org.elasticsearch.node.NodeValidationException Java Examples

@BeforeClass
@SuppressWarnings({"rawtypes", "unchecked"})
public static void startElasticsearch() throws NodeValidationException {
  final Settings settings = Settings.builder()
    .put("path.home", ES_WORKING_DIR)
    .put("path.data", ES_WORKING_DIR + "/data")
    .put("path.logs", ES_WORKING_DIR + "/logs")
    .put("transport.type", "netty4")
    .put("http.type", "netty4")
    .put("cluster.name", clusterName)
    .put("http.port", HTTP_PORT)
    .put("transport.tcp.port", HTTP_TRANSPORT_PORT)
    .put("network.host", "127.0.0.1")
    .build();
  final Collection plugins = Collections.singletonList(Netty4Plugin.class);
  node = new PluginConfigurableNode(settings, plugins);
  node.start();
}
 

@BeforeAll
public static void init() throws IOException, InterruptedException, NodeValidationException {

    logger.debug("Starting embedded node");
    String resource = "elasticsearch_embedded.yml";
    Settings.Builder settings = Settings.builder().loadFromStream(resource,
            ElasticsearchAwareTest.class.getResourceAsStream(resource), false);

    embeddedNode = EmbeddedElastic.builder().withElasticVersion("5.0.0")
            .withSetting(PopularProperties.TRANSPORT_TCP_PORT, 9300)
            .withSetting(PopularProperties.CLUSTER_NAME, "elasticsearch").build();
    embeddedNode.start();

    logger.debug("Started embedded node");

}
 

private EmbeddedElasticsearchServer(String defaultDataDirectory, int port) throws NodeValidationException {
    this.dataDirectory = defaultDataDirectory;
    this.port = port;

    Settings.Builder settings = Settings.builder()
            .put("http.enabled", "true")
            .put("transport.type", "local")
            .put("http.type", "netty3")
            .put("path.data", dataDirectory)
            .put("path.home", DEFAULT_HOME_DIRECTORY)
            .put("script.inline", "on")
            .put("node.max_local_storage_nodes", 10000)
            .put("script.stored", "on");

    startNodeInAvailablePort(settings);
}
 

private void startNodeInAvailablePort(Settings.Builder settings) throws NodeValidationException {
    int findFreePortRetries = MAX_PORT_RETRIES;
    boolean success = false;

    while(!success) {
        try {
            settings.put("http.port", String.valueOf(this.port));

            // this a hack in order to load Groovy plug in since we want to enable the usage of scripts
            node = new NodeExt(settings.build() , Arrays.asList(Netty3Plugin.class, PainlessPlugin.class, ReindexPlugin.class, VectorScoringPlugin.class));
            node.start();
            success = true;
            System.out.println(EmbeddedElasticsearchServer.class.getName() + ": Using port: " + this.port);
        } catch (BindHttpException exception) {
            if(findFreePortRetries == 0) {
                System.out.println("Could not find any free port in range: [" + (this.port - MAX_PORT_RETRIES) + " - " + this.port+"]");
                throw exception;
            }
            findFreePortRetries--;
            System.out.println("Port already in use (" + this.port + "). Trying another port...");
            this.port = randomPort();
        }
    }
}
 

@Bean(destroyMethod="close")
Node newNode() throws NodeValidationException {
  final Path tempDir = createTempDir().toPath();
  final Settings settings = Settings.builder()
    .put(ClusterName.CLUSTER_NAME_SETTING.getKey(), new ClusterName("single-node-cluster" + System.nanoTime()))
    .put(Environment.PATH_HOME_SETTING.getKey(), tempDir)
    .put(Environment.PATH_REPO_SETTING.getKey(), tempDir.resolve("repo"))
    .put(Environment.PATH_SHARED_DATA_SETTING.getKey(), createTempDir().getParent())
    .put("node.name", "single-node")
    .put("script.inline", "true")
    .put("script.stored", "true")
    .put(ScriptService.SCRIPT_MAX_COMPILATIONS_PER_MINUTE.getKey(), 1000)
    .put(EsExecutors.PROCESSORS_SETTING.getKey(), 1)
    .put(NetworkModule.HTTP_ENABLED.getKey(), false)
    .put("discovery.type", "zen")
    .put("transport.type", "local")
    .put(Node.NODE_DATA_SETTING.getKey(), true)
    .put(NODE_ID_SEED_SETTING.getKey(), System.nanoTime())
    .build();
  return new Node(settings).start(); // NOSONAR
}
 

static void startElasticEmbeddedServer() throws NodeValidationException {
  Settings settings =
      Settings.builder()
          .put("node.data", TRUE)
          .put("network.host", ELASTIC_IN_MEM_HOSTNAME)
          .put("http.port", port)
          .put("path.data", elasticTempFolder.getRoot().getPath())
          .put("path.home", elasticTempFolder.getRoot().getPath())
          .put("transport.type", "local")
          .put("http.enabled", TRUE)
          .put("node.ingest", TRUE)
          .build();
  node = new PluginNode(settings);
  node.start();
  LOG.info("Elastic in memory server started.");
  prepareElasticIndex();
  LOG.info(
      "Prepared index "
          + ELASTIC_INDEX_NAME
          + "and populated data on elastic in memory server.");
}
 

public HttpHost start() {
    var watch = new StopWatch();
    this.dataPath = Files.tempDir();
    try {
        Settings.Builder settings = Settings.builder();
        settings.put(ClusterName.CLUSTER_NAME_SETTING.getKey(), "test")
                .put(Node.NODE_NAME_SETTING.getKey(), "test")
                .put(Environment.PATH_HOME_SETTING.getKey(), dataPath)
                .put(NetworkService.GLOBAL_NETWORK_BIND_HOST_SETTING.getKey(), "_local_")
                .put(DiscoveryModule.DISCOVERY_TYPE_SETTING.getKey(), DiscoveryModule.SINGLE_NODE_DISCOVERY_TYPE);
        node = new LocalNode(settings.build());
        node.start();
        // on same local server, there may be multiple es started, e.g. multiple test jobs on shared build server, this is to retrieve actual http port
        return new HttpHost("localhost", node.injector().getInstance(HttpServerTransport.class).boundAddress().publishAddress().getPort());
    } catch (NodeValidationException e) {
        throw new Error(e);
    } finally {
        logger.info("create local elasticsearch node, dataPath={}, elapsed={}", dataPath, watch.elapsed());
    }
}
 

public EmbeddedElasticsearch5(Path dataPath, String clusterName, int httpPort, int transportPort)
    throws NodeValidationException {
  this.clusterName = clusterName;
  this.httpPort = httpPort;
  this.transportPort = transportPort;
  this.dataPath = dataPath;

  // NB 'transport.type' is not 'local' as connecting via separate transport client
  Settings settings =
      Settings.builder()
          .put("path.home", dataPath.toString())
          .put("cluster.name", clusterName)
          .put("http.port", Integer.toString(httpPort))
          .put("transport.tcp.port", Integer.toString(transportPort))
          .put("http.enabled", true)
          .build();

  Collection<Class<? extends Plugin>> plugins = Collections.singletonList(Netty4Plugin.class);
  node = new PluginConfigurableNode(settings, plugins);
  node.start();
}
 

@Override
public void init() throws ServletException {
    System.setProperty("es.set.netty.runtime.available.processors", "false");

    Settings settings = Settings.builder()
        .put("http.port", AvailablePortFinder.getAndStoreNextAvailable("es-port.txt"))
        .put("http.cors.enabled", true)
        .put("http.cors.allow-origin", "*")
        .put("path.data", DATA_PATH)
        .put("path.home", HOME_PATH)
        .build();

    List<Class<? extends Plugin>> plugins = new ArrayList<>();
    plugins.add(Netty4Plugin.class);

    node = new ElasticsearchNode(settings, plugins);
    try {
        node.start();
    } catch (NodeValidationException e) {
        throw new ServletException(e);
    }
}
 

/**
 * Start a closed node.
 *
 * @param i the number of nodes
 * @return true if the node is started.
 */
@SuppressWarnings("resource")
public boolean startNode(final int i) {
    if (i >= nodeList.size()) {
        return false;
    }
    if (!nodeList.get(i).isClosed()) {
        return false;
    }
    final Node node = new ClusterRunnerNode(envList.get(i), pluginList);
    try {
        node.start();
        nodeList.set(i, node);
        return true;
    } catch (final NodeValidationException e) {
        print(e.getLocalizedMessage());
    }
    return false;
}
 

void startNode() {
    try {
        node.start();
    } catch (NodeValidationException e) {
        throw new RuntimeException(e);
    }
}
 

/**
 * Starts current node
 */
public void start() {
  Preconditions.checkState(!isStarted, "already started");
  try {
    node.start();
    this.isStarted = true;
  } catch (NodeValidationException e) {
    throw new RuntimeException(e);
  }
}
 

/**
 * Executes the bootstrap checks if the node has the transport protocol bound to a non-loopback interface. If the system property
 * {@code es.enforce.bootstrap.checks} is set to {@code true} then the bootstrap checks will be enforced regardless of whether or not
 * the transport protocol is bound to a non-loopback interface.
 *
 * @param boundTransportAddress the node network bindings
 */
static void check(final Settings settings,
                  final BoundTransportAddress boundTransportAddress,
                  List<BootstrapCheck> additionalChecks) throws NodeValidationException {
    final List<BootstrapCheck> builtInChecks = checks();
    final List<BootstrapCheck> combinedChecks = new ArrayList<>(builtInChecks);
    combinedChecks.addAll(additionalChecks);
    check(settings,
          enforceLimits(boundTransportAddress, DiscoveryModule.DISCOVERY_TYPE_SETTING.get(settings)),
          Collections.unmodifiableList(combinedChecks));
}
 

private void init(final boolean daemonize, final boolean quiet, Environment env)
    throws NodeValidationException, UserException {
    try {
        BootstrapProxy.init(!daemonize, quiet, env);
    } catch (BootstrapException | RuntimeException e) {
        // format exceptions to the console in a special way
        // to avoid 2MB stacktraces from guice, etc.
        throw new StartupExceptionProxy(e);
    }
}
 

@Override
protected void execute(Terminal terminal, OptionSet options, Environment env) throws Exception {
    if (options.nonOptionArguments().isEmpty() == false) {
        throw new UserException(ExitCodes.USAGE, "Positional arguments not allowed, found " + options.nonOptionArguments());
    }
    if (options.has(versionOption)) {
        if (options.has(daemonizeOption) || options.has(pidfileOption)) {
            throw new UserException(ExitCodes.USAGE, "CrateDB version option is mutually exclusive with any other option");
        }
        terminal.println("Version: " + Version.CURRENT
                         + ", Build: " + Build.CURRENT.hashShort() + "/" + Build.CURRENT.timestamp()
                         + ", JVM: " + JvmInfo.jvmInfo().version());
        return;
    }

    final boolean daemonize = options.has(daemonizeOption);

    final Path pidFile = pidfileOption.value(options);
    env = addPidFileSetting(pidFile, env);

    final boolean quiet = options.has(quietOption);

    try {
        init(daemonize, quiet, env);
    } catch (NodeValidationException e) {
        throw new UserException(ExitCodes.CONFIG, e.getMessage());
    }
}
 

/**
 * Starts current node
 */
void start() {
  Preconditions.checkState(!isStarted, "already started");
  try {
    node.start();
    this.isStarted = true;
  } catch (NodeValidationException e) {
    throw new RuntimeException(e);
  }
}
 

public MockElasticsearchServer(String directory) throws NodeValidationException {
    this.DATA_DIRECTORY = UUID.randomUUID()
                                  .toString() + "/" + directory;
    Settings settings = Settings.builder()
            .put("http.enabled", "false")
            .put("path.home", "target/" + DATA_DIRECTORY)
            .put("transport.type", "local")
            .build();
    Stopwatch stopwatch = Stopwatch.createStarted();
    node = new Node(settings).start();
    System.out.printf("TimeTakenForEstart: %d%n", stopwatch.elapsed(TimeUnit.MILLISECONDS));
}
 

/**
 * Starts current node
 */
public void start() {
  Preconditions.checkState(!isStarted, "already started");
  try {
    node.start();
    this.isStarted = true;
  } catch (NodeValidationException e) {
    throw TestUtil.rethrow(e);
  }
}
 

public EmbeddedElasticsearch5() throws NodeValidationException, IOException {
  this(
      Files.createTempDirectory("elasticsearch"),
      "test-cluster",
      RandomPort.generate(),
      RandomPort.generate());
}
 

/**
 * Starts current node.
 */
public void start() {
    Preconditions.checkState(! isStarted, "already started");
    try {
        node.start();
        this.isStarted = true;
    } catch (NodeValidationException ex) {
        throw new RuntimeException(ex);
    }
}
 

private void setup(boolean addShutdownHook, Environment environment) throws BootstrapException {
    Settings settings = environment.settings();
    initializeNatives(
        BootstrapSettings.MEMORY_LOCK_SETTING.get(settings),
        BootstrapSettings.CTRLHANDLER_SETTING.get(settings));

    // initialize probes before the security manager is installed
    initializeProbes();

    if (addShutdownHook) {
        Runtime.getRuntime().addShutdownHook(new Thread(() -> {
            try {
                IOUtils.close(node);
                LoggerContext context = (LoggerContext) LogManager.getContext(false);
                Configurator.shutdown(context);
            } catch (IOException ex) {
                throw new ElasticsearchException("failed to stop node", ex);
            }
        }));
    }

    try {
        // look for jar hell
        final Logger logger = LogManager.getLogger(JarHell.class);
        JarHell.checkJarHell(logger::debug);
    } catch (IOException | URISyntaxException e) {
        throw new BootstrapException(e);
    }

    IfConfig.logIfNecessary();

    node = new CrateNode(environment) {

        @Override
        protected void validateNodeBeforeAcceptingRequests(BoundTransportAddress boundTransportAddress,
                                                           List<BootstrapCheck> bootstrapChecks) throws NodeValidationException {
            BootstrapChecks.check(settings, boundTransportAddress, bootstrapChecks);
        }
    };

}
 

private void start() throws NodeValidationException {
    node.start();
    keepAliveThread.start();
}
 

@BeforeClass
public static void startServer() throws NodeValidationException, IOException {
  port = NetworkTestHelper.getAvailableLocalPort();
  ElasticEmbeddedServer.startElasticEmbeddedServer();
}
 

private EmbeddedElasticsearchServer(String dataDirectory) throws NodeValidationException {
    this(dataDirectory, randomPort());
}
 

public EmbeddedElasticsearchServer() throws NodeValidationException {
    this(DEFAULT_DATA_DIRECTORY);
}
 

/**
 * Executes the provided checks and fails the node if {@code enforceLimits} is {@code true}, otherwise logs warnings. If the system
 * property {@code es.enforce.bootstrap.checks} is set to {@code true} then the bootstrap checks will be enforced regardless of whether
 * or not the transport protocol is bound to a non-loopback interface.
 *
 * @param enforceLimits {@code true} if the checks should be enforced or otherwise warned
 * @param checks        the checks to execute
 */
static void check(
    final Settings settings,
    final boolean enforceLimits,
    final List<BootstrapCheck> checks) throws NodeValidationException {
    check(settings, enforceLimits, checks, Loggers.getLogger(BootstrapChecks.class));
}