Java MetaData.builder方法代码示例

import org.elasticsearch.cluster.metadata.MetaData; //导入方法依赖的package包/类
/**
 * Loads the full state, which includes both the global state and all the indices
 * meta state.
 */
MetaData loadFullState() throws Exception {
    MetaData globalMetaData = loadGlobalState();
    MetaData.Builder metaDataBuilder;
    if (globalMetaData != null) {
        metaDataBuilder = MetaData.builder(globalMetaData);
    } else {
        metaDataBuilder = MetaData.builder();
    }
    for (String indexFolderName : nodeEnv.availableIndexFolders()) {
        IndexMetaData indexMetaData = IndexMetaData.FORMAT.loadLatestState(logger, namedXContentRegistry,
            nodeEnv.resolveIndexFolder(indexFolderName));
        if (indexMetaData != null) {
            metaDataBuilder.put(indexMetaData, false);
        } else {
            logger.debug("[{}] failed to find metadata for existing index location", indexFolderName);
        }
    }
    return metaDataBuilder.build();
}
 

import org.elasticsearch.cluster.metadata.MetaData; //导入方法依赖的package包/类
private ClusterState createInitialClusterState() {
    MetaData.Builder metaBuilder = MetaData.builder();
    metaBuilder.put(IndexMetaData.builder("idx").settings(settings(Version.CURRENT)).numberOfShards(1).numberOfReplicas(0));
    MetaData metaData = metaBuilder.build();
    RoutingTable.Builder routingTableBuilder = RoutingTable.builder();
    routingTableBuilder.addAsNew(metaData.index("idx"));

    RoutingTable routingTable = routingTableBuilder.build();
    ClusterState clusterState = ClusterState.builder(ClusterName.CLUSTER_NAME_SETTING.getDefault(Settings.EMPTY))
        .metaData(metaData).routingTable(routingTable).build();
    clusterState = ClusterState.builder(clusterState).nodes(DiscoveryNodes.builder().add(newNode("node1")).add(newNode("node2")))
        .build();
    RoutingTable prevRoutingTable = routingTable;
    routingTable = strategy.reroute(clusterState, "reroute", false).routingTable();
    clusterState = ClusterState.builder(clusterState).routingTable(routingTable).build();

    assertEquals(prevRoutingTable.index("idx").shards().size(), 1);
    assertEquals(prevRoutingTable.index("idx").shard(0).shards().get(0).state(), UNASSIGNED);

    assertEquals(routingTable.index("idx").shards().size(), 1);
    assertEquals(routingTable.index("idx").shard(0).shards().get(0).state(), INITIALIZING);
    return clusterState;
}
 

import org.elasticsearch.cluster.metadata.MetaData; //导入方法依赖的package包/类
private ClusterState addIndex(ClusterState clusterState, AllocationService service, int indexOrdinal, int numberOfShards,
                              int numberOfReplicas) {
    MetaData.Builder metaDataBuilder = MetaData.builder(clusterState.getMetaData());
    RoutingTable.Builder routingTableBuilder = RoutingTable.builder(clusterState.routingTable());

    IndexMetaData.Builder index = IndexMetaData.builder("test" + indexOrdinal).settings(settings(Version.CURRENT)).numberOfShards(numberOfShards).numberOfReplicas(
            numberOfReplicas);
    IndexMetaData imd = index.build();
    metaDataBuilder = metaDataBuilder.put(imd, true);
    routingTableBuilder.addAsNew(imd);

    MetaData metaData = metaDataBuilder.build();
    clusterState = ClusterState.builder(clusterState).metaData(metaData).routingTable(routingTableBuilder.build()).build();
    clusterState = service.reroute(clusterState, "reroute");

    logger.info("restart all the primary shards, replicas will start initializing");
    RoutingNodes routingNodes = clusterState.getRoutingNodes();
    clusterState = service.applyStartedShards(clusterState, routingNodes.shardsWithState(INITIALIZING));

    logger.info("start the replica shards");
    routingNodes = clusterState.getRoutingNodes();
    clusterState = service.applyStartedShards(clusterState, routingNodes.shardsWithState(INITIALIZING));

    logger.info("complete rebalancing");
    return applyStartedShardsUntilNoChange(clusterState, service);
}
 

import org.elasticsearch.cluster.metadata.MetaData; //导入方法依赖的package包/类
private ClusterState createInitialClusterState(AllocationService service) {
    MetaData.Builder metaBuilder = MetaData.builder();
    metaBuilder.put(IndexMetaData.builder("idx").settings(settings(Version.CURRENT)).numberOfShards(1).numberOfReplicas(0));
    MetaData metaData = metaBuilder.build();
    RoutingTable.Builder routingTableBuilder = RoutingTable.builder();
    routingTableBuilder.addAsNew(metaData.index("idx"));

    RoutingTable routingTable = routingTableBuilder.build();
    ClusterState clusterState = ClusterState.builder(org.elasticsearch.cluster.ClusterName.CLUSTER_NAME_SETTING
        .getDefault(Settings.EMPTY))
        .metaData(metaData).routingTable(routingTable).build();
    clusterState = ClusterState.builder(clusterState).nodes(DiscoveryNodes.builder().add(newNode("node1")).add(newNode("node2")))
        .build();
    RoutingTable prevRoutingTable = routingTable;
    routingTable = service.reroute(clusterState, "reroute").routingTable();
    clusterState = ClusterState.builder(clusterState).routingTable(routingTable).build();

    assertEquals(prevRoutingTable.index("idx").shards().size(), 1);
    assertEquals(prevRoutingTable.index("idx").shard(0).shards().get(0).state(), UNASSIGNED);

    assertEquals(routingTable.index("idx").shards().size(), 1);
    assertEquals(routingTable.index("idx").shard(0).shards().get(0).state(), INITIALIZING);
    return clusterState;
}
 

import org.elasticsearch.cluster.metadata.MetaData; //导入方法依赖的package包/类
/**
 * Loads the full state, which includes both the global state and all the indices
 * meta state.
 */
MetaData loadFullState() throws Exception {
    MetaData globalMetaData = loadGlobalState();
    MetaData.Builder metaDataBuilder;
    if (globalMetaData != null) {
        metaDataBuilder = MetaData.builder(globalMetaData);
    } else {
        metaDataBuilder = MetaData.builder();
    }

    final Set<String> indices = nodeEnv.findAllIndices();
    for (String index : indices) {
        IndexMetaData indexMetaData = loadIndexState(index);
        if (indexMetaData == null) {
            logger.debug("[{}] failed to find metadata for existing index location", index);
        } else {
            metaDataBuilder.put(indexMetaData, false);
        }
    }
    return metaDataBuilder.build();
}
 

import org.elasticsearch.cluster.metadata.MetaData; //导入方法依赖的package包/类
@Setup
public void setUp() throws Exception {
    final String[] params = indicesShardsReplicasNodes.split("\\|");

    int numIndices = toInt(params[0]);
    int numShards = toInt(params[1]);
    int numReplicas = toInt(params[2]);
    int numNodes = toInt(params[3]);

    strategy = Allocators.createAllocationService(Settings.builder()
            .put("cluster.routing.allocation.awareness.attributes", "tag")
            .build());

    MetaData.Builder mb = MetaData.builder();
    for (int i = 1; i <= numIndices; i++) {
        mb.put(IndexMetaData.builder("test_" + i)
                .settings(Settings.builder().put("index.version.created", Version.CURRENT))
                .numberOfShards(numShards)
                .numberOfReplicas(numReplicas)
        );
    }
    MetaData metaData = mb.build();
    RoutingTable.Builder rb = RoutingTable.builder();
    for (int i = 1; i <= numIndices; i++) {
        rb.addAsNew(metaData.index("test_" + i));
    }
    RoutingTable routingTable = rb.build();
    DiscoveryNodes.Builder nb = DiscoveryNodes.builder();
    for (int i = 1; i <= numNodes; i++) {
        nb.add(Allocators.newNode("node" + i, Collections.singletonMap("tag", "tag_" + (i % numTags))));
    }
    initialClusterState = ClusterState.builder(ClusterName.CLUSTER_NAME_SETTING.getDefault(Settings.EMPTY))
        .metaData(metaData).routingTable(routingTable).nodes
            (nb).build();
}
 

import org.elasticsearch.cluster.metadata.MetaData; //导入方法依赖的package包/类
/**
 * Elasticsearch 2.0 removed several deprecated features and as well as support for Lucene 3.x. This method calls
 * {@link MetaDataIndexUpgradeService} to makes sure that indices are compatible with the current version. The
 * MetaDataIndexUpgradeService might also update obsolete settings if needed.
 * Allows upgrading global custom meta data via {@link MetaDataUpgrader#customMetaDataUpgraders}
 *
 * @return input <code>metaData</code> if no upgrade is needed or an upgraded metaData
 */
static MetaData upgradeMetaData(MetaData metaData,
                                MetaDataIndexUpgradeService metaDataIndexUpgradeService,
                                MetaDataUpgrader metaDataUpgrader) throws Exception {
    // upgrade index meta data
    boolean changed = false;
    final MetaData.Builder upgradedMetaData = MetaData.builder(metaData);
    for (IndexMetaData indexMetaData : metaData) {
        IndexMetaData newMetaData = metaDataIndexUpgradeService.upgradeIndexMetaData(indexMetaData,
            Version.CURRENT.minimumIndexCompatibilityVersion());
        changed |= indexMetaData != newMetaData;
        upgradedMetaData.put(newMetaData, false);
    }
    // collect current customs
    Map<String, MetaData.Custom> existingCustoms = new HashMap<>();
    for (ObjectObjectCursor<String, MetaData.Custom> customCursor : metaData.customs()) {
        existingCustoms.put(customCursor.key, customCursor.value);
    }
    // upgrade global custom meta data
    Map<String, MetaData.Custom> upgradedCustoms = metaDataUpgrader.customMetaDataUpgraders.apply(existingCustoms);
    if (upgradedCustoms.equals(existingCustoms) == false) {
        existingCustoms.keySet().forEach(upgradedMetaData::removeCustom);
        for (Map.Entry<String, MetaData.Custom> upgradedCustomEntry : upgradedCustoms.entrySet()) {
            upgradedMetaData.putCustom(upgradedCustomEntry.getKey(), upgradedCustomEntry.getValue());
        }
        changed = true;
    }
    return changed ? upgradedMetaData.build() : metaData;
}
 

import org.elasticsearch.cluster.metadata.MetaData; //导入方法依赖的package包/类
/**
 * Updates the current {@link MetaData} based on the changes of this RoutingChangesObserver. Specifically
 * we update {@link IndexMetaData#getInSyncAllocationIds()} and {@link IndexMetaData#primaryTerm(int)} based on
 * the changes made during this allocation.
 *
 * @param oldMetaData {@link MetaData} object from before the routing nodes was changed.
 * @param newRoutingTable {@link RoutingTable} object after routing changes were applied.
 * @return adapted {@link MetaData}, potentially the original one if no change was needed.
 */
public MetaData applyChanges(MetaData oldMetaData, RoutingTable newRoutingTable) {
    Map<Index, List<Map.Entry<ShardId, Updates>>> changesGroupedByIndex =
        shardChanges.entrySet().stream().collect(Collectors.groupingBy(e -> e.getKey().getIndex()));

    MetaData.Builder metaDataBuilder = null;
    for (Map.Entry<Index, List<Map.Entry<ShardId, Updates>>> indexChanges : changesGroupedByIndex.entrySet()) {
        Index index = indexChanges.getKey();
        final IndexMetaData oldIndexMetaData = oldMetaData.getIndexSafe(index);
        IndexMetaData.Builder indexMetaDataBuilder = null;
        for (Map.Entry<ShardId, Updates> shardEntry : indexChanges.getValue()) {
            ShardId shardId = shardEntry.getKey();
            Updates updates = shardEntry.getValue();
            indexMetaDataBuilder = updateInSyncAllocations(newRoutingTable, oldIndexMetaData, indexMetaDataBuilder, shardId, updates);
            indexMetaDataBuilder = updatePrimaryTerm(oldIndexMetaData, indexMetaDataBuilder, shardId, updates);
        }

        if (indexMetaDataBuilder != null) {
            if (metaDataBuilder == null) {
                metaDataBuilder = MetaData.builder(oldMetaData);
            }
            metaDataBuilder.put(indexMetaDataBuilder);
        }
    }

    if (metaDataBuilder != null) {
        return metaDataBuilder.build();
    } else {
        return oldMetaData;
    }
}
 

import org.elasticsearch.cluster.metadata.MetaData; //导入方法依赖的package包/类
public void testHandleNodeJoin_incompatibleClusterState() throws UnknownHostException {
    Settings nodeSettings = Settings.builder()
        .put("discovery.type", "zen") // <-- To override the local setting if set externally
        .build();
    String masterOnlyNode = internalCluster().startMasterOnlyNode(nodeSettings);
    String node1 = internalCluster().startNode(nodeSettings);
    ZenDiscovery zenDiscovery = (ZenDiscovery) internalCluster().getInstance(Discovery.class, masterOnlyNode);
    ClusterService clusterService = internalCluster().getInstance(ClusterService.class, node1);
    final ClusterState state = clusterService.state();
    MetaData.Builder mdBuilder = MetaData.builder(state.metaData());
    mdBuilder.putCustom(CustomMetaData.TYPE, new CustomMetaData("data"));
    ClusterState stateWithCustomMetaData = ClusterState.builder(state).metaData(mdBuilder).build();

    final AtomicReference<IllegalStateException> holder = new AtomicReference<>();
    DiscoveryNode node = state.nodes().getLocalNode();
    zenDiscovery.handleJoinRequest(node, stateWithCustomMetaData, new MembershipAction.JoinCallback() {
        @Override
        public void onSuccess() {
        }

        @Override
        public void onFailure(Exception e) {
            holder.set((IllegalStateException) e);
        }
    });

    assertThat(holder.get(), notNullValue());
    assertThat(holder.get().getMessage(), equalTo("failure when sending a validation request to node"));
}
 

import org.elasticsearch.cluster.metadata.MetaData; //导入方法依赖的package包/类
private MetaData randomMeta() throws IOException {
    int numIndices = randomIntBetween(1, 10);
    MetaData.Builder mdBuilder = MetaData.builder();
    mdBuilder.generateClusterUuidIfNeeded();
    for (int i = 0; i < numIndices; i++) {
        mdBuilder.put(indexBuilder(randomAsciiOfLength(10) + "idx-"+i));
    }
    int numDelIndices = randomIntBetween(0, 5);
    final IndexGraveyard.Builder graveyard = IndexGraveyard.builder();
    for (int i = 0; i < numDelIndices; i++) {
        graveyard.addTombstone(new Index(randomAsciiOfLength(10) + "del-idx-" + i, UUIDs.randomBase64UUID()));
    }
    mdBuilder.indexGraveyard(graveyard.build());
    return mdBuilder.build();
}
 

import org.elasticsearch.cluster.metadata.MetaData; //导入方法依赖的package包/类
private static MetaData randomMetaData(TestCustomMetaData... customMetaDatas) {
    MetaData.Builder builder = MetaData.builder();
    for (TestCustomMetaData customMetaData : customMetaDatas) {
        builder.putCustom(customMetaData.getWriteableName(), customMetaData);
    }
    for (int i = 0; i < randomIntBetween(1, 5); i++) {
        builder.put(
            IndexMetaData.builder(randomAsciiOfLength(10))
                .settings(settings(Version.CURRENT))
                .numberOfReplicas(randomIntBetween(0, 3))
                .numberOfShards(randomIntBetween(1, 5))
        );
    }
    return builder.build();
}
 

import org.elasticsearch.cluster.metadata.MetaData; //导入方法依赖的package包/类
private ClusterState initCluster(AllocationService strategy) {
    MetaData.Builder metaDataBuilder = MetaData.builder();
    RoutingTable.Builder routingTableBuilder = RoutingTable.builder();

    for (int i = 0; i < numberOfIndices; i++) {
        IndexMetaData.Builder index = IndexMetaData.builder("test" + i).settings(settings(Version.CURRENT)).numberOfShards(numberOfShards).numberOfReplicas(numberOfReplicas);
        metaDataBuilder = metaDataBuilder.put(index);
    }

    MetaData metaData = metaDataBuilder.build();

    for (ObjectCursor<IndexMetaData> cursor : metaData.indices().values()) {
        routingTableBuilder.addAsNew(cursor.value);
    }

    RoutingTable initialRoutingTable = routingTableBuilder.build();


    logger.info("start " + numberOfNodes + " nodes");
    DiscoveryNodes.Builder nodes = DiscoveryNodes.builder();
    for (int i = 0; i < numberOfNodes; i++) {
        nodes.add(newNode("node" + i));
    }
    ClusterState clusterState = ClusterState.builder(org.elasticsearch.cluster.ClusterName.CLUSTER_NAME_SETTING.getDefault(Settings.EMPTY)).nodes(nodes).metaData(metaData).routingTable(initialRoutingTable).build();
    clusterState = strategy.reroute(clusterState, "reroute");

    logger.info("restart all the primary shards, replicas will start initializing");
    RoutingNodes routingNodes = clusterState.getRoutingNodes();
    clusterState = strategy.applyStartedShards(clusterState, routingNodes.shardsWithState(INITIALIZING));

    logger.info("start the replica shards");
    routingNodes = clusterState.getRoutingNodes();
    clusterState = strategy.applyStartedShards(clusterState, routingNodes.shardsWithState(INITIALIZING));

    logger.info("complete rebalancing");
    return applyStartedShardsUntilNoChange(clusterState, strategy);
}
 

import org.elasticsearch.cluster.metadata.MetaData; //导入方法依赖的package包/类
private ClusterState initCluster(AllocationService service, int numberOfNodes, int numberOfIndices, int numberOfShards,
                                 int numberOfReplicas) {
    MetaData.Builder metaDataBuilder = MetaData.builder();
    RoutingTable.Builder routingTableBuilder = RoutingTable.builder();

    for (int i = 0; i < numberOfIndices; i++) {
        IndexMetaData.Builder index = IndexMetaData.builder("test" + i).settings(settings(Version.CURRENT)).numberOfShards(numberOfShards).numberOfReplicas(
                numberOfReplicas);
        metaDataBuilder = metaDataBuilder.put(index);
    }

    MetaData metaData = metaDataBuilder.build();

    for (ObjectCursor<IndexMetaData> cursor : metaData.indices().values()) {
        routingTableBuilder.addAsNew(cursor.value);
    }

    RoutingTable initialRoutingTable = routingTableBuilder.build();

    logger.info("start {} nodes", numberOfNodes);
    DiscoveryNodes.Builder nodes = DiscoveryNodes.builder();
    for (int i = 0; i < numberOfNodes; i++) {
        nodes.add(newNode("node" + i));
    }
    ClusterState clusterState = ClusterState.builder(org.elasticsearch.cluster.ClusterName.CLUSTER_NAME_SETTING.getDefault(Settings.EMPTY)).nodes(nodes).metaData(metaData).routingTable(initialRoutingTable).build();
    clusterState = service.reroute(clusterState, "reroute");

    logger.info("restart all the primary shards, replicas will start initializing");
    RoutingNodes routingNodes = clusterState.getRoutingNodes();
    clusterState = service.applyStartedShards(clusterState, routingNodes.shardsWithState(INITIALIZING));

    logger.info("start the replica shards");
    routingNodes = clusterState.getRoutingNodes();
    clusterState = service.applyStartedShards(clusterState, routingNodes.shardsWithState(INITIALIZING));
    routingNodes = clusterState.getRoutingNodes();

    logger.info("complete rebalancing");
    return applyStartedShardsUntilNoChange(clusterState, service);
}
 

import org.elasticsearch.cluster.metadata.MetaData; //导入方法依赖的package包/类
private static MetaData createMetaData(final List<Index> indices) {
    final MetaData.Builder builder = MetaData.builder();
    builder.clusterUUID(INITIAL_CLUSTER_ID);
    for (Index index : indices) {
        builder.put(createIndexMetadata(index), true);
    }
    return builder.build();
}
 

import org.elasticsearch.cluster.metadata.MetaData; //导入方法依赖的package包/类
public void testClusterHealth() throws IOException {
    RoutingTableGenerator routingTableGenerator = new RoutingTableGenerator();
    RoutingTableGenerator.ShardCounter counter = new RoutingTableGenerator.ShardCounter();
    RoutingTable.Builder routingTable = RoutingTable.builder();
    MetaData.Builder metaData = MetaData.builder();
    for (int i = randomInt(4); i >= 0; i--) {
        int numberOfShards = randomInt(3) + 1;
        int numberOfReplicas = randomInt(4);
        IndexMetaData indexMetaData = IndexMetaData
                .builder("test_" + Integer.toString(i))
                .settings(settings(Version.CURRENT))
                .numberOfShards(numberOfShards)
                .numberOfReplicas(numberOfReplicas)
                .build();
        IndexRoutingTable indexRoutingTable = routingTableGenerator.genIndexRoutingTable(indexMetaData, counter);
        metaData.put(indexMetaData, true);
        routingTable.add(indexRoutingTable);
    }
    ClusterState clusterState = ClusterState.builder(ClusterName.CLUSTER_NAME_SETTING.getDefault(Settings.EMPTY))
                                            .metaData(metaData)
                                            .routingTable(routingTable.build())
                                            .build();
    String[] concreteIndices = indexNameExpressionResolver.concreteIndexNames(
        clusterState, IndicesOptions.strictExpand(), (String[]) null
    );
    ClusterStateHealth clusterStateHealth = new ClusterStateHealth(clusterState, concreteIndices);
    logger.info("cluster status: {}, expected {}", clusterStateHealth.getStatus(), counter.status());
    clusterStateHealth = maybeSerialize(clusterStateHealth);
    assertClusterHealth(clusterStateHealth, counter);
}