Examples with ExistExtensionServlet org.exist.http.servlets.ExistExtensionServlet used on opensource projects

Example 1 with ExistExtensionServlet

use of org.exist.http.servlets.ExistExtensionServlet in project exist by eXist-db.

the class JettyStart method run.

public synchronized void run(final String[] args, final Observer observer) {
    if (args.length == 0) {
        logger.error("No configuration file specified!");
        return;
    }
    Path jettyConfig = Paths.get(args[0]).normalize();
    boolean configFromClasspath = false;
    if (Files.notExists(jettyConfig)) {
        logger.warn("Configuration file: {} does not exist!", jettyConfig.toAbsolutePath().toString());
        final String jettyConfigFileName = FileUtils.fileName(jettyConfig.getFileName());
        logger.warn("Fallback... searching for configuration file on classpath: {}!etc/{}", getClass().getPackage().getName(), jettyConfigFileName);
        final URL jettyConfigUrl = getClass().getResource("etc/" + jettyConfigFileName);
        if (jettyConfigUrl != null) {
            try {
                jettyConfig = Paths.get(jettyConfigUrl.toURI()).normalize();
                configFromClasspath = true;
            } catch (final URISyntaxException e) {
                logger.error("Unable to retrieve configuration file from classpath: {}", e.getMessage(), e);
                return;
            }
        } else {
            logger.error("Unable to find configuration file on classpath!");
            return;
        }
    }
    final Map<String, String> configProperties;
    try {
        configProperties = getConfigProperties(jettyConfig.getParent());
        // modify JETTY_HOME and JETTY_BASE properties when running with classpath config
        if (configFromClasspath) {
            final String jettyClasspathHome = jettyConfig.getParent().getParent().toAbsolutePath().toString();
            System.setProperty(JETTY_HOME_PROP, jettyClasspathHome);
            configProperties.put(JETTY_HOME_PROP, jettyClasspathHome);
            configProperties.put(JETTY_BASE_PROP, jettyClasspathHome);
        }
        if (observer != null) {
            addObserver(observer);
        }
        logger.info("Running with Java {} [{} ({}) in {}]", System.getProperty("java.version", "(unknown java.version)"), System.getProperty("java.vendor", "(unknown java.vendor)"), System.getProperty("java.vm.name", "(unknown java.vm.name)"), System.getProperty("java.home", "(unknown java.home)"));
        logger.info("Approximate maximum amount of memory for JVM: {}", FileUtils.humanSize(Runtime.getRuntime().maxMemory()));
        logger.info("Number of processors available to JVM: {}", Runtime.getRuntime().availableProcessors());
        logger.info("Running as user '{}'", System.getProperty("user.name", "(unknown user.name)"));
        logger.info("[eXist Home : {}]", System.getProperty("exist.home", "unknown"));
        logger.info("[eXist Version : {}]", SystemProperties.getInstance().getSystemProperty("product-version", "unknown"));
        logger.info("[eXist Build : {}]", SystemProperties.getInstance().getSystemProperty("product-build", "unknown"));
        logger.info("[Git commit : {}]", SystemProperties.getInstance().getSystemProperty("git-commit", "unknown"));
        logger.info("[Operating System : {} {} {}]", System.getProperty("os.name"), System.getProperty("os.version"), System.getProperty("os.arch"));
        logger.info("[log4j.configurationFile : {}]", System.getProperty("log4j.configurationFile"));
        logger.info("[jetty Version: {}]", Jetty.VERSION);
        logger.info("[{} : {}]", JETTY_HOME_PROP, configProperties.get(JETTY_HOME_PROP));
        logger.info("[{} : {}]", JETTY_BASE_PROP, configProperties.get(JETTY_BASE_PROP));
        logger.info("[jetty configuration : {}]", jettyConfig.toAbsolutePath().toString());
        // configure the database instance
        SingleInstanceConfiguration config;
        if (args.length == 2) {
            config = new SingleInstanceConfiguration(args[1]);
        } else {
            config = new SingleInstanceConfiguration();
        }
        logger.info("Configuring eXist from {}", config.getConfigFilePath().map(Path::normalize).map(Path::toAbsolutePath).map(Path::toString).orElse("<UNKNOWN>"));
        BrokerPool.configure(1, 5, config, Optional.ofNullable(observer));
        // register the XMLDB driver
        final Database xmldb = new DatabaseImpl();
        xmldb.setProperty("create-database", "false");
        DatabaseManager.registerDatabase(xmldb);
    } catch (final Exception e) {
        logger.error("configuration error: {}", e.getMessage(), e);
        e.printStackTrace();
        return;
    }
    try {
        // load jetty configurations
        final List<Path> configFiles = getEnabledConfigFiles(jettyConfig);
        final List<Object> configuredObjects = new ArrayList<>();
        XmlConfiguration last = null;
        for (final Path confFile : configFiles) {
            logger.info("[loading jetty configuration : {}]", confFile.toString());
            try (final InputStream is = Files.newInputStream(confFile)) {
                final XmlConfiguration configuration = new XmlConfiguration(is);
                if (last != null) {
                    configuration.getIdMap().putAll(last.getIdMap());
                }
                configuration.getProperties().putAll(configProperties);
                configuredObjects.add(configuration.configure());
                last = configuration;
            }
        }
        // start Jetty
        final Optional<Server> maybeServer = startJetty(configuredObjects);
        if (!maybeServer.isPresent()) {
            logger.error("Unable to find a server to start in jetty configurations");
            throw new IllegalStateException();
        }
        final Server server = maybeServer.get();
        final Connector[] connectors = server.getConnectors();
        // Construct description of all ports opened.
        final StringBuilder allPorts = new StringBuilder();
        if (connectors.length > 1) {
            // plural s
            allPorts.append("s");
        }
        boolean establishedPrimaryPort = false;
        for (final Connector connector : connectors) {
            if (connector instanceof NetworkConnector) {
                final NetworkConnector networkConnector = (NetworkConnector) connector;
                if (!establishedPrimaryPort) {
                    this.primaryPort = networkConnector.getLocalPort();
                    establishedPrimaryPort = true;
                }
                allPorts.append(" ");
                allPorts.append(networkConnector.getLocalPort());
            }
        }
        // *************************************************************
        final List<URI> serverUris = getSeverURIs(server);
        if (!serverUris.isEmpty()) {
            this.primaryPort = serverUris.get(0).getPort();
        }
        logger.info("-----------------------------------------------------");
        logger.info("Server has started, listening on:");
        for (final URI serverUri : serverUris) {
            logger.info("{}", serverUri.resolve("/"));
        }
        logger.info("Configured contexts:");
        final LinkedHashSet<Handler> handlers = getAllHandlers(server.getHandler());
        for (final Handler handler : handlers) {
            if (handler instanceof ContextHandler) {
                final ContextHandler contextHandler = (ContextHandler) handler;
                logger.info("{} ({})", contextHandler.getContextPath(), contextHandler.getDisplayName());
            }
            if (handler instanceof ServletContextHandler) {
                final ServletContextHandler contextHandler = (ServletContextHandler) handler;
                final ServiceLoader<ExistExtensionServlet> services = ServiceLoader.load(ExistExtensionServlet.class);
                for (ExistExtensionServlet existExtensionServlet : services) {
                    final String pathSpec = existExtensionServlet.getPathSpec();
                    final String contextPath = contextHandler.getContextPath();
                    // Avoid "//" as logged prefix
                    final String normalizedPath = "/".equals(contextPath) ? pathSpec : contextPath + pathSpec;
                    logger.info("{} ({})", normalizedPath, existExtensionServlet.getServletInfo());
                    // Register servlet
                    contextHandler.addServlet(new ServletHolder(existExtensionServlet), pathSpec);
                }
            }
        }
        logger.info("-----------------------------------------------------");
        setChanged();
        notifyObservers(SIGNAL_STARTED);
    } catch (final MultiException e) {
        // Mute the BindExceptions
        boolean hasBindException = false;
        for (final Throwable t : e.getThrowables()) {
            if (t instanceof java.net.BindException) {
                hasBindException = true;
                logger.error("----------------------------------------------------------");
                logger.error("ERROR: Could not bind to port because {}", t.getMessage());
                logger.error(t.toString());
                logger.error("----------------------------------------------------------");
            }
        }
        // If it is another error, print stacktrace
        if (!hasBindException) {
            e.printStackTrace();
        }
        setChanged();
        notifyObservers(SIGNAL_ERROR);
    } catch (final SocketException e) {
        logger.error("----------------------------------------------------------");
        logger.error("ERROR: Could not bind to port because {}", e.getMessage());
        logger.error(e.toString());
        logger.error("----------------------------------------------------------");
        setChanged();
        notifyObservers(SIGNAL_ERROR);
    } catch (final Exception e) {
        e.printStackTrace();
        setChanged();
        notifyObservers(SIGNAL_ERROR);
    }
}