Java IndexMetaData.Builder方法代码示例

import org.elasticsearch.cluster.metadata.IndexMetaData; //导入方法依赖的package包/类
public void testCanDeleteIndexContent() throws IOException {
    final IndicesService indicesService = getIndicesService();
    IndexSettings idxSettings = IndexSettingsModule.newIndexSettings("test", Settings.builder()
            .put(IndexMetaData.SETTING_SHADOW_REPLICAS, true)
            .put(IndexMetaData.SETTING_DATA_PATH, "/foo/bar")
            .put(IndexMetaData.SETTING_NUMBER_OF_SHARDS, randomIntBetween(1, 4))
            .put(IndexMetaData.SETTING_NUMBER_OF_REPLICAS, randomIntBetween(0, 3))
            .build());
    assertFalse("shard on shared filesystem", indicesService.canDeleteIndexContents(idxSettings.getIndex(), idxSettings));

    final IndexMetaData.Builder newIndexMetaData = IndexMetaData.builder(idxSettings.getIndexMetaData());
    newIndexMetaData.state(IndexMetaData.State.CLOSE);
    idxSettings = IndexSettingsModule.newIndexSettings(newIndexMetaData.build());
    assertTrue("shard on shared filesystem, but closed, so it should be deletable",
        indicesService.canDeleteIndexContents(idxSettings.getIndex(), idxSettings));
}
 

import org.elasticsearch.cluster.metadata.IndexMetaData; //导入方法依赖的package包/类
/** reverse engineer the in sync aid based on the given indexRoutingTable **/
public static IndexMetaData updateActiveAllocations(IndexRoutingTable indexRoutingTable, IndexMetaData indexMetaData) {
    IndexMetaData.Builder imdBuilder = IndexMetaData.builder(indexMetaData);
    for (IndexShardRoutingTable shardTable : indexRoutingTable) {
        for (ShardRouting shardRouting : shardTable) {
            Set<String> insyncAids = shardTable.activeShards().stream().map(
                shr -> shr.allocationId().getId()).collect(Collectors.toSet());
            final ShardRouting primaryShard = shardTable.primaryShard();
            if (primaryShard.initializing() && primaryShard.relocating() == false &&
                RecoverySource.isInitialRecovery(primaryShard.recoverySource().getType()) == false ) {
                // simulate a primary was initialized based on aid
                insyncAids.add(primaryShard.allocationId().getId());
            }
            imdBuilder.putInSyncAllocationIds(shardRouting.id(), insyncAids);
        }
    }
    return imdBuilder.build();
}
 

import org.elasticsearch.cluster.metadata.IndexMetaData; //导入方法依赖的package包/类
private void addInSyncAllocationIds(Index index, IndexMetaData.Builder indexMetaData,
                                    TestGatewayAllocator gatewayAllocator, DiscoveryNode node1) {
    for (int shard = 0; shard < indexMetaData.numberOfShards(); shard++) {

        final boolean primary = randomBoolean();
        final ShardRouting unassigned = ShardRouting.newUnassigned(new ShardId(index, shard), primary,
            primary ?
                RecoverySource.StoreRecoverySource.EMPTY_STORE_INSTANCE :
                RecoverySource.PeerRecoverySource.INSTANCE,
            new UnassignedInfo(UnassignedInfo.Reason.INDEX_CREATED, "test")
        );
        ShardRouting started = ShardRoutingHelper.moveToStarted(ShardRoutingHelper.initialize(unassigned, node1.getId()));
        indexMetaData.putInSyncAllocationIds(shard, Collections.singleton(started.allocationId().getId()));
        gatewayAllocator.addKnownAllocation(started);
    }
}
 

import org.elasticsearch.cluster.metadata.IndexMetaData; //导入方法依赖的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.IndexMetaData; //导入方法依赖的package包/类
private static IndexMetaData index(String name, String... aliases) {
    IndexMetaData.Builder builder = IndexMetaData.builder(name).settings(Settings.builder()
            .put("index.version.created", Version.CURRENT.id)
            .put("index.number_of_shards", 1)
            .put("index.number_of_replicas", 1));
    for (String alias: aliases) {
        builder.putAlias(AliasMetaData.builder(alias).build());
    }
    return builder.build();
}
 

import org.elasticsearch.cluster.metadata.IndexMetaData; //导入方法依赖的package包/类
void setClusterState(ClusterService clusterService, String index) {
    int numberOfNodes = randomIntBetween(3, 5);
    DiscoveryNodes.Builder discoBuilder = DiscoveryNodes.builder();
    IndexRoutingTable.Builder indexRoutingTable = IndexRoutingTable.builder(new Index(index, "_na_"));

    int shardIndex = -1;
    int totalIndexShards = 0;
    for (int i = 0; i < numberOfNodes; i++) {
        final DiscoveryNode node = newNode(i);
        discoBuilder = discoBuilder.add(node);
        int numberOfShards = randomIntBetween(1, 10);
        totalIndexShards += numberOfShards;
        for (int j = 0; j < numberOfShards; j++) {
            final ShardId shardId = new ShardId(index, "_na_", ++shardIndex);
            ShardRouting shard = TestShardRouting.newShardRouting(index, shardId.getId(), node.getId(), true, ShardRoutingState.STARTED);
            IndexShardRoutingTable.Builder indexShard = new IndexShardRoutingTable.Builder(shardId);
            indexShard.addShard(shard);
            indexRoutingTable.addIndexShard(indexShard.build());
        }
    }
    discoBuilder.localNodeId(newNode(0).getId());
    discoBuilder.masterNodeId(newNode(numberOfNodes - 1).getId());
    ClusterState.Builder stateBuilder = ClusterState.builder(new ClusterName(TEST_CLUSTER));
    stateBuilder.nodes(discoBuilder);
    final IndexMetaData.Builder indexMetaData = IndexMetaData.builder(index)
            .settings(Settings.builder().put(IndexMetaData.SETTING_VERSION_CREATED, Version.CURRENT))
            .numberOfReplicas(0)
            .numberOfShards(totalIndexShards);

    stateBuilder.metaData(MetaData.builder().put(indexMetaData));
    stateBuilder.routingTable(RoutingTable.builder().add(indexRoutingTable.build()).build());
    ClusterState clusterState = stateBuilder.build();
    setState(clusterService, clusterState);
}
 

import org.elasticsearch.cluster.metadata.IndexMetaData; //导入方法依赖的package包/类
/**
 * Increases the primary term if {@link #increasePrimaryTerm} was called for this shard id.
 */
private IndexMetaData.Builder updatePrimaryTerm(IndexMetaData oldIndexMetaData, IndexMetaData.Builder indexMetaDataBuilder,
                                                ShardId shardId, Updates updates) {
    if (updates.increaseTerm) {
        if (indexMetaDataBuilder == null) {
            indexMetaDataBuilder = IndexMetaData.builder(oldIndexMetaData);
        }
        indexMetaDataBuilder.primaryTerm(shardId.id(), oldIndexMetaData.primaryTerm(shardId.id()) + 1);
    }
    return indexMetaDataBuilder;
}
 

import org.elasticsearch.cluster.metadata.IndexMetaData; //导入方法依赖的package包/类
protected IndexMetaData buildIndexMetaData(int replicas) throws IOException {
    Settings settings = Settings.builder().put(IndexMetaData.SETTING_VERSION_CREATED, Version.CURRENT)
        .put(IndexMetaData.SETTING_NUMBER_OF_REPLICAS, replicas)
        .put(IndexMetaData.SETTING_NUMBER_OF_SHARDS, 1)
        .build();
    IndexMetaData.Builder metaData = IndexMetaData.builder(index.getName())
        .settings(settings)
        .primaryTerm(0, 1);
    for (Map.Entry<String, String> typeMapping : indexMapping.entrySet()) {
        metaData.putMapping(typeMapping.getKey(), typeMapping.getValue());
    }
    return metaData.build();
}
 

import org.elasticsearch.cluster.metadata.IndexMetaData; //导入方法依赖的package包/类
public void testFailIfFieldMappingNotFound() {
    IndexMetaData.Builder indexMetadata = new IndexMetaData.Builder("index");
    indexMetadata.settings(Settings.builder().put("index.version.created", Version.CURRENT)
        .put("index.number_of_shards", 1)
        .put("index.number_of_replicas", 1)
    );
    IndexSettings indexSettings = new IndexSettings(indexMetadata.build(), Settings.EMPTY);
    MapperService mapperService = mock(MapperService.class);
    when(mapperService.getIndexSettings()).thenReturn(indexSettings);
    final long nowInMillis = randomNonNegativeLong();
    QueryShardContext context = new QueryShardContext(
        0, indexSettings, null, null, mapperService, null, null, xContentRegistry(), null, null,
        () -> nowInMillis);

    context.setAllowUnmappedFields(false);
    MappedFieldType fieldType = new TextFieldMapper.TextFieldType();
    MappedFieldType result = context.failIfFieldMappingNotFound("name", fieldType);
    assertThat(result, sameInstance(fieldType));
    QueryShardException e = expectThrows(QueryShardException.class, () -> context.failIfFieldMappingNotFound("name", null));
    assertEquals("No field mapping can be found for the field with name [name]", e.getMessage());

    context.setAllowUnmappedFields(true);
    result = context.failIfFieldMappingNotFound("name", fieldType);
    assertThat(result, sameInstance(fieldType));
    result = context.failIfFieldMappingNotFound("name", null);
    assertThat(result, nullValue());

    context.setAllowUnmappedFields(false);
    context.setMapUnmappedFieldAsString(true);
    result = context.failIfFieldMappingNotFound("name", fieldType);
    assertThat(result, sameInstance(fieldType));
    result = context.failIfFieldMappingNotFound("name", null);
    assertThat(result, notNullValue());
    assertThat(result, instanceOf(TextFieldMapper.TextFieldType.class));
    assertThat(result.name(), equalTo("name"));
}
 

import org.elasticsearch.cluster.metadata.IndexMetaData; //导入方法依赖的package包/类
private IndexMetaData.Builder createIndexMetaData(String indexName) {
    primaryTermsPerIndex.put(indexName, new long[numberOfShards]);
    final IndexMetaData.Builder builder = new IndexMetaData.Builder(indexName)
            .settings(DEFAULT_SETTINGS)
            .numberOfReplicas(this.numberOfReplicas)
            .numberOfShards(this.numberOfShards);
    for (int i = 0; i < numberOfShards; i++) {
        builder.primaryTerm(i, randomInt(200));
        primaryTermsPerIndex.get(indexName)[i] = builder.primaryTerm(i);
    }
    return builder;
}
 

import org.elasticsearch.cluster.metadata.IndexMetaData; //导入方法依赖的package包/类
public void testRestoreDoesNotAllocateSnapshotOnOlderNodes() {
    final DiscoveryNode newNode = new DiscoveryNode("newNode", buildNewFakeTransportAddress(), emptyMap(),
            MASTER_DATA_ROLES, Version.CURRENT);
    final DiscoveryNode oldNode1 = new DiscoveryNode("oldNode1", buildNewFakeTransportAddress(), emptyMap(),
            MASTER_DATA_ROLES, VersionUtils.getPreviousVersion());
    final DiscoveryNode oldNode2 = new DiscoveryNode("oldNode2", buildNewFakeTransportAddress(), emptyMap(),
            MASTER_DATA_ROLES, VersionUtils.getPreviousVersion());

    int numberOfShards = randomIntBetween(1, 3);
    final IndexMetaData.Builder indexMetaData = IndexMetaData.builder("test").settings(settings(Version.CURRENT))
        .numberOfShards(numberOfShards).numberOfReplicas(randomIntBetween(0, 3));
    for (int i = 0; i < numberOfShards; i++) {
        indexMetaData.putInSyncAllocationIds(i, Collections.singleton("_test_"));
    }
    MetaData metaData = MetaData.builder().put(indexMetaData).build();

    ClusterState state = ClusterState.builder(ClusterName.CLUSTER_NAME_SETTING.getDefault(Settings.EMPTY))
        .metaData(metaData)
        .routingTable(RoutingTable.builder().addAsRestore(metaData.index("test"),
            new SnapshotRecoverySource(new Snapshot("rep1", new SnapshotId("snp1", UUIDs.randomBase64UUID())),
            Version.CURRENT, "test")).build())
        .nodes(DiscoveryNodes.builder().add(newNode).add(oldNode1).add(oldNode2)).build();
    AllocationDeciders allocationDeciders = new AllocationDeciders(Settings.EMPTY, Arrays.asList(
        new ReplicaAfterPrimaryActiveAllocationDecider(Settings.EMPTY),
        new NodeVersionAllocationDecider(Settings.EMPTY)));
    AllocationService strategy = new MockAllocationService(Settings.EMPTY,
        allocationDeciders,
        new TestGatewayAllocator(), new BalancedShardsAllocator(Settings.EMPTY), EmptyClusterInfoService.INSTANCE);
    state = strategy.reroute(state, new AllocationCommands(), true, false).getClusterState();

    // Make sure that primary shards are only allocated on the new node
    for (int i = 0; i < numberOfShards; i++) {
        assertEquals("newNode", state.routingTable().index("test").getShards().get(i).primaryShard().currentNodeId());
    }
}
 

import org.elasticsearch.cluster.metadata.IndexMetaData; //导入方法依赖的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.IndexMetaData; //导入方法依赖的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.IndexMetaData; //导入方法依赖的package包/类
private List<ClusterState> simulateClusterRecoveryStates(final String indexName,
                                                         final boolean withPreviousAllocationIds,
                                                         final boolean withPrimaryAllocationFailures) {
    final int numberOfShards = randomIntBetween(1, 5);
    final int numberOfReplicas = randomIntBetween(1, numberOfShards);
    // initial index creation and new routing table info
    IndexMetaData indexMetaData = IndexMetaData.builder(indexName)
                                               .settings(settings(Version.CURRENT)
                                                             .put(IndexMetaData.SETTING_INDEX_UUID, UUIDs.randomBase64UUID()))
                                               .numberOfShards(numberOfShards)
                                               .numberOfReplicas(numberOfReplicas)
                                               .state(IndexMetaData.State.OPEN)
                                               .build();
    if (withPreviousAllocationIds) {
        final IndexMetaData.Builder idxMetaWithAllocationIds = IndexMetaData.builder(indexMetaData);
        boolean atLeastOne = false;
        for (int i = 0; i < numberOfShards; i++) {
            if (atLeastOne == false || randomBoolean()) {
                idxMetaWithAllocationIds.putInSyncAllocationIds(i, Sets.newHashSet(UUIDs.randomBase64UUID()));
                atLeastOne = true;
            }
        }
        indexMetaData = idxMetaWithAllocationIds.build();
    }
    final MetaData metaData = MetaData.builder().put(indexMetaData, true).build();
    final RoutingTable routingTable = RoutingTable.builder().addAsRecovery(indexMetaData).build();

    ClusterState clusterState = ClusterState.builder(new ClusterName("test_cluster"))
                                            .metaData(metaData)
                                            .routingTable(routingTable)
                                            .build();
    return generateClusterStates(clusterState, indexName, numberOfReplicas, withPrimaryAllocationFailures);
}
 

import org.elasticsearch.cluster.metadata.IndexMetaData; //导入方法依赖的package包/类
/**
 * Updates in-sync allocations with routing changes that were made to the routing table.
 */
private IndexMetaData.Builder updateInSyncAllocations(RoutingTable newRoutingTable, IndexMetaData oldIndexMetaData,
                                                      IndexMetaData.Builder indexMetaDataBuilder, ShardId shardId, Updates updates) {
    assert Sets.haveEmptyIntersection(updates.addedAllocationIds, updates.removedAllocationIds) :
        "allocation ids cannot be both added and removed in the same allocation round, added ids: " +
            updates.addedAllocationIds + ", removed ids: " + updates.removedAllocationIds;

    Set<String> oldInSyncAllocationIds = oldIndexMetaData.inSyncAllocationIds(shardId.id());

    // check if we have been force-initializing an empty primary or a stale primary
    if (updates.initializedPrimary != null && oldInSyncAllocationIds.isEmpty() == false &&
        oldInSyncAllocationIds.contains(updates.initializedPrimary.allocationId().getId()) == false) {
        // we're not reusing an existing in-sync allocation id to initialize a primary, which means that we're either force-allocating
        // an empty or a stale primary (see AllocateEmptyPrimaryAllocationCommand or AllocateStalePrimaryAllocationCommand).
        RecoverySource.Type recoverySourceType = updates.initializedPrimary.recoverySource().getType();
        boolean emptyPrimary = recoverySourceType == RecoverySource.Type.EMPTY_STORE;
        assert updates.addedAllocationIds.isEmpty() : (emptyPrimary ? "empty" : "stale") +
            " primary is not force-initialized in same allocation round where shards are started";

        if (indexMetaDataBuilder == null) {
            indexMetaDataBuilder = IndexMetaData.builder(oldIndexMetaData);
        }
        if (emptyPrimary) {
            // forcing an empty primary resets the in-sync allocations to the empty set (ShardRouting.allocatedPostIndexCreate)
            indexMetaDataBuilder.putInSyncAllocationIds(shardId.id(), Collections.emptySet());
        } else {
            // forcing a stale primary resets the in-sync allocations to the singleton set with the stale id
            indexMetaDataBuilder.putInSyncAllocationIds(shardId.id(),
                Collections.singleton(updates.initializedPrimary.allocationId().getId()));
        }
    } else {
        // standard path for updating in-sync ids
        Set<String> inSyncAllocationIds = new HashSet<>(oldInSyncAllocationIds);
        inSyncAllocationIds.addAll(updates.addedAllocationIds);
        inSyncAllocationIds.removeAll(updates.removedAllocationIds);

        // Prevent set of inSyncAllocationIds to grow unboundedly. This can happen for example if we don't write to a primary
        // but repeatedly shut down nodes that have active replicas.
        // We use number_of_replicas + 1 (= possible active shard copies) to bound the inSyncAllocationIds set
        // Only trim the set of allocation ids when it grows, otherwise we might trim too eagerly when the number
        // of replicas was decreased while shards were unassigned.
        int maxActiveShards = oldIndexMetaData.getNumberOfReplicas() + 1; // +1 for the primary
        IndexShardRoutingTable newShardRoutingTable = newRoutingTable.shardRoutingTable(shardId);
        if (inSyncAllocationIds.size() > oldInSyncAllocationIds.size() && inSyncAllocationIds.size() > maxActiveShards) {
            // trim entries that have no corresponding shard routing in the cluster state (i.e. trim unavailable copies)
            List<ShardRouting> assignedShards = newShardRoutingTable.assignedShards();
            assert assignedShards.size() <= maxActiveShards :
                "cannot have more assigned shards " + assignedShards + " than maximum possible active shards " + maxActiveShards;
            Set<String> assignedAllocations = assignedShards.stream().map(s -> s.allocationId().getId()).collect(Collectors.toSet());
            inSyncAllocationIds = inSyncAllocationIds.stream()
                .sorted(Comparator.comparing(assignedAllocations::contains).reversed()) // values with routing entries first
                .limit(maxActiveShards)
                .collect(Collectors.toSet());
        }

        // only remove allocation id of failed active primary if there is at least one active shard remaining. Assume for example that
        // the primary fails but there is no new primary to fail over to. If we were to remove the allocation id of the primary from the
        // in-sync set, this could create an empty primary on the next allocation.
        if (newShardRoutingTable.activeShards().isEmpty() && updates.firstFailedPrimary != null) {
            // add back allocation id of failed primary
            inSyncAllocationIds.add(updates.firstFailedPrimary.allocationId().getId());
        }

        assert inSyncAllocationIds.isEmpty() == false || oldInSyncAllocationIds.isEmpty() :
            "in-sync allocations cannot become empty after they have been non-empty: " + oldInSyncAllocationIds;

        // be extra safe here and only update in-sync set if it is non-empty
        if (inSyncAllocationIds.isEmpty() == false) {
            if (indexMetaDataBuilder == null) {
                indexMetaDataBuilder = IndexMetaData.builder(oldIndexMetaData);
            }
            indexMetaDataBuilder.putInSyncAllocationIds(shardId.id(), inSyncAllocationIds);
        }
    }
    return indexMetaDataBuilder;
}