One of the main roles of the master is to decide which shards to allocate to which nodes, and when to move shards between nodes in order to rebalance the cluster.

Configures classes and services that affect the entire cluster

    public static final Setting<Allocation> CLUSTER_ROUTING_ALLOCATION_ENABLE_SETTING =

        new Setting<>("cluster.routing.allocation.enable", Allocation.ALL.toString(), Allocation::parse,

            Property.Dynamic, Property.NodeScope);

    public static final Setting<Allocation> INDEX_ROUTING_ALLOCATION_ENABLE_SETTING =

        new Setting<>("index.routing.allocation.enable", Allocation.ALL.toString(), Allocation::parse,

            Property.Dynamic, Property.IndexScope);

    public static final Setting<Rebalance> CLUSTER_ROUTING_REBALANCE_ENABLE_SETTING =

        new Setting<>("cluster.routing.rebalance.enable", Rebalance.ALL.toString(), Rebalance::parse,

            Property.Dynamic, Property.NodeScope);

    public static final Setting<Rebalance> INDEX_ROUTING_REBALANCE_ENABLE_SETTING =

        new Setting<>("index.routing.rebalance.enable", Rebalance.ALL.toString(), Rebalance::parse,

            Property.Dynamic, Property.IndexScope);

    private volatile Rebalance enableRebalance;

    private volatile Allocation enableAllocation;

 public static Collection<AllocationDecider> createAllocationDeciders(Settings settings, ClusterSettings clusterSettings,

                                                                         List<ClusterPlugin> clusterPlugins) {

        // collect deciders by class so that we can detect duplicates

        Map<Class, AllocationDecider> deciders = new LinkedHashMap<>();

        addAllocationDecider(deciders, new MaxRetryAllocationDecider(settings));

        addAllocationDecider(deciders, new ResizeAllocationDecider(settings));

        addAllocationDecider(deciders, new ReplicaAfterPrimaryActiveAllocationDecider(settings));

        addAllocationDecider(deciders, new RebalanceOnlyWhenActiveAllocationDecider(settings));

        addAllocationDecider(deciders, new ClusterRebalanceAllocationDecider(settings, clusterSettings));

        addAllocationDecider(deciders, new ConcurrentRebalanceAllocationDecider(settings, clusterSettings));

        addAllocationDecider(deciders, new EnableAllocationDecider(settings, clusterSettings));

        addAllocationDecider(deciders, new NodeVersionAllocationDecider(settings));

        addAllocationDecider(deciders, new SnapshotInProgressAllocationDecider(settings));

        addAllocationDecider(deciders, new RestoreInProgressAllocationDecider(settings));

        addAllocationDecider(deciders, new FilterAllocationDecider(settings, clusterSettings));

        addAllocationDecider(deciders, new SameShardAllocationDecider(settings, clusterSettings));

        addAllocationDecider(deciders, new DiskThresholdDecider(settings, clusterSettings));

        addAllocationDecider(deciders, new ThrottlingAllocationDecider(settings, clusterSettings));

        addAllocationDecider(deciders, new ShardsLimitAllocationDecider(settings, clusterSettings));

        addAllocationDecider(deciders, new AwarenessAllocationDecider(settings, clusterSettings));

        clusterPlugins.stream()

            .flatMap(p -> p.createAllocationDeciders(settings, clusterSettings).stream())

            .forEach(d -> addAllocationDecider(deciders, d));

        return deciders.values();

    }

    private static ShardsAllocator createShardsAllocator(Settings settings, ClusterSettings clusterSettings,

                                                         List<ClusterPlugin> clusterPlugins) {

        Map<String, Supplier<ShardsAllocator>> allocators = new HashMap<>();

        allocators.put(BALANCED_ALLOCATOR, () -> new BalancedShardsAllocator(settings, clusterSettings));

        for (ClusterPlugin plugin : clusterPlugins) {

            plugin.getShardsAllocators(settings, clusterSettings).forEach((k, v) -> {

                if (allocators.put(k, v) != null) {

                    throw new IllegalArgumentException("ShardsAllocator [" + k + "] already defined");

                }

            });

        }

        String allocatorName = SHARDS_ALLOCATOR_TYPE_SETTING.get(settings);

        Supplier<ShardsAllocator> allocatorSupplier = allocators.get(allocatorName);

        if (allocatorSupplier == null) {

            throw new IllegalArgumentException("Unknown ShardsAllocator [" + allocatorName + "]");

        }

        return Objects.requireNonNull(allocatorSupplier.get(),

            "ShardsAllocator factory for [" + allocatorName + "] returned null");

    }

    @Override

    protected synchronized void doStart() {

        clusterApplierService.start();

        masterService.start();

    }

    @Override

    protected synchronized void doStart() {

        Objects.requireNonNull(nodeConnectionsService, "please set the node connection service before starting");

        Objects.requireNonNull(state.get(), "please set initial state before starting");

        addListener(localNodeMasterListeners);

        threadPoolExecutor = EsExecutors.newSinglePrioritizing(

                nodeName + "/" + CLUSTER_UPDATE_THREAD_NAME,

                daemonThreadFactory(settings, CLUSTER_UPDATE_THREAD_NAME),

                threadPool.getThreadContext(),

                threadPool.scheduler());

    }

    @Override

    protected synchronized void doStart() {

        Objects.requireNonNull(clusterStatePublisher, "please set a cluster state publisher before starting");

        Objects.requireNonNull(clusterStateSupplier, "please set a cluster state supplier before starting");

        threadPoolExecutor = EsExecutors.newSinglePrioritizing(

                nodeName + "/" + MASTER_UPDATE_THREAD_NAME,

                daemonThreadFactory(settings, MASTER_UPDATE_THREAD_NAME),

                threadPool.getThreadContext(),

                threadPool.scheduler());

        taskBatcher = new Batcher(logger, threadPoolExecutor);

    }