Java DeleteIndexRequestBuilder类代码示例

import org.elasticsearch.action.admin.indices.delete.DeleteIndexRequestBuilder; //导入依赖的package包/类
@Test
public void testDeleteIndex() {
    //Test data
    final String indexName = "index";
    final AdminClient adminClient = createMock(AdminClient.class);
    final IndicesAdminClient indicesAdminClient = createMock(IndicesAdminClient.class);
    final DeleteIndexRequestBuilder deleteIndexRequestBuilder = createMock(DeleteIndexRequestBuilder.class);
    final DeleteIndexResponse deleteIndexResponse = createMock(DeleteIndexResponse.class);
    //Reset
    resetAll();
    //Expectations
    expect(esClient.admin()).andReturn(adminClient);
    expect(adminClient.indices()).andReturn(indicesAdminClient);
    expect(indicesAdminClient.prepareDelete(indexName)).andReturn(deleteIndexRequestBuilder);
    expect(deleteIndexRequestBuilder.get()).andReturn(deleteIndexResponse);
    //Replay
    replayAll();
    //Run test scenario
    final boolean result = elasticsearchClientWrapper.deleteIndex(indexName);
    //Verify
    verifyAll();
    assertEquals(deleteIndexResponse.isAcknowledged(), result);
}
 

import org.elasticsearch.action.admin.indices.delete.DeleteIndexRequestBuilder; //导入依赖的package包/类
@Override
public Observable<Boolean> call(String index) {
    Elasticsearch elasticsearch = vertxContext.verticle().elasticsearch();
    DeleteIndexRequestBuilder request = elasticsearch.get().admin().indices().prepareDelete(index);
    if (LOGGER.isDebugEnabled()) {
        LOGGER.debug(format("Request %s", Jsonify.toString(request)));
    }
    return elasticsearch.execute(vertxContext, request, elasticsearch.getDefaultAdminTimeout())
            .map(Optional::get)
            .doOnNext(response -> {
                if (LOGGER.isDebugEnabled()) {
                    LOGGER.debug(format("Response %s", Jsonify.toString(response)));
                }
            })
            .map(AcknowledgedResponse::isAcknowledged);
}
 

import org.elasticsearch.action.admin.indices.delete.DeleteIndexRequestBuilder; //导入依赖的package包/类
@Override
public BulkNodeClient deleteIndex(String index) {
    if (closed) {
        throw new ElasticsearchException("client is closed");
    }
    if (client == null) {
        logger.warn("no client");
        return this;
    }
    if (index == null) {
        logger.warn("no index name given to delete index");
        return this;
    }
    DeleteIndexRequestBuilder deleteIndexRequestBuilder =
            new DeleteIndexRequestBuilder(client(), DeleteIndexAction.INSTANCE, index);
    deleteIndexRequestBuilder.execute().actionGet();
    return this;
}
 

import org.elasticsearch.action.admin.indices.delete.DeleteIndexRequestBuilder; //导入依赖的package包/类
@Override
public HttpBulkNodeClient deleteIndex(String index) {
    if (closed) {
        throw new ElasticsearchException("client is closed");
    }
    if (client == null) {
        logger.warn("no client");
        return this;
    }
    if (index == null) {
        logger.warn("no index name given to delete index");
        return this;
    }
    DeleteIndexRequestBuilder deleteIndexRequestBuilder =
            new DeleteIndexRequestBuilder(client(), DeleteIndexAction.INSTANCE, index);
    deleteIndexRequestBuilder.execute().actionGet();
    return this;
}
 

import org.elasticsearch.action.admin.indices.delete.DeleteIndexRequestBuilder; //导入依赖的package包/类
@Test
public void test() throws Exception {
    try {
        DeleteIndexRequestBuilder deleteIndexRequestBuilder = new DeleteIndexRequestBuilder(client("1"), DeleteIndexAction.INSTANCE, "test");
        deleteIndexRequestBuilder.execute().actionGet();
    } catch (Exception e) {
        // ignore
    }
    IndexRequestBuilder indexRequestBuilder = new IndexRequestBuilder(client("1"), IndexAction.INSTANCE);
    indexRequestBuilder
            .setIndex("test")
            .setType("test")
            .setId("1")
            .setSource(jsonBuilder().startObject().field("field", "1%2fPJJP3JV2C24iDfEu9XpHBaYxXh%2fdHTbmchB35SDznXO2g8Vz4D7GTIvY54iMiX_149c95f02a8").endObject())
            .setRefresh(true)
            .execute()
            .actionGet();
    String doc = client("1").prepareSearch("test")
            .setTypes("test")
            .setQuery(matchQuery("field", "1%2fPJJP3JV2C24iDfEu9XpHBaYxXh%2fdHTbmchB35SDznXO2g8Vz4D7GTIvY54iMiX_149c95f02a8"))
            .execute()
            .actionGet()
            .getHits().getAt(0).getSourceAsString();

    assertEquals(doc, "{\"field\":\"1%2fPJJP3JV2C24iDfEu9XpHBaYxXh%2fdHTbmchB35SDznXO2g8Vz4D7GTIvY54iMiX_149c95f02a8\"}");
}
 

import org.elasticsearch.action.admin.indices.delete.DeleteIndexRequestBuilder; //导入依赖的package包/类
public DeleteIndexResponse deleteIndex(final String index,
        final BuilderCallback<DeleteIndexRequestBuilder> builder) {
    final DeleteIndexResponse actionGet = builder
            .apply(client().admin().indices().prepareDelete(index))
            .execute().actionGet();
    if (!actionGet.isAcknowledged()) {
        onFailure("Failed to create " + index + ".", actionGet);
    }
    return actionGet;
}
 

import org.elasticsearch.action.admin.indices.delete.DeleteIndexRequestBuilder; //导入依赖的package包/类
@Override
public synchronized BaseMetricTransportClient deleteIndex(String index) {
    if (client == null) {
        logger.warn("no client for delete index");
        return this;
    }
    if (index == null) {
        logger.warn("no index name given to delete index");
        return this;
    }
    new DeleteIndexRequestBuilder(client(), DeleteIndexAction.INSTANCE, index).execute().actionGet();
    return this;
}
 

import org.elasticsearch.action.admin.indices.delete.DeleteIndexRequestBuilder; //导入依赖的package包/类
@Override
public void deleteIndex (String indexName) {
  if(exists(indexName)){
    final DeleteIndexRequestBuilder delIdx = client.admin().indices().prepareDelete(indexName);
    delIdx.execute().actionGet();
  }
}
 

import org.elasticsearch.action.admin.indices.delete.DeleteIndexRequestBuilder; //导入依赖的package包/类
DeleteIndexRequestBuilder prepareDelete() {
    logger.info(marker, "Deleting {}", kbId);
    return client.admin().indices().prepareDelete(getIndexName());
}
 

import org.elasticsearch.action.admin.indices.delete.DeleteIndexRequestBuilder; //导入依赖的package包/类
public static void assertAcked(DeleteIndexRequestBuilder builder) {
    assertAcked(builder.get());
}
 

import org.elasticsearch.action.admin.indices.delete.DeleteIndexRequestBuilder; //导入依赖的package包/类
@Override
public DeleteIndexRequestBuilder prepareDelete(String... indices) {
    return new DeleteIndexRequestBuilder(this, DeleteIndexAction.INSTANCE, indices);
}
 

import org.elasticsearch.action.admin.indices.delete.DeleteIndexRequestBuilder; //导入依赖的package包/类
@Override
public void cleanupOldIndexes(String newIndexName, Map<String, Set<String>> indexAliases) {
    String[] allIndexes = getAllIndexes();

    List<String> allIndexList = Arrays.asList(allIndexes);

    if (allIndexList != null && !allIndexList.isEmpty()) {
        // Sort newest to oldest so that we can skip the newer indexes when
        // deleting.
        Collections.sort(allIndexList, (s1, s2) -> s1.compareTo(s2));

        // Make sure the newest come first.
        Collections.reverse(allIndexList);

        int keepLastNumIndexes = 3;

        // Map for context-aware counter.
        Map<String, Integer> indexCounts = new HashMap<>();

        List<String> indexesToDelete = new ArrayList<>();

        for (String indexName : allIndexList) {
            int lastIndexUnderscore = indexName.lastIndexOf(Char.UNDERSCORE);
            if (lastIndexUnderscore < 0) {
                continue;
            }

            String aliasName = indexName.substring(0, lastIndexUnderscore); // TODO
                                                                            // ...
            Integer count = indexCounts.get(aliasName);

            if (count == null) {
                count = 0;
                indexCounts.put(aliasName, count);
            }

            if (count > keepLastNumIndexes && !isActive(indexName, indexAliases)
                && !indexName.equals(newIndexName)) {
                log.info("Deleting inactive index " + indexName);

                indexesToDelete.add(indexName);
            }

            indexCounts.put(aliasName, ++count);
        }

        if (!indexesToDelete.isEmpty()) {
            log.info("Deleting indexes: " + indexesToDelete);

            DeleteIndexRequestBuilder deleteIndexRequest = new DeleteIndexRequestBuilder(indicesAdminClient(),
                indexesToDelete.toArray(new String[indexesToDelete.size()]));
            DeleteIndexResponse deleteResponse = deleteIndexRequest.execute().actionGet();

            log.info("DeleteIndexResponse isAcknowledged: " + deleteResponse.isAcknowledged());
        }
    }
}
 

import org.elasticsearch.action.admin.indices.delete.DeleteIndexRequestBuilder; //导入依赖的package包/类
private void removeIndices(IndicesAdminClient indices) {
    DeleteIndexRequestBuilder chatsDeleteBuilder = new DeleteIndexRequestBuilder(indices, DeleteIndexAction.INSTANCE, "chats");
    DeleteIndexRequestBuilder channelsDeleteBuilder = new DeleteIndexRequestBuilder(indices, DeleteIndexAction.INSTANCE, "channels");
    indices.delete(chatsDeleteBuilder.request());
    indices.delete(channelsDeleteBuilder.request());
}
 

import org.elasticsearch.action.admin.indices.delete.DeleteIndexRequestBuilder; //导入依赖的package包/类
/**
    * Mapping the properties of RDF meta model to Elasticsearch Server
    * @param  
    * @return 
    */	
public void MappingRDFToESServer() throws IOException, InterruptedException{		
       String indexName = INDEX_NAME;
       String documentType = DOCUMENT_TYPE;
       
       //check if index is exist for a new clean index
       IndicesExistsResponse resource = transportClient.admin().indices().prepareExists(indexName).execute().actionGet();        
       if (resource.isExists()) {
           DeleteIndexRequestBuilder deleteIndex = transportClient.admin().indices().prepareDelete(indexName);
           deleteIndex.execute().actionGet();
           LOGGER.info("Index already exists, creating new clean index...");
       }
       CreateIndexRequestBuilder createIndexRequestBuilder = transportClient.admin().indices().prepareCreate(indexName);
       
	// construct mapping
       XContentBuilder builder = jsonBuilder()
       		.startObject()
       			.startObject(documentType)
       				.startObject("_meta")
        				.field("Title", "string")
        				.field("URI", "uri")
        				.field("Description", "string")
       				.endObject()
       			.endObject()
               .endObject();        
       createIndexRequestBuilder.addMapping(documentType, builder);
       createIndexRequestBuilder.execute().actionGet();
       		                     
       ResIterator listResources = rdfMetaDataModel.listSubjects();
       long documentID = 0;
       while (listResources.hasNext())
       {
   		String uri = listResources.next().toString();
   		String titel = rdfMetaDataModel.listStatements(new ResourceImpl(uri), RDFS.label, (RDFNode) null)
   				.next().getObject().toString();
   		String description = rdfMetaDataModel.listStatements(new ResourceImpl(uri), RDFS.comment, (RDFNode) null)
   				.next().getObject().toString();
   		
        documentID++;
        // Add documents
        IndexRequestBuilder indexRequestBuilder = transportClient.prepareIndex(indexName, documentType, "" + documentID);
        // build json object
        final XContentBuilder contentBuilder = jsonBuilder().startObject().prettyPrint();
   		
        contentBuilder.field("Title", titel)
 			  			  .field("URI", uri)
 			  			  .field("Description", description);
        indexRequestBuilder.setSource(contentBuilder);
        indexRequestBuilder.execute().actionGet();
       }
	LOGGER.info( "RDF metadatamodel has been successfully mapped to elasticserach server.");        
}
 

import org.elasticsearch.action.admin.indices.delete.DeleteIndexRequestBuilder; //导入依赖的package包/类
public void removeIndex(String index) throws Exception {
  DeleteIndexRequestBuilder builder = client.admin().indices().prepareDelete(index);
  DeleteIndexResponse response = builder.execute().actionGet();
}