public static void main(String[] args) throws IOException { Log4jESLoggerFactory.getRootLogger().setLevel("ERROR"); Settings settings = ImmutableSettings.settingsBuilder().put("cluster.name", "ciphergateway").build(); //Use one and only one Client in your JVM. It's threadsafe. Client client = new TransportClient(settings) .addTransportAddress(new InetSocketTransportAddress("localhost", 9300)); Long start = System.currentTimeMillis(); // exportES(client); // deleteES(client); // importES(client); // searchES(client); exportAndDeleteES(client); client.close(); Long end = System.currentTimeMillis(); System.out.println("用时: " + (end - start) + " ms"); }
public EsStore(String host, int port) { String clusterName = Configuration.getProperties().getString("es_cluster_name", "soundwave"); Settings settings = ImmutableSettings.settingsBuilder().put("cluster.name", clusterName) .put("client.transport.sniff", false).build(); esClient = new TransportClient(settings) .addTransportAddress( new InetSocketTransportAddress(host, port)); }
@Override public void commit() { if (this.client != null) { this.flushIndex(true); this.client.admin().indices() .refresh(new RefreshRequest(this.indexName)).actionGet(); // enable index auto refresh ImmutableSettings.Builder indexSettings = ImmutableSettings .settingsBuilder(); indexSettings.put("refresh_interval", 1); this.client.admin().indices().prepareUpdateSettings(this.indexName) .setSettings(indexSettings).execute().actionGet(); this.client.admin().indices().prepareOptimize(this.indexName) .setMaxNumSegments(5).execute().actionGet(); } }
@BeforeClass public static void startElasticsearch() throws Exception { removeOldDataDir(ES_WORKING_DIR + "/" + clusterName); Settings settings = ImmutableSettings.builder() .put("path.home", ES_WORKING_DIR) .put("path.conf", ES_WORKING_DIR) .put("path.data", ES_WORKING_DIR) .put("path.work", ES_WORKING_DIR) .put("path.logs", ES_WORKING_DIR) .put("http.port", HTTP_PORT) .put("transport.tcp.port", HTTP_TRANSPORT_PORT) .put("index.number_of_shards", "1") .put("index.number_of_replicas", "0") .put("discovery.zen.ping.multicast.enabled", "false") .build(); node = nodeBuilder().settings(settings).clusterName(clusterName).client(false).node(); node.start(); }
public void connect(String httpAddress, String transportAddress) { String cluster_name = getClusterName(httpAddress.split(",")); Settings settings = ImmutableSettings.settingsBuilder() .put("client.transport.sniff", true) .put("cluster.name", cluster_name).build(); TransportClient client = new TransportClient(settings); for (String host : transportAddress.split(",")) { if (StringUtils.isBlank(host)) { continue; } String ip = StringUtils.substringBefore(host, ":"); String port = StringUtils.substringAfter(host, ":"); client.addTransportAddress(new InetSocketTransportAddress(ip, Integer.valueOf(port))); } searchDao = new SearchDao(client); }
/** * * @Description 初始化客户端 * @param clusterNodes 多个集群节点用逗号分隔:"ip:9300,ip:9300" * @param clusterName 如:elasticsearch */ public static void initClient(String clusterNodes, String clusterName) { if (client == null) { lock.lock(); try { if (client == null) { Settings settings = ImmutableSettings.settingsBuilder() .put("client.transport.sniff", true) .put("client", true).put("data", false) .put("clusterName", clusterName).build(); client = new TransportClient(settings); for (String clusterNode : clusterNodes.split(",")) { String ip = clusterNode.split(":")[0]; String port = clusterNode.split(":")[1]; client.addTransportAddress(new InetSocketTransportAddress( ip, Integer.parseInt(port))); } } } finally { lock.unlock(); } } }
/** * If ES already contains this instance's target index, then do nothing. * Otherwise, create the index, then wait {@link #CREATE_SLEEP}. * <p> * The {@code client} field must point to a live, connected client. * The {@code indexName} field must be non-null and point to the name * of the index to check for existence or create. * * @param config the config for this ElasticSearchIndex * @throws java.lang.IllegalArgumentException if the index could not be created */ private void checkForOrCreateIndex(Configuration config) { Preconditions.checkState(null != client); //Create index if it does not already exist IndicesExistsResponse response = client.admin().indices().exists(new IndicesExistsRequest(indexName)).actionGet(); if (!response.isExists()) { ImmutableSettings.Builder settings = ImmutableSettings.settingsBuilder(); ElasticSearchSetup.applySettingsFromTitanConf(settings, config, ES_CREATE_EXTRAS_NS); CreateIndexResponse create = client.admin().indices().prepareCreate(indexName) .setSettings(settings.build()).execute().actionGet(); try { final long sleep = config.get(CREATE_SLEEP); log.debug("Sleeping {} ms after {} index creation returned from actionGet()", sleep, indexName); Thread.sleep(sleep); } catch (InterruptedException e) { throw new TitanException("Interrupted while waiting for index to settle in", e); } if (!create.isAcknowledged()) throw new IllegalArgumentException("Could not create index: " + indexName); } }
@Override public void start() { // Start embedded Elasticsearch node ImmutableSettings.Builder settings = ImmutableSettings.settingsBuilder(); settings.put("node.name", "test-node"); settings.put("path.data", "build/data"); m_node = NodeBuilder.nodeBuilder() .settings(settings) .clusterName("test-cluster") .data(true) .local(true) .node(); m_client = m_node.client(); // Start polling for index count m_timerId = vertx.setPeriodic(1000L, this); // Start tests super.start(); }
private void createAuditIndex() { logger.info("will create audit index"); final Settings auditIndexSettings = ImmutableSettings.builder().put(SETTING_NUMBER_OF_SHARDS, 3).put(SETTING_NUMBER_OF_REPLICAS, 1) .build(); final XContentBuilder auditIndexEventsTypeMapping = Change.getMapping(); client.admin().indices().prepareCreate(auditIndexName).addMapping(AUDIT_INDEX_INDEXING_TYPE, auditIndexEventsTypeMapping) .setSettings(auditIndexSettings).execute(new ActionListener<CreateIndexResponse>() { @Override public void onResponse(final CreateIndexResponse response) { if (!response.isAcknowledged()) { logger.error("Failed to create {}.", auditIndexName); throw new ElasticsearchException("Failed to create index " + auditIndexName); } } @Override public void onFailure(final Throwable e) { logger.error("Failed to create {}", e, auditIndexName); } }); }
private static ImmutableSettings.Builder setRandomTranslogSettings(final Random random, final ImmutableSettings.Builder builder) { if (random.nextBoolean()) { builder.put(TranslogService.INDEX_TRANSLOG_FLUSH_THRESHOLD_OPS, RandomInts.randomIntBetween(random, 1, 10000)); } if (random.nextBoolean()) { builder.put(TranslogService.INDEX_TRANSLOG_FLUSH_THRESHOLD_SIZE, new ByteSizeValue(RandomInts.randomIntBetween(random, 1, 300), ByteSizeUnit.MB)); } if (random.nextBoolean()) { builder.put(TranslogService.INDEX_TRANSLOG_FLUSH_THRESHOLD_PERIOD, TimeValue.timeValueMinutes(RandomInts.randomIntBetween(random, 1, 60))); } if (random.nextBoolean()) { builder.put(TranslogService.INDEX_TRANSLOG_FLUSH_INTERVAL, TimeValue.timeValueMillis(RandomInts.randomIntBetween(random, 1, 10000))); } if (random.nextBoolean()) { builder.put(TranslogService.INDEX_TRANSLOG_DISABLE_FLUSH, random.nextBoolean()); } return builder; }
/** * Returns a settings object used in {@link #createIndex(String...)} and {@link #prepareCreate(String)} and friends. * This method can be overwritten by subclasses to set defaults for the indices that are created by the test. * By default it returns a settings object that sets a random number of shards. Number of shards and replicas * can be controlled through specific methods. */ public Settings indexSettings() { final ImmutableSettings.Builder builder = ImmutableSettings.builder(); if (randomizeNumberOfShardsAndReplicas()) { final int numberOfShards = numberOfShards(); if (numberOfShards > 0) { builder.put(SETTING_NUMBER_OF_SHARDS, numberOfShards).build(); } final int numberOfReplicas = numberOfReplicas(); if (numberOfReplicas >= 0) { builder.put(SETTING_NUMBER_OF_REPLICAS, numberOfReplicas).build(); } } // 30% of the time if (useCustomDataPath() && (randomInt(9) < 3)) { final String dataPath = "data/custom-" + CHILD_JVM_ID + "/" + UUID.randomUUID().toString(); logger.info("using custom data_path for index: [{}]", dataPath); builder.put(IndexMetaData.SETTING_DATA_PATH, dataPath); } return builder.build(); }
/** * Return settings that could be used to start a node that has the given zipped home directory. */ protected Settings prepareBackwardsDataDir(final File backwardsIndex, final Object... settings) throws IOException { final File indexDir = newTempDir(); final File dataDir = new File(indexDir, "data"); TestUtil.unzip(backwardsIndex, indexDir); assertTrue(dataDir.exists()); final String[] list = dataDir.list(); if (list == null || list.length > 1) { throw new IllegalStateException("Backwards index must contain exactly one cluster"); } final File src = new File(dataDir, list[0]); final File dest = new File(dataDir, internalCluster().getClusterName()); assertTrue(src.exists()); src.renameTo(dest); assertFalse(src.exists()); assertTrue(dest.exists()); final ImmutableSettings.Builder builder = ImmutableSettings.builder().put(settings).put("gateway.type", "local") // this is important we need to recover from gateway .put("path.data", dataDir.getPath()); final File configDir = new File(indexDir, "config"); if (configDir.exists()) { builder.put("path.conf", configDir.getPath()); } return builder.build(); }
@Override public void init(Map<String, String> props) { String host = props.get(PropConst.HOST); if (host == null) { throw new IllegalArgumentException("Host does not specified"); } String port = props.get(PropConst.PORT); if (port == null) { throw new IllegalArgumentException("Port does not specified"); } String clusterName = props.get(PropConst.CLUSTER_NAME); if (clusterName == null) { throw new IllegalArgumentException("Cluster name does not specified"); } client = (new TransportClient(ImmutableSettings.settingsBuilder().put("cluster.name", clusterName).build())) .addTransportAddress(new InetSocketTransportAddress(host, Integer.valueOf(port))); }
public static Client getClient(Map stormConf, String boltType) { String host = ConfUtils.getString(stormConf, "es." + boltType + ".hostname", "localhost"); Client client; // connection to ES if (host.equalsIgnoreCase("localhost")) { Node node = org.elasticsearch.node.NodeBuilder.nodeBuilder() .clusterName("elasticsearch").client(true).node(); client = node.client(); } else { Settings settings = ImmutableSettings.settingsBuilder() .put("cluster.name", "elasticsearch").build(); client = new TransportClient(settings) .addTransportAddress(new InetSocketTransportAddress(host, 9300)); } return client; }
public static Client getJavaClient() { if (javaClient == null) { try { String es_cluster_name=AnalyseLogTaskLauncher.taskConfig.getEs_cluster_name(); ImmutableSettings.Builder builder = ImmutableSettings.settingsBuilder().put("cluster.name", es_cluster_name); Settings settings = builder.build(); List<String> cluster_ips = AnalyseLogTaskLauncher.taskConfig.getEs_ips(); TransportClient transportClient = new TransportClient(settings); for (String string : cluster_ips) { String[] strs=string.split(":"); transportClient.addTransportAddress(new InetSocketTransportAddress(strs[0], Integer.parseInt(strs[1]))); } javaClient = transportClient; } catch (Exception e) { e.printStackTrace(); } } return javaClient; }
@Bean(name = "appSearchElasticNode", destroyMethod = "close") public Node getElasticSearchNode( @Value("${elastic.hosts}") String hosts, @Value("${elastic.cluster.name}") String clusterName, @Value("${elastic.node.local}") boolean localMode) { NodeBuilder builder = nodeBuilder().clusterName(clusterName); if (localMode) { builder.local(true); } else { builder.settings( ImmutableSettings.builder() .put("discovery.zen.ping.unicast.hosts", hosts) .put("discovery.zen.ping.multicast.enabled", false) .put("node.client", true) .put("node.master", false) .put("node.data", false)); } return builder.node(); }
@Test public void testClusterSrvDiscoveryWith5Nodes() throws Exception { ImmutableSettings.Builder b = settingsBuilder() .put("node.mode", "network") .put("discovery.zen.ping.multicast.enabled", "false") .put("discovery.type", "srvtest") .put(SrvUnicastHostsProvider.DISCOVERY_SRV_QUERY, Constants.TEST_QUERY); assertEquals(cluster().size(), 0); internalCluster().startNode(b.put("transport.tcp.port", String.valueOf(Constants.NODE_0_TRANSPORT_TCP_PORT)).build()); internalCluster().startNode(b.put("transport.tcp.port", String.valueOf(Constants.NODE_1_TRANSPORT_TCP_PORT)).build()); internalCluster().startNode(b.put("transport.tcp.port", String.valueOf(Constants.NODE_2_TRANSPORT_TCP_PORT)).build()); internalCluster().startNode(b.put("transport.tcp.port", String.valueOf(Constants.NODE_3_TRANSPORT_TCP_PORT)).build()); internalCluster().startNode(b.put("transport.tcp.port", String.valueOf(Constants.NODE_4_TRANSPORT_TCP_PORT)).build()); assertEquals(cluster().size(), 5); }
public Client getClient() { if (client == null) { log.log(Level.INFO, "Elastic client doesn't exists, creating new one"); if (node == null) { log.log(Level.INFO, "Elastic client node doesn't exists, creating new one"); node = NodeBuilder.nodeBuilder() .settings(ImmutableSettings.settingsBuilder() .put("http.enabled", false) .put("network.host", "_" + System.getenv("SINKIT_NIC") + ":ipv4_") .putArray("discovery.zen.ping.unicast.hosts", System.getenv("SINKIT_ELASTIC_HOST") + ":" + System.getenv("SINKIT_ELASTIC_PORT")) .put("cluster.name", System.getenv("SINKIT_ELASTIC_CLUSTER")) .put("discovery.zen.ping.multicast.enabled", true) .put("discovery.zen.ping.timeout", "3s") .put("discovery.zen.minimum_master_nodes", 1) ) .client(true) .data(false) .node(); } client = node.client(); } return client; }
public Client createClient() { final AtomicReference<Client> elasticsearchClient = new AtomicReference<>(); await().atMost(30, TimeUnit.SECONDS).pollDelay(1, TimeUnit.SECONDS).until(() -> { Client c = new TransportClient(ImmutableSettings.settingsBuilder().put("cluster.name", elasticsearchClusterName).build()).addTransportAddress(new InetSocketTransportAddress(getIpAddress(), 9300)); try { c.admin().cluster().health(Requests.clusterHealthRequest("_all")).actionGet(); } catch (ElasticsearchException e) { c.close(); return false; } elasticsearchClient.set(c); return true; }); assertEquals(elasticsearchClusterName, elasticsearchClient.get().admin().cluster().health(Requests.clusterHealthRequest("_all")).actionGet().getClusterName()); return elasticsearchClient.get(); }
private GetSettingsResponse doParse(BytesReference bytesReference) { try (XContentParser parser = XContentHelper.createParser(bytesReference)) { ImmutableOpenMap.Builder<String, Settings> builder = ImmutableOpenMap.builder(); Map<String, Object> map = parser.map(); for (String index : map.keySet()) { Map<String, Map<String, Object>> indexSettings = getAsNestedStringToMapMap(map, index); Map<String, Map<String, Object>> settingsAsMap = getAsNestedStringToMapMap(indexSettings, "settings"); Map<String, String> flattenedSettings = flattenSettings(settingsAsMap); Settings settings = ImmutableSettings.builder().put(flattenedSettings).build(); builder.put(index, settings); } this.indexToSettings = builder.build(); return this; } catch (IOException e) { throw new RuntimeException(e); } }
@Test public void should_create_index_with_settings() throws ExecutionException, InterruptedException { String settings = TestFilesUtils.readFromClasspath("com/github/obourgain/elasticsearch/http/handler/admin/indices/create_index_with_settings.json"); CreateIndexResponse response = httpClient.admin().indices() .createIndex(Requests.createIndexRequest(THE_INDEX) .settings(settings)) .get(); Assertions.assertThat(response.isAcknowledged()).isTrue(); GetSettingsResponse getSettingsResponse = transportClient.admin().indices().getSettings(new GetSettingsRequest().indices(THE_INDEX)).actionGet(); ImmutableOpenMap<String, Settings> indexToSettings = getSettingsResponse.getIndexToSettings(); Assertions.assertThat(indexToSettings.iterator().hasNext()).isTrue(); Assertions.assertThat(indexToSettings.iterator().next().key).isEqualTo(THE_INDEX); Settings expectedSettings = ImmutableSettings.builder().loadFromSource(settings).build(); Settings actualSettings = indexToSettings.get(THE_INDEX); assertSettingsEquals(expectedSettings, actualSettings); }
@Override public void exitConnect_stmt(EQLParser.Connect_stmtContext ctx) { String clusterName = null; if(ctx.clusterName != null) { clusterName = ctx.clusterName.getText(); Settings settings = ImmutableSettings.settingsBuilder() .put("cluster.name", clusterName).build(); runtimeCtx.client = new TransportClient(settings); } else { runtimeCtx.client = new TransportClient(); } List<EQLParser.HostportContext> hps = ctx.hps; for(EQLParser.HostportContext hpc : hps) { HostPort hp = (HostPort)getValue(hpc); TransportClient tc = (TransportClient) runtimeCtx.client; tc.addTransportAddress(new InetSocketTransportAddress(hp.getHost(), hp.getPort())); } }
private Client getClientForTransportProtocol() { final Client client; final Builder settingsBuilder = ImmutableSettings.builder(); settingsBuilder.put("name", "DataCleaner"); settingsBuilder.put("cluster.name", _clusterName); if (!StringUtils.isNullOrEmpty(_username) && !StringUtils.isNullOrEmpty(_password)) { settingsBuilder.put("shield.user", _username + ":" + _password); if (_ssl) { if (!Strings.isNullOrEmpty(_keystorePath)) { settingsBuilder.put("shield.ssl.keystore.path", _keystorePath); settingsBuilder.put("shield.ssl.keystore.password", _keystorePassword); } settingsBuilder.put("shield.transport.ssl", "true"); } } final Settings settings = settingsBuilder.build(); client = new TransportClient(settings); ((TransportClient) client).addTransportAddress(new InetSocketTransportAddress(_hostname, _port)); return client; }
public ElasticsearchInsert(KafkaStream stream, String esHost, int threadNum, int bulkSize, String esCluster) { this.stream = stream; this.threadNum = threadNum; this.bulkSize = bulkSize; elasticSearchCluster = esCluster; elasticSearchHost = esHost; Settings settings = ImmutableSettings.settingsBuilder().put("cluster.name", elasticSearchCluster).build(); client = new TransportClient(settings).addTransportAddress(new InetSocketTransportAddress(elasticSearchHost, elasticSearchPort)); NodesInfoResponse response = client.admin().cluster().nodesInfo(new NodesInfoRequest().timeout("60")).actionGet(); nodesMap = response.getNodesMap(); for(String k: nodesMap.keySet()){ if(!elasticSearchHost.equals(nodesMap.get(k).getHostname())) { client.addTransportAddress(new InetSocketTransportAddress(nodesMap.get(k).getHostname(), elasticSearchPort)); } } LOG.info("init es"); }
@Test public void assertTop1OneShard() { client.admin().indices().prepareCreate("topk-0").setSettings(ImmutableSettings.settingsBuilder().put("index.number_of_shards", 1)).execute().actionGet(); client.prepareIndex("topk-0", "type0", "doc0").setSource("field0", "foo").execute().actionGet(); client.prepareIndex("topk-0", "type0", "doc1").setSource("field0", "foo").execute().actionGet(); client.prepareIndex("topk-0", "type0", "doc2").setSource("field0", "bar").setRefresh(true).execute().actionGet(); SearchResponse searchResponse = client.prepareSearch("topk-0") .setQuery(matchAllQuery()) .addAggregation(new TopKBuilder("topk").field("field0").size(1)) .execute().actionGet(); TopK topk = searchResponse.getAggregations().get("topk"); assertNotNull(topk); List<TopK.Bucket> buckets = new ArrayList<>(topk.getBuckets()); assertEquals(1, buckets.size()); assertEquals("foo", buckets.get(0).getKey()); assertEquals(2, buckets.get(0).getDocCount()); }
@Test public void assertTop1NumericalOneShard() { client.admin().indices().prepareCreate("topk-0n").setSettings(ImmutableSettings.settingsBuilder().put("index.number_of_shards", 1)).execute().actionGet(); client.prepareIndex("topk-0n", "type0", "doc0").setSource("field0", 42).execute().actionGet(); client.prepareIndex("topk-0n", "type0", "doc1").setSource("field0", 42).execute().actionGet(); client.prepareIndex("topk-0n", "type0", "doc2").setSource("field0", 51).setRefresh(true).execute().actionGet(); SearchResponse searchResponse = client.prepareSearch("topk-0n") .setQuery(matchAllQuery()) .addAggregation(new TopKBuilder("topk").field("field0").size(1)) .execute().actionGet(); TopK topk = searchResponse.getAggregations().get("topk"); assertNotNull(topk); List<TopK.Bucket> buckets = new ArrayList<>(topk.getBuckets()); assertEquals(1, buckets.size()); assertEquals("42", buckets.get(0).getKey()); assertEquals(2, buckets.get(0).getDocCount()); }
@Test public void assertTop1BooleanOneShard() { client.admin().indices().prepareCreate("topk-0b").setSettings(ImmutableSettings.settingsBuilder().put("index.number_of_shards", 1)).execute().actionGet(); client.prepareIndex("topk-0b", "type0", "doc0").setSource("field0", true).execute().actionGet(); client.prepareIndex("topk-0b", "type0", "doc1").setSource("field0", true).execute().actionGet(); client.prepareIndex("topk-0b", "type0", "doc2").setSource("field0", false).setRefresh(true).execute().actionGet(); SearchResponse searchResponse = client.prepareSearch("topk-0b") .setQuery(matchAllQuery()) .addAggregation(new TopKBuilder("topk").field("field0").size(1)) .execute().actionGet(); TopK topk = searchResponse.getAggregations().get("topk"); assertNotNull(topk); List<TopK.Bucket> buckets = new ArrayList<>(topk.getBuckets()); assertEquals(1, buckets.size()); assertEquals("T", buckets.get(0).getKey()); assertEquals(2, buckets.get(0).getDocCount()); }
@Test public void assertTop10of3OneShard() { client.admin().indices().prepareCreate("topk-1").setSettings(ImmutableSettings.settingsBuilder().put("index.number_of_shards", 1)).execute().actionGet(); client.prepareIndex("topk-1", "type0", "doc0").setSource("field0", "foo").execute().actionGet(); client.prepareIndex("topk-1", "type0", "doc1").setSource("field0", "foo").execute().actionGet(); client.prepareIndex("topk-1", "type0", "doc2").setSource("field0", "bar").setRefresh(true).execute().actionGet(); SearchResponse searchResponse = client.prepareSearch("topk-1") .setQuery(matchAllQuery()) .addAggregation(new TopKBuilder("topk").field("field0").size(10)) .execute().actionGet(); TopK topk = searchResponse.getAggregations().get("topk"); assertNotNull(topk); List<TopK.Bucket> buckets = new ArrayList<>(topk.getBuckets()); assertEquals(2, buckets.size()); assertEquals("foo", buckets.get(0).getKey()); assertEquals(2, buckets.get(0).getDocCount()); assertEquals("bar", buckets.get(1).getKey()); assertEquals(1, buckets.get(1).getDocCount()); }
@Test public void assertTop10of50TwoShard() { client.admin().indices().prepareCreate("topk-3").setSettings(ImmutableSettings.settingsBuilder().put("index.number_of_shards", 2)).execute().actionGet(); for (int i = 0; i < 50; ++i) { // 50 values client.prepareIndex("topk-3", "type0", "doc" + i).setSource("field0", "foo" + i).setRefresh(true).execute().actionGet(); } for (int i = 50; i < 100; ++i) { // 50 same values client.prepareIndex("topk-3", "type0", "doc" + i).setSource("field0", "foo0").setRefresh(true).execute().actionGet(); } SearchResponse searchResponse = client.prepareSearch("topk-3") .setQuery(matchAllQuery()) .addAggregation(new TopKBuilder("topk").field("field0").size(10)) .execute().actionGet(); assertEquals(100, searchResponse.getHits().getTotalHits()); TopK topk = searchResponse.getAggregations().get("topk"); assertNotNull(topk); List<TopK.Bucket> buckets = new ArrayList<>(topk.getBuckets()); assertEquals(10, buckets.size()); assertEquals("foo0", buckets.get(0).getKey()); assertEquals(51, buckets.get(0).getDocCount()); }
@Bean ElasticsearchOperations elasticsearchTemplate() throws IOException { // transport client Settings settings = ImmutableSettings.settingsBuilder() .put("cluster.name", "elasticsearch") .put("username","myname") .put("password","mypassword").build(); Client client = new TransportClient(settings) .addTransportAddress(new InetSocketTransportAddress("192.168.73.186", 9300)); return new ElasticsearchTemplate(client); // node client // return new ElasticsearchTemplate(nodeBuilder() // .local(true) // .settings( // ImmutableSettings.settingsBuilder() // .put("cluster.name", "elasticsearch") // .put("username", "myname") // .put("password", "mypassword").build()).node() // .client()); }
@BeforeSuite public static void init() throws IOException, ExecutionException, InterruptedException, ParseException { File file = new File(DB_FOLDER_NAME); FileUtils.deleteDirectory(file); Settings settings = ImmutableSettings.settingsBuilder() .put("path.logs", "") .put("path.data", DB_FOLDER_NAME) .build(); node = nodeBuilder().settings(settings).data(true).local(true).clusterName(HOST).node(); client = node.client(); LOG.info("Started local node at " + DB_FOLDER_NAME + " settings " + node.settings().getAsMap()); }
@Override protected UsageAwareDatastoreConnection<ElasticSearchDataContext> createDatastoreConnection() { final Builder settingsBuilder = ImmutableSettings.builder(); settingsBuilder.put("name", "AnalyzerBeans"); settingsBuilder.put("cluster.name", _clusterName); final Settings settings = settingsBuilder.build(); final TransportClient client = new TransportClient(settings); client.addTransportAddress(new InetSocketTransportAddress(_hostname, _port)); final ElasticSearchDataContext dataContext; if (_tableDefs == null || _tableDefs.length == 0) { dataContext = new ElasticSearchDataContext(client, _indexName); } else { dataContext = new ElasticSearchDataContext(client, _indexName, _tableDefs); } return new DatastoreConnectionImpl<ElasticSearchDataContext>(dataContext, this); }
private Client configureNewClient() { if (this.configurationElasticSearch == null) { this.configurationElasticSearch = ElasticSearchConfig.loadConfigurationFromFile(); } Settings settings = null; if (!this.settingAttributes.isEmpty()) { settings = ImmutableSettings.settingsBuilder().put(this.settingAttributes).build(); } TransportClient transportClient = (settings == null) ? new TransportClient() : new TransportClient(settings); return transportClient.addTransportAddress( new InetSocketTransportAddress( this.configurationElasticSearch.getElasticSearchHost(), this.configurationElasticSearch.getTransportClientPort() ) ); }
/** * Open client to elaticsearch cluster * * @param clusterName */ private void openClient(String clusterName) { logger.info("Using ElasticSearch hostnames: {} ", Arrays.toString(serverAddresses)); Settings settings = ImmutableSettings.settingsBuilder() .put("cluster.name", clusterName).build(); TransportClient transportClient = new TransportClient(settings); for (InetSocketTransportAddress host : serverAddresses) { transportClient.addTransportAddress(host); } if (client != null) { client.close(); } client = transportClient; }
@BeforeClass public static void setUpClass() throws Exception { final Settings settings = ImmutableSettings.settingsBuilder().put("script.disable_dynamic", false) .put("script.native.visibility.type", "ezbake.data.elastic.security.EzSecurityScriptFactory").build(); esSetup = new EsSetup(settings); esSetup.execute(EsSetup.deleteAll()); createIndexAndType(); writeTestDoc("noVis", null, null, null, null, "noVisData"); writeTestDoc("formalVisOnly", "TS&USA", null, null, null, "formalVisOnlyData"); writeTestDoc("formalAndExternalVis", "TS&USA", "Foo&(Bar|Baz)", null, null, "formalAndExternalVisData"); writeTestDoc( "allVis", "TS&USA", "Foo&(Bar|Baz)", Sets.newHashSet(92472393432L), Sets.newHashSet(324L, 43267L, 92472393432L), "allVisData"); Thread.sleep(2000); // Wait for docs to be added }
public static TransportClient buildClient() { TransportClient client = null; try { Properties props = ConfigUtil.getProps("elastic_search.properties"); Settings settings = ImmutableSettings.settingsBuilder().put("cluster.name", props.getProperty("es.name")) .build(); client = new TransportClient(settings); client.addTransportAddress(new InetSocketTransportAddress(props.getProperty("es.ip"), Integer .parseInt(props.getProperty("es.port")))) /*.addTransportAddress( new InetSocketTransportAddress(props.getProperty("es.ip2"), Integer.parseInt(props .getProperty("es.port")))) .addTransportAddress( new InetSocketTransportAddress(props.getProperty("es.ip3"), Integer.parseInt(props .getProperty("es.port"))))*/; return client; } catch (Exception e) { throw new RuntimeException(e); } }
public ElasticClient( String hosts, int port, String cluster, String applicationName, boolean instantRefresh, int version) { final TransportClient transportClient = new TransportClient(ImmutableSettings.settingsBuilder().put("cluster.name", cluster).build()); for (final String host : hosts.split(",")) { transportClient.addTransportAddress(new InetSocketTransportAddress(host, port)); } this.client = transportClient; this.indexName = applicationName; this.applicationName = applicationName; this.version = version; gson = new Gson(); if (instantRefresh) { logger.warn( "Starting ElasticClient with forced refresh on inserts. This is only recommended for " + "controlled environments, high throughput performance will suffer."); forceRefreshOnInsert = true; } applyDefaultMapping(); }