public void testDeleteRoutingRequired() throws ExecutionException, InterruptedException, IOException { createIndexWithAlias(); assertAcked( client() .admin() .indices() .preparePutMapping("test") .setType("test") .setSource( XContentFactory.jsonBuilder() .startObject() .startObject("test") .startObject("_routing") .field("required", true) .endObject() .endObject() .endObject())); ensureYellow("test"); int numDocs = iterations(10, 50); IndexRequestBuilder[] indexRequestBuilders = new IndexRequestBuilder[numDocs]; for (int i = 0; i < numDocs - 2; i++) { indexRequestBuilders[i] = client() .prepareIndex("test", "test", Integer.toString(i)) .setRouting(randomAsciiOfLength(randomIntBetween(1, 10))) .setSource("field", "value"); } String firstDocId = Integer.toString(numDocs - 2); indexRequestBuilders[numDocs - 2] = client() .prepareIndex("test", "test", firstDocId) .setRouting("routing") .setSource("field", "value"); String secondDocId = Integer.toString(numDocs - 1); String secondRouting = randomAsciiOfLength(randomIntBetween(1, 10)); indexRequestBuilders[numDocs - 1] = client() .prepareIndex("test", "test", secondDocId) .setRouting(secondRouting) .setSource("field", "value"); indexRandom(true, indexRequestBuilders); SearchResponse searchResponse = client().prepareSearch("test").get(); assertNoFailures(searchResponse); assertThat(searchResponse.getHits().totalHits(), equalTo((long) numDocs)); DeleteResponse deleteResponse = client().prepareDelete("test", "test", firstDocId).setRouting("routing").get(); assertThat(deleteResponse.isFound(), equalTo(true)); GetResponse getResponse = client().prepareGet("test", "test", firstDocId).setRouting("routing").get(); assertThat(getResponse.isExists(), equalTo(false)); refresh(); searchResponse = client().prepareSearch("test").get(); assertNoFailures(searchResponse); assertThat(searchResponse.getHits().totalHits(), equalTo((long) numDocs - 1)); }
public void testUpdate() { createIndexWithAlias(); ensureYellow("test"); UpdateRequestBuilder updateRequestBuilder = client() .prepareUpdate(indexOrAlias(), "type1", "1") .setUpsert("field1", "value1") .setDoc("field2", "value2"); UpdateResponse updateResponse = updateRequestBuilder.get(); assertThat(updateResponse.getIndex(), equalTo("test")); assertThat(updateResponse.getType(), equalTo("type1")); assertThat(updateResponse.getId(), equalTo("1")); assertThat(updateResponse.isCreated(), equalTo(true)); GetResponse getResponse = client().prepareGet("test", "type1", "1").get(); assertThat(getResponse.isExists(), equalTo(true)); assertThat(getResponse.getSourceAsMap().containsKey("field1"), equalTo(true)); assertThat(getResponse.getSourceAsMap().containsKey("field2"), equalTo(false)); updateResponse = updateRequestBuilder.get(); assertThat(updateResponse.getIndex(), equalTo("test")); assertThat(updateResponse.getType(), equalTo("type1")); assertThat(updateResponse.getId(), equalTo("1")); assertThat(updateResponse.isCreated(), equalTo(false)); getResponse = client().prepareGet("test", "type1", "1").get(); assertThat(getResponse.isExists(), equalTo(true)); assertThat(getResponse.getSourceAsMap().containsKey("field1"), equalTo(true)); assertThat(getResponse.getSourceAsMap().containsKey("field2"), equalTo(true)); }
/** * Basic test using Index & Realtime Get with internal versioning. This test ensures routing * works correctly across versions. */ public void testInternalVersion() throws Exception { createIndex("test"); final boolean routing = randomBoolean(); int numDocs = randomIntBetween(10, 20); for (int i = 0; i < numDocs; i++) { String routingKey = routing ? randomRealisticUnicodeOfLength(10) : null; String id = Integer.toString(i); assertThat( id, client() .prepareIndex("test", "type1", id) .setRouting(routingKey) .setSource("field1", English.intToEnglish(i)) .get() .isCreated(), is(true)); GetResponse get = client().prepareGet("test", "type1", id).setRouting(routingKey).setVersion(1).get(); assertThat("Document with ID " + id + " should exist but doesn't", get.isExists(), is(true)); assertThat(get.getVersion(), equalTo(1L)); client() .prepareIndex("test", "type1", id) .setRouting(routingKey) .setSource("field1", English.intToEnglish(i)) .execute() .actionGet(); get = client().prepareGet("test", "type1", id).setRouting(routingKey).setVersion(2).get(); assertThat("Document with ID " + id + " should exist but doesn't", get.isExists(), is(true)); assertThat(get.getVersion(), equalTo(2L)); } assertVersionCreated(compatibilityVersion(), "test"); }
@Override public HashMap<String, String> loadKey(String username) { logger.info("loading password for username {}", username); HashMap<String, String> ret = new HashMap<>(); String riverIndexName = getRiverIndexName(); refreshSearchIndex(riverIndexName); GetResponse resp = client.prepareGet(riverIndexName, riverName().name(), "_pwd").execute().actionGet(); if (resp.isExists()) { if (logger.isDebugEnabled()) { logger.debug("Password document: {}", resp.getSourceAsString()); } Map<String, Object> newset = resp.getSource(); Set<String> keys = newset.keySet(); for (String s : keys) { logger.info( "Added key {} with a value of {}", s, XContentMapValues.nodeStringValue(newset.get(s), null)); ret.put(s, XContentMapValues.nodeStringValue(newset.get(s), null)); } } if (ret.isEmpty()) { return null; } return ret; }
@Test public void testUpsert() throws Exception { createIndex(); ensureGreen(); UpdateResponse updateResponse = client() .prepareUpdate("test", "type1", "1") .setUpsert(XContentFactory.jsonBuilder().startObject().field("field", 1).endObject()) .setScript("ctx._source.field += 1", ScriptService.ScriptType.INLINE) .execute() .actionGet(); assertTrue(updateResponse.isCreated()); for (int i = 0; i < 5; i++) { GetResponse getResponse = client().prepareGet("test", "type1", "1").execute().actionGet(); assertThat(getResponse.getSourceAsMap().get("field").toString(), equalTo("1")); } updateResponse = client() .prepareUpdate("test", "type1", "1") .setUpsert(XContentFactory.jsonBuilder().startObject().field("field", 1).endObject()) .setScript("ctx._source.field += 1", ScriptService.ScriptType.INLINE) .execute() .actionGet(); assertFalse(updateResponse.isCreated()); for (int i = 0; i < 5; i++) { GetResponse getResponse = client().prepareGet("test", "type1", "1").execute().actionGet(); assertThat(getResponse.getSourceAsMap().get("field").toString(), equalTo("2")); } }
private void test( String name, Class<? extends HashFunction> expectedHashFunction, boolean expectedUseType) throws Exception { Path zippedIndexDir = getDataPath("/org/elasticsearch/cluster/routing/" + name + ".zip"); Settings baseSettings = prepareBackwardsDataDir(zippedIndexDir); internalCluster() .startNode(Settings.builder().put(baseSettings).put(Node.HTTP_ENABLED, true).build()); ensureYellow("test"); GetIndexResponse getIndexResponse = client().admin().indices().prepareGetIndex().get(); assertArrayEquals(new String[] {"test"}, getIndexResponse.indices()); GetSettingsResponse getSettingsResponse = client().admin().indices().prepareGetSettings("test").get(); assertEquals( expectedHashFunction.getName(), getSettingsResponse.getSetting("test", IndexMetaData.SETTING_LEGACY_ROUTING_HASH_FUNCTION)); assertEquals( Boolean.valueOf(expectedUseType).toString(), getSettingsResponse.getSetting("test", IndexMetaData.SETTING_LEGACY_ROUTING_USE_TYPE)); SearchResponse allDocs = client().prepareSearch("test").get(); assertSearchResponse(allDocs); assertHitCount(allDocs, 4); // Make sure routing works for (SearchHit hit : allDocs.getHits().hits()) { GetResponse get = client().prepareGet(hit.index(), hit.type(), hit.id()).get(); assertTrue(get.isExists()); } }
@Override public void run() { long totalRefreshTime = 0; int numExecutedRefreshed = 0; while (run) { long docIdLimit = COUNT; for (long docId = 1; run && docId < docIdLimit; ) { try { for (int j = 0; j < 8; j++) { GetResponse getResponse = client.prepareGet(indexName, "type1", String.valueOf(++docId)).get(); client .prepareIndex(indexName, "type1", getResponse.getId()) .setSource(getResponse.getSource()) .get(); } long startTime = System.currentTimeMillis(); client.admin().indices().prepareRefresh(indexName).execute().actionGet(); totalRefreshTime += System.currentTimeMillis() - startTime; numExecutedRefreshed++; Thread.sleep(500); } catch (Throwable e) { e.printStackTrace(); } } } avgRefreshTime = totalRefreshTime / numExecutedRefreshed; stopped = true; }
@CheckForNull public QProfileRule findByActiveRuleId(int activeRuleId) { GetResponse activeRuleResponse = index .client() .prepareGet(INDEX_RULES, ESActiveRule.TYPE_ACTIVE_RULE, Integer.toString(activeRuleId)) .setFields(FIELD_SOURCE, FIELD_PARENT) .execute() .actionGet(); Map<String, Object> activeRuleSource = activeRuleResponse.getSourceAsMap(); if (activeRuleSource != null) { Map<String, Object> ruleSource = index .client() .prepareGet( INDEX_RULES, TYPE_RULE, (String) activeRuleResponse.getField(FIELD_PARENT).getValue()) .execute() .actionGet() .getSourceAsMap(); if (ruleSource != null) { return new QProfileRule(ruleSource, activeRuleSource); } } return null; }
@Test public void testNullShape() throws Exception { String mapping = XContentFactory.jsonBuilder() .startObject() .startObject("type1") .startObject("properties") .startObject("location") .field("type", "geo_shape") .endObject() .endObject() .endObject() .endObject() .string(); prepareCreate("test").addMapping("type1", mapping).execute().actionGet(); ensureGreen(); client() .prepareIndex("test", "type1", "aNullshape") .setSource("{\"location\": null}") .execute() .actionGet(); GetResponse result = client().prepareGet("test", "type1", "aNullshape").execute().actionGet(); assertThat(result.getField("location"), nullValue()); }
@Test public void testUpsert() throws Exception { createIndex(); ClusterHealthResponse clusterHealth = client.admin().cluster().prepareHealth().setWaitForGreenStatus().execute().actionGet(); assertThat(clusterHealth.timedOut(), equalTo(false)); assertThat(clusterHealth.status(), equalTo(ClusterHealthStatus.GREEN)); client .prepareUpdate("test", "type1", "1") .setUpsert(XContentFactory.jsonBuilder().startObject().field("field", 1).endObject()) .setScript("ctx._source.field += 1") .execute() .actionGet(); for (int i = 0; i < 5; i++) { GetResponse getResponse = client.prepareGet("test", "type1", "1").execute().actionGet(); assertThat(getResponse.sourceAsMap().get("field").toString(), equalTo("1")); } client .prepareUpdate("test", "type1", "1") .setUpsert(XContentFactory.jsonBuilder().startObject().field("field", 1).endObject()) .setScript("ctx._source.field += 1") .execute() .actionGet(); for (int i = 0; i < 5; i++) { GetResponse getResponse = client.prepareGet("test", "type1", "1").execute().actionGet(); assertThat(getResponse.sourceAsMap().get("field").toString(), equalTo("2")); } }
void assertRealtimeGetWorks(String indexName) { assertAcked( client() .admin() .indices() .prepareUpdateSettings(indexName) .setSettings(Settings.builder().put("refresh_interval", -1).build())); SearchRequestBuilder searchReq = client().prepareSearch(indexName).setQuery(QueryBuilders.matchAllQuery()); SearchHit hit = searchReq.get().getHits().getAt(0); String docId = hit.getId(); // foo is new, it is not a field in the generated index client().prepareUpdate(indexName, "doc", docId).setDoc("foo", "bar").get(); GetResponse getRsp = client().prepareGet(indexName, "doc", docId).get(); Map<String, Object> source = getRsp.getSourceAsMap(); assertThat(source, Matchers.hasKey("foo")); assertAcked( client() .admin() .indices() .prepareUpdateSettings(indexName) .setSettings( Settings.builder() .put("refresh_interval", EngineConfig.DEFAULT_REFRESH_INTERVAL) .build())); }
@Override public Date readDatetimeValue(String spaceKey, String propertyName) throws IOException { Date lastDate = null; String documentName = prepareValueStoreDocumentName(spaceKey, propertyName); if (logger.isDebugEnabled()) logger.debug( "Going to read datetime value from {} property for space {}. Document name is {}.", propertyName, spaceKey, documentName); refreshSearchIndex(getRiverIndexName()); GetResponse lastSeqGetResponse = client .prepareGet(getRiverIndexName(), riverName.name(), documentName) .execute() .actionGet(); if (lastSeqGetResponse.isExists()) { Object timestamp = lastSeqGetResponse.getSourceAsMap().get(STORE_FIELD_VALUE); if (timestamp != null) { lastDate = DateTimeUtils.parseISODateTime(timestamp.toString()); } } else { if (logger.isDebugEnabled()) logger.debug("{} document doesn't exist in remore river persistent store", documentName); } return lastDate; }
private List<KnapsackState> get(String name) throws IOException { ImmutableList.Builder<KnapsackState> builder = ImmutableList.builder(); try { logger.debug("get knapsack states: {}", name); final Client client = injector.getInstance(Client.class); createIndexIfNotExist(client); GetResponse getResponse = client.prepareGet(INDEX_NAME, MAPPING_NAME, name).execute().actionGet(); if (!getResponse.isExists()) { return builder.build(); } XContentParser parser = xContent(JSON).createParser(getResponse.getSourceAsBytes()); while (parser.nextToken() != START_ARRAY) { // forward } while (parser.nextToken() != END_ARRAY) { KnapsackState state = new KnapsackState(); builder.add(state.fromXContent(parser)); } return builder.build(); } catch (Throwable t) { logger.error("get settings failed", t); return null; } }
@Override public <T> T mapResult(GetResponse response, Class<T> clazz) { T result = mapEntity(response.getSourceAsString(), clazz); if (result != null) { setPersistentEntityId(result, response.getId(), clazz); } return result; }
@Test public void testGet() { GetResponse response = client .prepareGet("asdf2014", "asdf", "1") .setOperationThreaded(false) .execute() .actionGet(); if (response != null) System.out.println("Id: " + response.getId()); }
protected ESShape getShape(Iterator<MultiGetItemResponse> iterator, int size) { ESShapeBuilder shapeBuilder = new ESShapeBuilder(size); for (int i = 0; i < size; i++) { GetResponse response = iterator.next().getResponse(); if (!response.isExists()) continue; @SuppressWarnings("unchecked") Map<String, Object> shape = (Map<String, Object>) response.getField("shape").getValue(); @SuppressWarnings("unchecked") List<Double> coordinates = (List<Double>) shape.get("coordinates"); shapeBuilder.addLocation(coordinates.get(1), coordinates.get(0)); } return shapeBuilder.build(); }
public void testIndexWithShadowReplicasCleansUp() throws Exception { Path dataPath = createTempDir(); Settings nodeSettings = nodeSettings(dataPath); final int nodeCount = randomIntBetween(2, 5); logger.info("--> starting {} nodes", nodeCount); final List<String> nodes = internalCluster().startNodesAsync(nodeCount, nodeSettings).get(); final String IDX = "test"; final Tuple<Integer, Integer> numPrimariesAndReplicas = randomPrimariesAndReplicas(nodeCount); final int numPrimaries = numPrimariesAndReplicas.v1(); final int numReplicas = numPrimariesAndReplicas.v2(); logger.info( "--> creating index {} with {} primary shards and {} replicas", IDX, numPrimaries, numReplicas); Settings idxSettings = Settings.builder() .put(IndexMetaData.SETTING_NUMBER_OF_SHARDS, numPrimaries) .put(IndexMetaData.SETTING_NUMBER_OF_REPLICAS, numReplicas) .put(IndexMetaData.SETTING_DATA_PATH, dataPath.toAbsolutePath().toString()) .put(IndexMetaData.SETTING_SHADOW_REPLICAS, true) .put(IndexMetaData.SETTING_SHARED_FILESYSTEM, true) .build(); prepareCreate(IDX).setSettings(idxSettings).addMapping("doc", "foo", "type=text").get(); ensureGreen(IDX); client().prepareIndex(IDX, "doc", "1").setSource("foo", "bar").get(); client().prepareIndex(IDX, "doc", "2").setSource("foo", "bar").get(); flushAndRefresh(IDX); GetResponse gResp1 = client().prepareGet(IDX, "doc", "1").get(); GetResponse gResp2 = client().prepareGet(IDX, "doc", "2").get(); assertThat(gResp1.getSource().get("foo"), equalTo("bar")); assertThat(gResp2.getSource().get("foo"), equalTo("bar")); logger.info("--> performing query"); SearchResponse resp = client().prepareSearch(IDX).setQuery(matchAllQuery()).get(); assertHitCount(resp, 2); logger.info("--> deleting index " + IDX); assertAcked(client().admin().indices().prepareDelete(IDX)); assertAllIndicesRemovedAndDeletionCompleted( internalCluster().getInstances(IndicesService.class)); assertPathHasBeenCleared(dataPath); // TODO: uncomment the test below when https://github.com/elastic/elasticsearch/issues/17695 is // resolved. // assertIndicesDirsDeleted(nodes); }
@Test public void testThatGetFromTranslogShouldWorkWithIncludeExcludeAndFields() throws Exception { client.admin().indices().prepareDelete().execute().actionGet(); String index = "test"; String type = "type1"; String mapping = jsonBuilder() .startObject() .startObject("source_excludes") .startObject("_source") .array("includes", "included") .array("exlcudes", "excluded") .endObject() .endObject() .endObject() .string(); client .admin() .indices() .prepareCreate(index) .addMapping(type, mapping) .setSettings(ImmutableSettings.settingsBuilder().put("index.refresh_interval", -1)) .execute() .actionGet(); client .prepareIndex(index, type, "1") .setSource( jsonBuilder() .startObject() .field("field", "1", "2") .field("included", "should be seen") .field("excluded", "should not be seen") .endObject()) .execute() .actionGet(); GetResponse responseBeforeFlush = client .prepareGet(index, type, "1") .setFields("_source", "included", "excluded") .execute() .actionGet(); client.admin().indices().prepareFlush(index).execute().actionGet(); GetResponse responseAfterFlush = client .prepareGet(index, type, "1") .setFields("_source", "included", "excluded") .execute() .actionGet(); assertThat(responseBeforeFlush.isExists(), is(true)); assertThat(responseAfterFlush.isExists(), is(true)); assertThat(responseBeforeFlush.getSourceAsMap(), not(hasKey("excluded"))); assertThat(responseBeforeFlush.getSourceAsMap(), not(hasKey("field"))); assertThat(responseBeforeFlush.getSourceAsMap(), hasKey("included")); assertThat(responseBeforeFlush.getSourceAsString(), is(responseAfterFlush.getSourceAsString())); }
@Override public final String esGet(String index, String type, String id) { try { final GetResponse gr = client.prepareGet(index, type, id).execute().actionGet(); if (!gr.exists()) return "Doesn't exist"; return gr.getSourceAsString(); } catch (ElasticSearchException e) { log.debug("ElasticSearchException {}", e); return e.getMessage(); } }
public T get(String id) { GetResponse result = client.prepareGet(index, entity, id).execute().actionGet(); String source = result.getSourceAsString(); System.out.println("Loaded SLA: " + source); try { T entity = mapper.readValue(source, clazz); entity.setId(result.getId()); logger.info("Successfully obtained entity with id [{}]", id); return entity; } catch (IOException e) { logger.error("Error retrieving entity with id " + id, e); return null; } }
@SuppressWarnings("unchecked") protected <T extends ESEntity> T buildEntityFromGetResponse( Class<T> entityClass, MultiGetItemResponse item) { GetResponse response = item.getResponse(); if (!response.isExists()) throw new DaoException( String.format( "Entity %s does not exist in %s/%s", response.getId(), response.getIndex(), response.getType())); if (entityClass == null) throw new IllegalArgumentException("Provided Entity class is null"); else if (entityClass.equals(ESNode.class)) return (T) ESNode.Builder.buildFromGetReponse(response); else if (entityClass.equals(ESWay.class)) return (T) ESWay.Builder.buildFromGetReponse(response); else throw new IllegalArgumentException(entityClass.getSimpleName() + " is not a known Entity"); }
protected void createRiver(String jsonDefinition, String river, Object... args) throws Exception { logger.info("Create river [{}]", river); String setting = getJsonSettings(jsonDefinition, args); logger.info("River setting [{}]", setting); node.client().prepareIndex("_river", river, "_meta").setSource(setting).execute().actionGet(); logger.debug("Running Cluster Health"); ClusterHealthResponse clusterHealth = node.client() .admin() .cluster() .health(clusterHealthRequest().waitForGreenStatus()) .actionGet(); logger.info("Done Cluster Health, status " + clusterHealth.getStatus()); GetResponse response = getNode().client().prepareGet("_river", river, "_meta").execute().actionGet(); assertThat(response.isExists(), equalTo(true)); }
/** Reconfigure the river. Must be stopped! */ public synchronized void reconfigure() { if (!closed) throw new IllegalStateException("Remote River must be stopped to reconfigure it!"); logger.info("reconfiguring Remote River"); String riverIndexName = getRiverIndexName(); refreshSearchIndex(riverIndexName); GetResponse resp = client.prepareGet(riverIndexName, riverName().name(), "_meta").execute().actionGet(); if (resp.isExists()) { if (logger.isDebugEnabled()) { logger.debug("Configuration document: {}", resp.getSourceAsString()); } Map<String, Object> newset = resp.getSource(); configure(newset); } else { throw new IllegalStateException( "Configuration document not found to reconfigure remote river " + riverName().name()); } }
public RiverState load(Client client) throws IOException { if (coordinateIndex == null || coordinateType == null || coordinateId == null) { return this; } GetResponse get = null; try { get = client.prepareGet(coordinateIndex, coordinateType, coordinateId).execute().actionGet(); } catch (Exception e) { // ignore } if (get != null && get.isExists()) { XContentParser parser = XContentFactory.xContent(XContentType.JSON).createParser(get.getSourceAsBytes()); fromXContent(parser); } else { counter = 0L; } return this; }
@CheckForNull @Override public DOMAIN getNullableByKey(KEY key) { GetRequestBuilder request = client .prepareGet() .setType(this.getIndexType()) .setIndex(this.getIndexName()) .setId(this.getKeyValue(key)) .setFetchSource(true) .setRouting(this.getKeyValue(key)); GetResponse response = request.get(); if (response.isExists()) { return toDoc(response.getSource()); } return null; }
private String getLastUpdate() { String res; SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd'T'HH:mm:ss"); try { GetResponse response = client.prepareGet(indexName, "stats", "1").setFields("last_update").execute().actionGet(); if (!response.getFields().isEmpty()) { res = (String) response.getField("last_update").getValue(); } else { res = sdf.format(new Date(0)); } } catch (ElasticsearchIllegalStateException ex) { logger.error("Could not get last_update, use Date(0)", ex.getLocalizedMessage()); res = sdf.format(new Date(0)); } catch (NullPointerException ex) { logger.error("Could not get last_update, use Date(0)", ex.getLocalizedMessage()); res = sdf.format(new Date(0)); } return res; }
@Override public Article get(long id) { GetResponse getResponse = transportClient.prepareGet(INDICE, TYPE, String.valueOf(id)).execute().actionGet(); if (getResponse.isExists()) { Map<String, Object> map = getResponse.getSource(); String title = (String) map.get(TITLE); String summary = (String) map.get(SUMMARY); String idStr = getResponse.getId(); logger.debug("get id : {}", idStr); Article article = new Article(); article.setId(Long.parseLong(idStr)); article.setTitle(title); article.setSummary(summary); return article; } else { return null; } }
@Override public Table load(String key) { logger.info("Load called for: " + key); GetResponse response = elasticsearchConnection .getClient() .prepareGet() .setIndex(TABLE_META_INDEX) .setType(TABLE_META_TYPE) .setId(key) .execute() .actionGet(); if (!response.isExists()) { return null; } try { return objectMapper.readValue(response.getSourceAsBytes(), Table.class); } catch (Exception e) { throw new RuntimeException("Error getting data for table: " + key); } }
@Override public void run() { while (run) { int childIdLimit = PARENT_COUNT * NUM_CHILDREN_PER_PARENT; for (int childId = 1; run && childId < childIdLimit; ) { try { for (int j = 0; j < 8; j++) { GetResponse getResponse = client .prepareGet(indexName, "child", String.valueOf(++childId)) .setFields("_source", "_parent") .setRouting("1") // Doesn't matter what value, since there is only one shard .get(); client .prepareIndex(indexName, "child", Integer.toString(childId) + "_" + j) .setParent(getResponse.getField("_parent").getValue().toString()) .setSource(getResponse.getSource()) .get(); } client.admin().indices().prepareRefresh(indexName).execute().actionGet(); Thread.sleep(1000); if (childId % 500 == 0) { NodesStatsResponse statsResponse = client .admin() .cluster() .prepareNodesStats() .clear() .setIndices(true) .execute() .actionGet(); System.out.println( "Deleted docs: " + statsResponse.getAt(0).getIndices().getDocs().getDeleted()); } } catch (Throwable e) { e.printStackTrace(); } } } }
/** * Get the river definition by its name * * @param name * @return */ public T get(String name) { if (logger.isDebugEnabled()) logger.debug("get({})", name); T river = null; if (name != null) { GetRequestBuilder rb = new GetRequestBuilder(client, SMDSearchProperties.ES_META_INDEX); rb.setType(SMDSearchProperties.ES_META_RIVERS); rb.setId(name); try { GetResponse response = rb.execute().actionGet(); if (response.isExists()) { river = getHelper().toRiver(buildInstance(), response.getSourceAsMap()); } } catch (IndexMissingException e) { // Index does not exists, so RIVER does not exist... } } if (logger.isDebugEnabled()) logger.debug("/get({})={}", name, river); return river; }