Java CreateIndexRequestBuilder.get方法代码示例

import org.elasticsearch.action.admin.indices.create.CreateIndexRequestBuilder; //导入方法依赖的package包/类
public void createIndexIfNotExists(String index, String settingJson, Map<String, String> mappingJson) {
    String formattedIndex = formatIndex(index);
    IndicesAdminClient indicesClient = client.admin().indices();

    IndicesExistsResponse existsResponse = indicesClient.prepareExists(formattedIndex).get();
    if (existsResponse.isExists()) {
        return;
    }

    CreateIndexRequestBuilder builder = indicesClient.prepareCreate(formattedIndex)
            .setSettings(Settings.settingsBuilder().loadFromSource(settingJson));
    mappingJson.forEach((k, v) -> {
        builder.addMapping(k, v);
    });

    CreateIndexResponse indexResponse = builder.get();
    if (!indexResponse.isAcknowledged()) {
        throw new ElasticsearchException(String.format("index %s の作成に失敗しました", index));
    }
}
 

import org.elasticsearch.action.admin.indices.create.CreateIndexRequestBuilder; //导入方法依赖的package包/类
protected boolean createMapping(MappingConfiguration mapping, String indexId) {
    IndicesAdminClient indices = getClient().admin().indices();

    Map<String, Object> schema = schemaGenerator.generate(mapping);
    log.trace("Built schema creation request:\n{}", Arrays.toString(schema.entrySet().toArray()));

    // create metadata mapping and schema mapping
    CreateIndexRequestBuilder request = indices.prepareCreate(indexId)
            .addMapping(MetadataDataMapping.METADATA_TYPE_NAME, getMetadataSchema())
            .addMapping(mapping.getType(), schema);
    if (mapping.hasIndexCreationRequest()) {
        request.setSettings(mapping.getIndexCreationRequest());
    }

    CreateIndexResponse response = request.get();
    log.debug("Created indices: {}, acknowledged: {}", response, response.isAcknowledged());

    Map<String, Object> mdRecord = createMetadataRecord(mapping.getVersion(), mapping.getName());
    IndexResponse mdResponse = getClient().prepareIndex(indexId, MetadataDataMapping.METADATA_TYPE_NAME, MetadataDataMapping.METADATA_ROW_ID).setSource(mdRecord).get();
    log.debug("Saved mapping metadata '{}': {}", mdResponse.isCreated(), Arrays.toString(mdRecord.entrySet().toArray()));

    return (mdResponse.isCreated() && response.isAcknowledged());
}
 

import org.elasticsearch.action.admin.indices.create.CreateIndexRequestBuilder; //导入方法依赖的package包/类
/**
 * Create a new index with an initial mapping.
 *
 * @param indexName the name of the index to create
 * @param type      the mapping type
 * @param mapping   the mapping source
 *
 * @return true if the index was successfully created, false otherwise
 */
public static boolean create(String indexName, String type, String mapping) {
  synchronized (Indices.class) {
    if (exists(indexName)) {
      return true;
    }

    CreateIndexRequestBuilder builder = self.client.getClient().admin().indices().prepareCreate(indexName);
    builder.setSettings(Settings.builder()
        .put("number_of_shards", self.properties.getShardsPerIndex())
        .put("number_of_replicas", self.properties.getReplicasPerShard())
        .build());

    if (mapping != null) {
      builder.addMapping(type, mapping, XContentType.JSON);
    }

    log.debug("Creating new index with name {}", indexName);
    boolean created;

    try {
      CreateIndexResponse response = builder.get();
      created = response.isAcknowledged();
    } catch (ResourceAlreadyExistsException ex) {
      created = true;
    }

    self.client.waitForYellowStatus();

    if (created) {
      self.indexCache.add(indexName);
    }

    return created;
  }
}
 

import org.elasticsearch.action.admin.indices.create.CreateIndexRequestBuilder; //导入方法依赖的package包/类
private synchronized void createIndexIfNotExists() throws IOException {
    if (isError()) {
        if (logger.isTraceEnabled()) {
            logger.trace("error, not creating index");
        }
        return;
    }

    if(initialized) {
        return;
    }
    
    
    IMAPImporter.waitForYellowCluster(client);
    
    // create index if it doesn't already exist
    if (!client.admin().indices().prepareExists(index).execute().actionGet().isExists()) {

        final CreateIndexRequestBuilder createIndexRequestBuilder = client.admin().indices().prepareCreate(index);
        if (settings != null) {
            logger.debug("index settings are provided, will apply them {}", settings);
            createIndexRequestBuilder.setSettings(settings);
        } else {
            logger.debug("no settings given for index '{}'",index);
        }
        
        
        if (mapping != null) {
            logger.warn("mapping for type '{}' is provided, will apply {}", type, mapping);
            createIndexRequestBuilder.addMapping(type, mapping);
        } else {
            logger.debug("no mapping given for type '{}', will apply default mapping",type);
            createIndexRequestBuilder.addMapping(type, getDefaultTypeMapping());
        }
        
        final CreateIndexResponse res = createIndexRequestBuilder.get();
        
        if (!res.isAcknowledged()) {
            throw new IOException("Could not create index " + index);
        }
        
        IMAPImporter.waitForYellowCluster(client);
        
        logger.info("Index {} created", index);
        
    } else {
        logger.debug("Index {} already exists", index);
    }
    
    initialized = true;
}