Field Detail

• coordinationManager

  private CoordinatedStateManager coordinationManager

• watcher

  private final ZooKeeperWatcher watcher

• LOG

  private static final org.apache.commons.logging.Log LOG

Constructor Detail

• ZKSplitTransactionCoordination

  public ZKSplitTransactionCoordination(CoordinatedStateManager coordinationProvider,
                                ZooKeeperWatcher watcher)

Method Detail

• startSplitTransaction

  public void startSplitTransaction(HRegion parent,
                           ServerName serverName,
                           HRegionInfo hri_a,
                           HRegionInfo hri_b)
                             throws IOException

  Creates a new ephemeral node in the PENDING_SPLIT state for the specified region. Create it ephemeral in case regionserver dies mid-split.

  Does not transition nodes from other states. If a node already exists for this region, an Exception will be thrown.

  Specified by:

  startSplitTransaction in interface SplitTransactionCoordination

  Parameters:

  parent - region to be created as offline

  serverName - server event originates from

  hri_a - daughter region

  hri_b - daughter region

  Throws:

  IOException

• transitionSplittingNode

  private int transitionSplittingNode(HRegionInfo parent,
                            HRegionInfo a,
                            HRegionInfo b,
                            ServerName serverName,
                            SplitTransactionCoordination.SplitTransactionDetails std,
                            EventType beginState,
                            EventType endState)
                               throws IOException

  Transitions an existing ephemeral node for the specified region which is currently in the begin state to be in the end state. Master cleans up the final SPLIT znode when it reads it (or if we crash, zk will clean it up).

  Does not transition nodes from other states. If for some reason the node could not be transitioned, the method returns -1. If the transition is successful, the version of the node after transition is returned.

  This method can fail and return false for three different reasons:

  • Node for this region does not exist
  • Node for this region is not in the begin state
  • After verifying the begin state, update fails because of wrong version (this should never actually happen since an RS only does this transition following a transition to the begin state. If two RS are conflicting, one would fail the original transition to the begin state and not this transition)

  Does not set any watches.

  This method should only be used by a RegionServer when splitting a region.

  Parameters:

  parent - region to be transitioned to opened

  a - Daughter a of split

  b - Daughter b of split

  serverName - server event originates from

  std - split transaction details

  beginState - the expected current state the znode should be

  endState - the state to be transition to

  Returns:

  version of node after transition, -1 if unsuccessful transition

  Throws:

  IOException

• waitForSplitTransaction

  public void waitForSplitTransaction(RegionServerServices services,
                             Region parent,
                             HRegionInfo hri_a,
                             HRegionInfo hri_b,
                             SplitTransactionCoordination.SplitTransactionDetails sptd)
                               throws IOException

  Wait for the splitting node to be transitioned from pending_split to splitting by master. That's how we are sure master has processed the event and is good with us to move on. If we don't get any update, we periodically transition the node so that master gets the callback. If the node is removed or is not in pending_split state any more, we abort the split.

  Specified by:

  waitForSplitTransaction in interface SplitTransactionCoordination

  Parameters:

  services - Used to online/offline regions.

  parent - region

  hri_a - daughter region

  hri_b - daughter region

  sptd - split transaction details

  Throws:

  IOException

• completeSplitTransaction

  public void completeSplitTransaction(RegionServerServices services,
                              Region a,
                              Region b,
                              SplitTransactionCoordination.SplitTransactionDetails std,
                              Region parent)
                                throws IOException

  Finish off split transaction, transition the zknode

  Specified by:

  completeSplitTransaction in interface SplitTransactionCoordination

  Parameters:

  services - Used to online/offline regions.

  a - daughter region

  b - daughter region

  std - split transaction details

  parent -

  Throws:

  IOException - If thrown, transaction failed. Call SplitTransaction.rollback( Server, RegionServerServices)

• clean

  public void clean(HRegionInfo hri)

  Description copied from interface: SplitTransactionCoordination
  clean the split transaction

  Specified by:

  clean in interface SplitTransactionCoordination

  Parameters:

  hri - node to delete

• getDefaultDetails

  public SplitTransactionCoordination.SplitTransactionDetails getDefaultDetails()

  Specified by:

  getDefaultDetails in interface SplitTransactionCoordination

• processTransition

  public int processTransition(HRegionInfo p,
                      HRegionInfo hri_a,
                      HRegionInfo hri_b,
                      ServerName sn,
                      SplitTransactionCoordination.SplitTransactionDetails std)
                        throws IOException

  Description copied from interface: SplitTransactionCoordination
  Required by AssignmentManager

  Specified by:

  processTransition in interface SplitTransactionCoordination

  Throws:

  IOException