*

* Licensed to the Apache Software Foundation (ASF) under one

* or more contributor license agreements.  See the NOTICE file

* distributed with this work for additional information

* regarding copyright ownership.  The ASF licenses this file

* to you under the Apache License, Version 2.0 (the

* "License"); you may not use this file except in compliance

* with the License.  You may obtain a copy of the License at

*

*     http://www.apache.org/licenses/LICENSE-2.0

*

* Unless required by applicable law or agreed to in writing, software

* distributed under the License is distributed on an "AS IS" BASIS,

* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.

* See the License for the specific language governing permissions and

* limitations under the License.

*/

* Manages and performs region assignment.

* <p>

* Monitors ZooKeeper for events related to regions in transition.

* <p>

* Handles existing regions in transition during master failover.

*/

  private static final Log LOG = LogFactory.getLog(AssignmentManager.class);

  public static final ServerName HBCK_CODE_SERVERNAME = ServerName.valueOf(HConstants.HBCK_CODE_NAME,

      -1, -1L);

  public static final String ASSIGNMENT_TIMEOUT = "hbase.master.assignment.timeoutmonitor.timeout";

  public static final int DEFAULT_ASSIGNMENT_TIMEOUT_DEFAULT = 600000;

  public static final String ASSIGNMENT_TIMEOUT_MANAGEMENT = "hbase.assignment.timeout.management";

  public static final boolean DEFAULT_ASSIGNMENT_TIMEOUT_MANAGEMENT = false;

  public static final String ALREADY_IN_TRANSITION_WAITTIME

    = "hbase.assignment.already.intransition.waittime";

  public static final int DEFAULT_ALREADY_IN_TRANSITION_WAITTIME = 60000; // 1 minute

  protected final Server server;

  private ServerManager serverManager;

  private boolean shouldAssignRegionsWithFavoredNodes;

  private CatalogTracker catalogTracker;

  protected final TimeoutMonitor timeoutMonitor;

  private final TimerUpdater timerUpdater;

  private LoadBalancer balancer;

  private final MetricsAssignmentManager metricsAssignmentManager;

  private final TableLockManager tableLockManager;

  private AtomicInteger numRegionsOpened = new AtomicInteger(0);

  final private KeyLocker<String> locker = new KeyLocker<String>();

  /**

   * Map of regions to reopen after the schema of a table is changed. Key -

   * encoded region name, value - HRegionInfo

   */

  private final Map <String, HRegionInfo> regionsToReopen;

  /*

   * Maximum times we recurse an assignment/unassignment.

   * See below in {@link #assign()} and {@link #unassign()}.

   */

  private final int maximumAttempts;

  /**

   * Map of two merging regions from the region to be created.

   */

  private final Map<String, PairOfSameType<HRegionInfo>> mergingRegions

    = new HashMap<String, PairOfSameType<HRegionInfo>>();

  /**

   * The sleep time for which the assignment will wait before retrying in case of hbase:meta assignment

   * failure due to lack of availability of region plan

   */

  private final long sleepTimeBeforeRetryingMetaAssignment;

  /** Plans for region movement. Key is the encoded version of a region name*/

  // TODO: When do plans get cleaned out?  Ever? In server open and in server

  // shutdown processing -- St.Ack

  // All access to this Map must be synchronized.

  final NavigableMap<String, RegionPlan> regionPlans =

    new TreeMap<String, RegionPlan>();

  private final ZKTable zkTable;

  /**

   * Contains the server which need to update timer, these servers will be

   * handled by {@link TimerUpdater}

   */

  private final ConcurrentSkipListSet<ServerName> serversInUpdatingTimer;

  private final ExecutorService executorService;

  // For unit tests, keep track of calls to ClosedRegionHandler

  private Map<HRegionInfo, AtomicBoolean> closedRegionHandlerCalled = null;

  // For unit tests, keep track of calls to OpenedRegionHandler

  private Map<HRegionInfo, AtomicBoolean> openedRegionHandlerCalled = null;

  //Thread pool executor service for timeout monitor

  private java.util.concurrent.ExecutorService threadPoolExecutorService;

  // A bunch of ZK events workers. Each is a single thread executor service

  private final java.util.concurrent.ExecutorService zkEventWorkers;

  private List<EventType> ignoreStatesRSOffline = Arrays.asList(

      EventType.RS_ZK_REGION_FAILED_OPEN, EventType.RS_ZK_REGION_CLOSED);

  private final RegionStates regionStates;

  // The threshold to use bulk assigning. Using bulk assignment

  // only if assigning at least this many regions to at least this

  // many servers. If assigning fewer regions to fewer servers,

  // bulk assigning may be not as efficient.

  private final int bulkAssignThresholdRegions;

  private final int bulkAssignThresholdServers;

  // Should bulk assignment wait till all regions are assigned,

  // or it is timed out?  This is useful to measure bulk assignment

  // performance, but not needed in most use cases.

  private final boolean bulkAssignWaitTillAllAssigned;

  /**

   * Indicator that AssignmentManager has recovered the region states so

   * that ServerShutdownHandler can be fully enabled and re-assign regions

   * of dead servers. So that when re-assignment happens, AssignmentManager

   * has proper region states.

   *

   * Protected to ease testing.

   */

  protected final AtomicBoolean failoverCleanupDone = new AtomicBoolean(false);

  /** Is the TimeOutManagement activated **/

  private final boolean tomActivated;

  /**

   * A map to track the count a region fails to open in a row.

   * So that we don't try to open a region forever if the failure is

   * unrecoverable.  We don't put this information in region states

   * because we don't expect this to happen frequently; we don't

   * want to copy this information over during each state transition either.

   */

  private final ConcurrentHashMap<String, AtomicInteger>

    failedOpenTracker = new ConcurrentHashMap<String, AtomicInteger>();

  /**

   * For testing only!  Set to true to skip handling of split.

   */

  @edu.umd.cs.findbugs.annotations.SuppressWarnings(value="MS_SHOULD_BE_FINAL")

  public static boolean TEST_SKIP_SPLIT_HANDLING = false;

  /**

   * Constructs a new assignment manager.

   *

   * @param server

   * @param serverManager

   * @param catalogTracker

   * @param service

   * @throws KeeperException

   * @throws IOException

   */

  public AssignmentManager(Server server, ServerManager serverManager,

      CatalogTracker catalogTracker, final LoadBalancer balancer,

      final ExecutorService service, MetricsMaster metricsMaster,

      final TableLockManager tableLockManager) throws KeeperException, IOException {

    super(server.getZooKeeper());

    this.server = server;

    this.serverManager = serverManager;

    this.catalogTracker = catalogTracker;

    this.executorService = service;

    this.regionsToReopen = Collections.synchronizedMap

                           (new HashMap<String, HRegionInfo> ());

    Configuration conf = server.getConfiguration();

    // Only read favored nodes if using the favored nodes load balancer.

    this.shouldAssignRegionsWithFavoredNodes = conf.getClass(

           HConstants.HBASE_MASTER_LOADBALANCER_CLASS, Object.class).equals(

           FavoredNodeLoadBalancer.class);

    this.tomActivated = conf.getBoolean(

      ASSIGNMENT_TIMEOUT_MANAGEMENT, DEFAULT_ASSIGNMENT_TIMEOUT_MANAGEMENT);

    if (tomActivated){

      this.serversInUpdatingTimer =  new ConcurrentSkipListSet<ServerName>();

      this.timeoutMonitor = new TimeoutMonitor(

        conf.getInt("hbase.master.assignment.timeoutmonitor.period", 30000),

        server, serverManager,

        conf.getInt(ASSIGNMENT_TIMEOUT, DEFAULT_ASSIGNMENT_TIMEOUT_DEFAULT));

      this.timerUpdater = new TimerUpdater(conf.getInt(

        "hbase.master.assignment.timerupdater.period", 10000), server);

      Threads.setDaemonThreadRunning(timerUpdater.getThread(),

        server.getServerName() + ".timerUpdater");

    } else {

      this.serversInUpdatingTimer =  null;

      this.timeoutMonitor = null;

      this.timerUpdater = null;

    }

    this.zkTable = new ZKTable(this.watcher);

    // This is the max attempts, not retries, so it should be at least 1.

    this.maximumAttempts = Math.max(1,

      this.server.getConfiguration().getInt("hbase.assignment.maximum.attempts", 10));

    this.sleepTimeBeforeRetryingMetaAssignment = this.server.getConfiguration().getLong(