Examples with CreationException org.elasticsearch.common.inject.CreationException used on opensource projects

Example 1 with CreationException

use of org.elasticsearch.common.inject.CreationException in project crate by crate.

the class NodeSettingsTest method testInvalidUnicastHost.

@Test
public void testInvalidUnicastHost() throws Exception {
    Settings.Builder builder = Settings.settingsBuilder().put("discovery.zen.ping.multicast.enabled", false).put("discovery.zen.ping.unicast.hosts", "nonexistinghost:4300").put("path.home", createConfigPath());
    Terminal terminal = Terminal.DEFAULT;
    Environment environment = CrateSettingsPreparer.prepareEnvironment(builder.build(), terminal);
    try {
        node = new CrateNode(environment);
        fail("Exception expected (failed to resolve address)");
    } catch (Throwable t) {
        assertThat(t, instanceOf(CreationException.class));
        Throwable rootCause = ((CreationException) t).getErrorMessages().iterator().next().getCause();
        assertThat(rootCause, instanceOf(IllegalArgumentException.class));
        assertThat(rootCause.getMessage(), is("Failed to resolve address for [nonexistinghost:4300]"));
    }
}

Example 2 with CreationException

use of org.elasticsearch.common.inject.CreationException in project crate by crate.

the class RepositoryServiceTest method testConvertException.

@Test
public void testConvertException() throws Throwable {
    expectedException.expect(RepositoryException.class);
    expectedException.expectMessage("[foo] failed: [foo] missing location");
    throw RepositoryService.convertRepositoryException(new RepositoryException("foo", "failed", new CreationException(ImmutableList.of(new Message(Collections.<Object>singletonList(10), "creation error", new RepositoryException("foo", "missing location"))))));
}

Example 3 with CreationException

use of org.elasticsearch.common.inject.CreationException in project crate by crate.

the class BootstrapProxy method init.

/**
     * This method is invoked by {@link Elasticsearch#main(String[])}
     * to startup elasticsearch.
     */
public static void init(String[] args) throws Throwable {
    // Set the system property before anything has a chance to trigger its use
    System.setProperty("es.logger.prefix", "");
    BootstrapCLIParser bootstrapCLIParser = new BootstrapCLIParser();
    CliTool.ExitStatus status = bootstrapCLIParser.execute(args);
    if (CliTool.ExitStatus.OK != status) {
        System.exit(status.status());
    }
    INSTANCE = new BootstrapProxy();
    boolean foreground = !"false".equals(System.getProperty("es.foreground", System.getProperty("es-foreground")));
    // handle the wrapper system property, if its a service, don't run as a service
    if (System.getProperty("wrapper.service", "XXX").equalsIgnoreCase("true")) {
        foreground = false;
    }
    Environment environment = initialSettings(foreground);
    Settings settings = environment.settings();
    setupLogging(settings, environment);
    checkForCustomConfFile();
    if (environment.pidFile() != null) {
        PidFile.create(environment.pidFile(), true);
    }
    if (System.getProperty("es.max-open-files", "false").equals("true")) {
        ESLogger logger = Loggers.getLogger(Bootstrap.class);
        logger.info("max_open_files [{}]", ProcessProbe.getInstance().getMaxFileDescriptorCount());
    }
    // warn if running using the client VM
    if (JvmInfo.jvmInfo().getVmName().toLowerCase(Locale.ROOT).contains("client")) {
        ESLogger logger = Loggers.getLogger(Bootstrap.class);
        logger.warn("jvm uses the client vm, make sure to run `java` with the server vm for best performance by adding `-server` to the command line");
    }
    try {
        if (!foreground) {
            Loggers.disableConsoleLogging();
            closeSystOut();
        }
        // fail if using broken version
        JVMCheck.check();
        INSTANCE.setup(true, settings, environment);
        INSTANCE.start();
        if (!foreground) {
            closeSysError();
        }
    } catch (Throwable e) {
        // disable console logging, so user does not see the exception twice (jvm will show it already)
        if (foreground) {
            Loggers.disableConsoleLogging();
        }
        ESLogger logger = Loggers.getLogger(Bootstrap.class);
        if (INSTANCE.node != null) {
            logger = Loggers.getLogger(Bootstrap.class, INSTANCE.node.settings().get("name"));
        }
        // HACK, it sucks to do this, but we will run users out of disk space otherwise
        if (e instanceof CreationException) {
            // guice: log the shortened exc to the log file
            ByteArrayOutputStream os = new ByteArrayOutputStream();
            PrintStream ps = new PrintStream(os, false, "UTF-8");
            new StartupError(e).printStackTrace(ps);
            ps.flush();
            logger.error("Guice Exception: {}", os.toString("UTF-8"));
        } else {
            // full exception
            logger.error("Exception", e);
        }
        // re-enable it if appropriate, so they can see any logging during the shutdown process
        if (foreground) {
            Loggers.enableConsoleLogging();
        }
        throw e;
    }
}

Example 4 with CreationException

use of org.elasticsearch.common.inject.CreationException in project elasticsearch by elastic.

the class Bootstrap method init.

/**
     * This method is invoked by {@link Elasticsearch#main(String[])} to startup elasticsearch.
     */
static void init(final boolean foreground, final Path pidFile, final boolean quiet, final Environment initialEnv) throws BootstrapException, NodeValidationException, UserException {
    // Set the system property before anything has a chance to trigger its use
    initLoggerPrefix();
    // force the class initializer for BootstrapInfo to run before
    // the security manager is installed
    BootstrapInfo.init();
    INSTANCE = new Bootstrap();
    final SecureSettings keystore = loadSecureSettings(initialEnv);
    Environment environment = createEnvironment(foreground, pidFile, keystore, initialEnv.settings());
    try {
        LogConfigurator.configure(environment);
    } catch (IOException e) {
        throw new BootstrapException(e);
    }
    checkForCustomConfFile();
    if (environment.pidFile() != null) {
        try {
            PidFile.create(environment.pidFile(), true);
        } catch (IOException e) {
            throw new BootstrapException(e);
        }
    }
    final boolean closeStandardStreams = (foreground == false) || quiet;
    try {
        if (closeStandardStreams) {
            final Logger rootLogger = ESLoggerFactory.getRootLogger();
            final Appender maybeConsoleAppender = Loggers.findAppender(rootLogger, ConsoleAppender.class);
            if (maybeConsoleAppender != null) {
                Loggers.removeAppender(rootLogger, maybeConsoleAppender);
            }
            closeSystOut();
        }
        // fail if somebody replaced the lucene jars
        checkLucene();
        // install the default uncaught exception handler; must be done before security is
        // initialized as we do not want to grant the runtime permission
        // setDefaultUncaughtExceptionHandler
        Thread.setDefaultUncaughtExceptionHandler(new ElasticsearchUncaughtExceptionHandler(() -> Node.NODE_NAME_SETTING.get(environment.settings())));
        INSTANCE.setup(true, environment);
        /* TODO: close this once s3 repository doesn't try to read during repository construction
            try {
                // any secure settings must be read during node construction
                IOUtils.close(keystore);
            } catch (IOException e) {
                throw new BootstrapException(e);
            }*/
        INSTANCE.start();
        if (closeStandardStreams) {
            closeSysError();
        }
    } catch (NodeValidationException | RuntimeException e) {
        // disable console logging, so user does not see the exception twice (jvm will show it already)
        final Logger rootLogger = ESLoggerFactory.getRootLogger();
        final Appender maybeConsoleAppender = Loggers.findAppender(rootLogger, ConsoleAppender.class);
        if (foreground && maybeConsoleAppender != null) {
            Loggers.removeAppender(rootLogger, maybeConsoleAppender);
        }
        Logger logger = Loggers.getLogger(Bootstrap.class);
        if (INSTANCE.node != null) {
            logger = Loggers.getLogger(Bootstrap.class, Node.NODE_NAME_SETTING.get(INSTANCE.node.settings()));
        }
        // HACK, it sucks to do this, but we will run users out of disk space otherwise
        if (e instanceof CreationException) {
            // guice: log the shortened exc to the log file
            ByteArrayOutputStream os = new ByteArrayOutputStream();
            PrintStream ps = null;
            try {
                ps = new PrintStream(os, false, "UTF-8");
            } catch (UnsupportedEncodingException uee) {
                assert false;
                e.addSuppressed(uee);
            }
            new StartupException(e).printStackTrace(ps);
            ps.flush();
            try {
                logger.error("Guice Exception: {}", os.toString("UTF-8"));
            } catch (UnsupportedEncodingException uee) {
                assert false;
                e.addSuppressed(uee);
            }
        } else if (e instanceof NodeValidationException) {
            logger.error("node validation exception\n{}", e.getMessage());
        } else {
            // full exception
            logger.error("Exception", e);
        }
        // re-enable it if appropriate, so they can see any logging during the shutdown process
        if (foreground && maybeConsoleAppender != null) {
            Loggers.addAppender(rootLogger, maybeConsoleAppender);
        }
        throw e;
    }
}