How to use

builder

method

in

org.elasticsearch.cluster.block.ClusterBlocks

@Override
protected void doStart() {
  DiscoveryNode localNode = transportService.getLocalNode();
  assert localNode != null;
  synchronized (stateMutex) {
    // set initial state
    assert committedState.get() == null;
    assert localNode != null;
    ClusterState.Builder builder = clusterApplier.newClusterStateBuilder();
    ClusterState initialState = builder
      .blocks(ClusterBlocks.builder()
        .addGlobalBlock(STATE_NOT_RECOVERED_BLOCK)
        .addGlobalBlock(discoverySettings.getNoMasterBlock()))
      .nodes(DiscoveryNodes.builder().add(localNode).localNodeId(localNode.getId()))
      .build();
    committedState.set(initialState);
    clusterApplier.setInitialState(initialState);
    nodesFD.setLocalNode(localNode);
    joinThreadControl.start();
  }
  zenPing.start();
}

protected void rejoin(String reason) {
  assert Thread.holdsLock(stateMutex);
  ClusterState clusterState = committedState.get();
  logger.warn("{}, current nodes: {}", reason, clusterState.nodes());
  nodesFD.stop();
  masterFD.stop(reason);
  // TODO: do we want to force a new thread if we actively removed the master? this is to give a full pinging cycle
  // before a decision is made.
  joinThreadControl.startNewThreadIfNotRunning();
  if (clusterState.nodes().getMasterNodeId() != null) {
    // remove block if it already exists before adding new one
    assert clusterState.blocks().hasGlobalBlock(discoverySettings.getNoMasterBlock().id()) == false :
      "NO_MASTER_BLOCK should only be added by ZenDiscovery";
    ClusterBlocks clusterBlocks = ClusterBlocks.builder().blocks(clusterState.blocks())
      .addGlobalBlock(discoverySettings.getNoMasterBlock())
      .build();
    DiscoveryNodes discoveryNodes = new DiscoveryNodes.Builder(clusterState.nodes()).masterNodeId(null).build();
    clusterState = ClusterState.builder(clusterState)
      .blocks(clusterBlocks)
      .nodes(discoveryNodes)
      .build();
    committedState.set(clusterState);
    clusterApplier.onNewClusterState(reason, this::clusterState, (source, e) -> {}); // don't wait for state to be applied
  }
}

protected ClusterState createInitialState(DiscoveryNode localNode) {
  ClusterState.Builder builder = clusterApplier.newClusterStateBuilder();
  return builder.nodes(DiscoveryNodes.builder().add(localNode)
      .localNodeId(localNode.getId())
      .masterNodeId(localNode.getId())
      .build())
    .blocks(ClusterBlocks.builder()
      .addGlobalBlock(STATE_NOT_RECOVERED_BLOCK))
    .build();
}

RoutingTable.Builder routingTableBuilder = RoutingTable.builder(currentState.routingTable());
MetaData.Builder metaDataBuilder = MetaData.builder(meta);
ClusterBlocks.Builder clusterBlocksBuilder = ClusterBlocks.builder().blocks(currentState.blocks());

ClusterBlocks.Builder blocks = ClusterBlocks.builder().blocks(currentState.blocks());
RoutingTable.Builder routingTableBuilder = RoutingTable.builder(currentState.routingTable());
final Version minIndexCompatibilityVersion = currentState.getNodes().getMaxNodeVersion()

ClusterBlocks.Builder blocksBuilder = ClusterBlocks.builder()
  .blocks(currentState.blocks());
for (IndexMetaData openIndexMetadata : indicesToClose) {

ClusterBlocks.Builder blocks = ClusterBlocks.builder().blocks(currentState.blocks());
maybeUpdateClusterBlock(actualIndices, blocks, IndexMetaData.INDEX_READ_ONLY_BLOCK,
  IndexMetaData.INDEX_READ_ONLY_SETTING, openSettings);

private ClusterState.Builder becomeMasterAndTrimConflictingNodes(ClusterState currentState, List<DiscoveryNode> joiningNodes) {
  assert currentState.nodes().getMasterNodeId() == null : currentState;
  DiscoveryNodes currentNodes = currentState.nodes();
  DiscoveryNodes.Builder nodesBuilder = DiscoveryNodes.builder(currentNodes);
  nodesBuilder.masterNodeId(currentState.nodes().getLocalNodeId());
  for (final DiscoveryNode joiningNode : joiningNodes) {
    final DiscoveryNode nodeWithSameId = nodesBuilder.get(joiningNode.getId());
    if (nodeWithSameId != null && nodeWithSameId.equals(joiningNode) == false) {
      logger.debug("removing existing node [{}], which conflicts with incoming join from [{}]", nodeWithSameId, joiningNode);
      nodesBuilder.remove(nodeWithSameId.getId());
    }
    final DiscoveryNode nodeWithSameAddress = currentNodes.findByAddress(joiningNode.getAddress());
    if (nodeWithSameAddress != null && nodeWithSameAddress.equals(joiningNode) == false) {
      logger.debug("removing existing node [{}], which conflicts with incoming join from [{}]", nodeWithSameAddress,
        joiningNode);
      nodesBuilder.remove(nodeWithSameAddress.getId());
    }
  }
  // now trim any left over dead nodes - either left there when the previous master stepped down
  // or removed by us above
  ClusterState tmpState = ClusterState.builder(currentState).nodes(nodesBuilder).blocks(ClusterBlocks.builder()
    .blocks(currentState.blocks())
    .removeGlobalBlock(DiscoverySettings.NO_MASTER_BLOCK_ID)).build();
  return ClusterState.builder(allocationService.deassociateDeadNodes(tmpState, false,
    "removed dead nodes on election"));
}

  indexMetaData.getNumberOfReplicas(), mappings.keySet());
ClusterBlocks.Builder blocks = ClusterBlocks.builder().blocks(currentState.blocks());
if (!request.blocks().isEmpty()) {
  for (ClusterBlock block : request.blocks()) {

    .persistentSettings(Settings.builder().put(persistentFinalSettings).put(unknownOrInvalidPersistentSettings).build());
ClusterBlocks.Builder blocks = ClusterBlocks.builder().blocks(currentState.blocks());
boolean updatedReadOnly = MetaData.SETTING_READ_ONLY_SETTING.get(metaData.persistentSettings())
    || MetaData.SETTING_READ_ONLY_SETTING.get(metaData.transientSettings());

ClusterBlocks.Builder blocksBuilder = ClusterBlocks.builder()
    .blocks(currentState.blocks());
final Version minIndexCompatibilityVersion = currentState.getNodes().getMaxNodeVersion()

ClusterBlocks.Builder blocks = ClusterBlocks.builder().blocks(currentState.blocks());
RoutingTable.Builder rtBuilder = RoutingTable.builder(currentState.routingTable());
ImmutableOpenMap<ShardId, RestoreInProgress.ShardRestoreStatus> shards;

@Override
public ClusterState execute(ClusterState currentState) {
  logger.debug("releasing the cassandra ring block...");
  
  // remove the block, since we recovered from gateway
  ClusterBlocks.Builder blocks = ClusterBlocks.builder().blocks(currentState.blocks()).removeGlobalBlock(NO_CASSANDRA_RING_BLOCK);
  
  // update the state to reflect 
  ClusterState updatedState = ClusterState.builder(currentState).blocks(blocks).incrementVersion().build();
  return updatedState;
}

ClusterBlocks.Builder blocks = ClusterBlocks.builder()
    .blocks(currentState.blocks())
    .blocks(recoveredState.blocks())

public BaseClusterService(Settings settings,
           ClusterSettings clusterSettings, ThreadPool threadPool, Supplier<DiscoveryNode> localNodeSupplier) {
  super(settings);
  this.localNodeSupplier = localNodeSupplier;
  this.operationRouting = new OperationRouting(settings, clusterSettings);
  this.threadPool = threadPool;
  this.clusterSettings = clusterSettings;
  this.clusterName = ClusterName.CLUSTER_NAME_SETTING.get(settings);
  // will be replaced on doStart.
  this.state = new AtomicReference<>(ClusterState.builder(clusterName).build());
  this.clusterSettings.addSettingsUpdateConsumer(CLUSTER_SERVICE_SLOW_TASK_LOGGING_THRESHOLD_SETTING,
      this::setSlowTaskLoggingThreshold);
  this.slowTaskLoggingThreshold = CLUSTER_SERVICE_SLOW_TASK_LOGGING_THRESHOLD_SETTING.get(settings);
  localNodeMasterListeners = new LocalNodeMasterListeners(threadPool);
  //initialBlocks = ClusterBlocks.builder();
  // Add NO_CASSANDRA_RING_BLOCK to avoid to save metadata while cassandra ring not ready.
  initialBlocks = ClusterBlocks.builder().addGlobalBlock(CassandraGatewayService.NO_CASSANDRA_RING_BLOCK);
}

protected ClusterState createInitialState(DiscoveryNode localNode) {
  ClusterState.Builder builder = clusterApplier.newClusterStateBuilder();
  return builder.nodes(DiscoveryNodes.builder().add(localNode)
      .localNodeId(localNode.getId())
      .masterNodeId(localNode.getId())
      .build())
    .blocks(ClusterBlocks.builder()
      .addGlobalBlock(STATE_NOT_RECOVERED_BLOCK))
    .build();
}

protected ClusterState createInitialState(DiscoveryNode localNode) {
  ClusterState.Builder builder = clusterApplier.newClusterStateBuilder();
  return builder.nodes(DiscoveryNodes.builder().add(localNode)
      .localNodeId(localNode.getId())
      .masterNodeId(localNode.getId())
      .build())
    .blocks(ClusterBlocks.builder()
      .addGlobalBlock(STATE_NOT_RECOVERED_BLOCK))
    .build();
}

@Override
public ClusterState execute(ClusterState currentState) {
  DiscoveryNodes.Builder nodesBuilder = DiscoveryNodes.builder();
  for (LocalDiscovery discovery : clusterGroups.get(clusterName).members()) {
    nodesBuilder.put(discovery.localNode());
  }
  nodesBuilder.localNodeId(master.localNode().id()).masterNodeId(master.localNode().id());
  // remove the NO_MASTER block in this case
  ClusterBlocks.Builder blocks = ClusterBlocks.builder().blocks(currentState.blocks()).removeGlobalBlock(discoverySettings.getNoMasterBlock());
  return ClusterState.builder(currentState).nodes(nodesBuilder).blocks(blocks).build();
}

@Override
protected ClusterState createInitialState(DiscoveryNode localNode) {
  ClusterBlocks.Builder clusterBlocks = ClusterBlocks.builder(); // don't add no_master / state recovery block
  if (BLOCKS_WRITE_SETTING.get(settings)) {
    clusterBlocks.addGlobalBlock(TRIBE_WRITE_BLOCK);
  }
  if (BLOCKS_METADATA_SETTING.get(settings)) {
    clusterBlocks.addGlobalBlock(TRIBE_METADATA_BLOCK);
  }
  return ClusterState.builder(ClusterName.CLUSTER_NAME_SETTING.get(settings))
    .nodes(DiscoveryNodes.builder().add(localNode).localNodeId(localNode.getId()).build())
    .blocks(clusterBlocks).build();
}

@Override
public ClusterState execute(ClusterState currentState) {
  // read metadata from the clusterService thread to avoid freeze in gossip.
  MetaData schemaMetaData = clusterService.checkForNewMetaData(version);
  
  ClusterState.Builder newStateBuilder = ClusterState.builder(currentState).nodes(nodes());
  // update blocks
  ClusterBlocks.Builder blocks = ClusterBlocks.builder().blocks(currentState.blocks());
  if (schemaMetaData.settings().getAsBoolean("cluster.blocks.read_only", false))
    blocks.addGlobalBlock(MetaData.CLUSTER_READ_ONLY_BLOCK);
  
  if (schemaMetaData != null) {
    newStateBuilder.metaData(schemaMetaData);
    
    // update indices block.
    for (IndexMetaData indexMetaData : schemaMetaData)
      blocks.updateBlocks(indexMetaData);
  }
  return clusterService.updateNumberOfShardsAndReplicas( newStateBuilder.blocks(blocks).build() );
}