RegionMergeTransactionImpl (Apache HBase 1.2.12 API)

java.lang.Object
- org.apache.hadoop.hbase.regionserver.RegionMergeTransactionImpl

All Implemented Interfaces:: RegionMergeTransaction

@InterfaceAudience.Private
public class RegionMergeTransactionImpl
extends Object
implements RegionMergeTransaction

Nested Class Summary

Nested Classes
Modifier and Type Class and Description

static class RegionMergeTransactionImpl.JournalEntryImpl
- Nested classes/interfaces inherited from interface org.apache.hadoop.hbase.regionserver.RegionMergeTransaction
  RegionMergeTransaction.JournalEntry, RegionMergeTransaction.RegionMergeTransactionPhase, RegionMergeTransaction.TransactionListener

Nested Classes
Modifier and Type	Class and Description
`static class`	`RegionMergeTransactionImpl.JournalEntryImpl`

Field Summary

Fields
Modifier and Type	Field and Description
`private static IOException`	`closedByOtherException`
`private RegionMergeTransaction.RegionMergeTransactionPhase`	`currentPhase`
`private boolean`	`forcible`
`private List<RegionMergeTransaction.JournalEntry>`	`journal`
`private ArrayList<RegionMergeTransaction.TransactionListener>`	`listeners`
`private static org.apache.commons.logging.Log`	`LOG`
`private long`	`masterSystemTime`
`private HRegionInfo`	`mergedRegionInfo`
`private org.apache.hadoop.fs.Path`	`mergesdir`
`private HRegion`	`region_a`
`private HRegion`	`region_b`
`private RegionMergeCoordination.RegionMergeDetails`	`rmd`
`private RegionServerCoprocessorHost`	`rsCoprocessorHost`
`private RegionServerServices`	`rsServices`
`private Server`	`server`
`private boolean`	`useCoordinationForAssignment`

Constructor Summary

Constructors
Constructor and Description
`RegionMergeTransactionImpl(Region a, Region b, boolean forcible)` Constructor
`RegionMergeTransactionImpl(Region a, Region b, boolean forcible, long masterSystemTime)` Constructor

Method Summary

Methods
Modifier and Type	Method and Description
`private static Put`	`addEmptyLocation(Put p, int replicaId)`
`Put`	`addLocation(Put p, ServerName sn, long openSeqNum)`
`private Map<byte[],List<StoreFile>>`	`closeAndOfflineRegion(RegionServerServices services, HRegion region, boolean isRegionA, boolean testing)` Close the merging region and offline it in regionserver
`(package private) HRegion`	`createMergedRegion(Server server, RegionServerServices services, User user)` Prepare the merged region and region files.
`(package private) HRegion`	`createMergedRegionFromMerges(HRegion a, HRegion b, HRegionInfo mergedRegion)` Create a merged region from the merges directory under region a.
`HRegion`	`execute(Server server, RegionServerServices services)` Run the transaction.
`HRegion`	`execute(Server server, RegionServerServices services, User user)` Run the transaction.
`List<RegionMergeTransaction.JournalEntry>`	`getJournal()` Get the journal for the transaction.
`HRegionInfo`	`getMergedRegionInfo()`
`static HRegionInfo`	`getMergedRegionInfo(HRegionInfo a, HRegionInfo b)` Get merged region info through the specified two regions
`(package private) org.apache.hadoop.fs.Path`	`getMergesDir()`
`RegionServerServices`	`getRegionServerServices()` Get the RegonServerServices of the server running the transaction or rollback
`Server`	`getServer()` Get the Server running the transaction or rollback
`(package private) boolean`	`hasMergeQualifierInMeta(RegionServerServices services, byte[] regionName)` Checks if the given region has merge qualifier in hbase:meta
`private void`	`mergeRegionsAndPutMetaEntries(HConnection hConnection, HRegionInfo mergedRegion, HRegionInfo regionA, HRegionInfo regionB, ServerName serverName, List<Mutation> metaEntries, int regionReplication)`
`private void`	`mergeStoreFiles(Map<byte[],List<StoreFile>> hstoreFilesOfRegionA, Map<byte[],List<StoreFile>> hstoreFilesOfRegionB)` Create reference file(s) of merging regions under the region_a merges dir
`(package private) void`	`openMergedRegion(Server server, RegionServerServices services, HRegion merged)` Perform time consuming opening of the merged region.
`boolean`	`prepare(RegionServerServices services)` Does checks on merge inputs.
`void`	`prepareMutationsForMerge(HRegionInfo mergedRegion, HRegionInfo regionA, HRegionInfo regionB, ServerName serverName, List<Mutation> mutations, int regionReplication)`
`RegionMergeTransaction`	`registerTransactionListener(RegionMergeTransaction.TransactionListener listener)` Register a listener for transaction preparation, execution, and possibly rollback phases.
`boolean`	`rollback(Server server, RegionServerServices services)` Roll back a failed transaction
`boolean`	`rollback(Server server, RegionServerServices services, User user)` Roll back a failed transaction
`void`	`stepsAfterPONR(Server server, RegionServerServices services, HRegion mergedRegion)` Deprecated.
`void`	`stepsAfterPONR(Server server, RegionServerServices services, HRegion mergedRegion, User user)`
`HRegion`	`stepsBeforePONR(Server server, RegionServerServices services, boolean testing)`
`private void`	`transition(RegionMergeTransaction.RegionMergeTransactionPhase nextPhase)`
`private void`	`transition(RegionMergeTransaction.RegionMergeTransactionPhase nextPhase, boolean isRollback)`
`private boolean`	`useCoordination(Server server)`

Methods inherited from class java.lang.Object
clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

Field Detail

LOG

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

mergedRegionInfo
```
private HRegionInfo mergedRegionInfo
```

region_a
```
private final HRegion region_a
```

region_b
```
private final HRegion region_b
```

mergesdir

private final org.apache.hadoop.fs.Path mergesdir

forcible
```
private final boolean forcible
```

useCoordinationForAssignment

private boolean useCoordinationForAssignment

masterSystemTime
```
private final long masterSystemTime
```

currentPhase

private RegionMergeTransaction.RegionMergeTransactionPhase currentPhase

server
```
private Server server
```

rsServices

private RegionServerServices rsServices

journal

private final List<RegionMergeTransaction.JournalEntry> journal

listeners

private final ArrayList<RegionMergeTransaction.TransactionListener> listeners

closedByOtherException

private static IOException closedByOtherException

rsCoprocessorHost

private RegionServerCoprocessorHost rsCoprocessorHost

rmd

private RegionMergeCoordination.RegionMergeDetails rmd

Constructor Detail

RegionMergeTransactionImpl

public RegionMergeTransactionImpl(Region a,
                          Region b,
                          boolean forcible)

Constructor

Parameters:: a - region a to merge; b - region b to merge; forcible - if false, we will only merge adjacent regions

RegionMergeTransactionImpl

public RegionMergeTransactionImpl(Region a,
                          Region b,
                          boolean forcible,
                          long masterSystemTime)

Constructor

Parameters:: a - region a to merge; b - region b to merge; forcible - if false, we will only merge adjacent regions; masterSystemTime - the time at the master side

Method Detail
- transition
```
private void transition(RegionMergeTransaction.RegionMergeTransactionPhase nextPhase)
                 throws IOException
```
  Throws:
  
  IOException
- transition
```
private void transition(RegionMergeTransaction.RegionMergeTransactionPhase nextPhase,
              boolean isRollback)
                 throws IOException
```
  Throws:
  
  IOException
- prepare
```
public boolean prepare(RegionServerServices services)
                throws IOException
```
  Does checks on merge inputs.
  
  Specified by:
  
  prepare in interface RegionMergeTransaction
  
  Parameters:
  services -
  
  Returns:
  true if the regions are mergeable else false if they are not (e.g. its already closed, etc.).
  
  Throws:
  
  IOException
- execute
```
public HRegion execute(Server server,
              RegionServerServices services)
                throws IOException
```
  Run the transaction.
  
  Specified by:
  
  execute in interface RegionMergeTransaction
  
  Parameters:
  server - Hosting server instance. Can be null when testing
  services - Used to online/offline regions.
  
  Returns:
  merged region
  
  Throws:
  
  IOException - If thrown, transaction failed. Call rollback(Server, RegionServerServices)
  
  IOException
  See Also:
  rollback(Server, RegionServerServices)
- execute
```
public HRegion execute(Server server,
              RegionServerServices services,
              User user)
                throws IOException
```
  Description copied from interface: RegionMergeTransaction
  
  Run the transaction.
  
  Specified by:
  
  execute in interface RegionMergeTransaction
  
  Parameters:
  server - Hosting server instance. Can be null when testing
  services - Used to online/offline regions.
  
  Returns:
  merged region
  
  Throws:
  
  IOException - If thrown, transaction failed. Call RegionMergeTransaction.rollback(Server, RegionServerServices)
  See Also:
  RegionMergeTransaction.rollback(Server, RegionServerServices, User)
- stepsAfterPONR
```
@Deprecated
public void stepsAfterPONR(Server server,
                             RegionServerServices services,
                             HRegion mergedRegion)
                    throws IOException
```
  Deprecated.
  
  Throws:
  
  IOException
- stepsAfterPONR
```
public void stepsAfterPONR(Server server,
                  RegionServerServices services,
                  HRegion mergedRegion,
                  User user)
                    throws IOException
```
  Throws:
  
  IOException
- createMergedRegion
```
HRegion createMergedRegion(Server server,
                         RegionServerServices services,
                         User user)
                     throws IOException
```
  Prepare the merged region and region files.
  
  Parameters:
  server - Hosting server instance. Can be null when testing
  services - Used to online/offline regions.
  
  Returns:
  merged region
  
  Throws:
  
  IOException - If thrown, transaction failed. Call rollback(Server, RegionServerServices)
- mergeRegionsAndPutMetaEntries
```
private void mergeRegionsAndPutMetaEntries(HConnection hConnection,
                                 HRegionInfo mergedRegion,
                                 HRegionInfo regionA,
                                 HRegionInfo regionB,
                                 ServerName serverName,
                                 List<Mutation> metaEntries,
                                 int regionReplication)
                                    throws IOException
```
  Throws:
  
  IOException
- prepareMutationsForMerge
```
public void prepareMutationsForMerge(HRegionInfo mergedRegion,
                            HRegionInfo regionA,
                            HRegionInfo regionB,
                            ServerName serverName,
                            List<Mutation> mutations,
                            int regionReplication)
                              throws IOException
```
  Throws:
  
  IOException
- addLocation
```
public Put addLocation(Put p,
              ServerName sn,
              long openSeqNum)
```
- addEmptyLocation
```
private static Put addEmptyLocation(Put p,
                   int replicaId)
```
- stepsBeforePONR
```
public HRegion stepsBeforePONR(Server server,
                      RegionServerServices services,
                      boolean testing)
                        throws IOException
```
  Throws:
  
  IOException
- createMergedRegionFromMerges
```
HRegion createMergedRegionFromMerges(HRegion a,
                                   HRegion b,
                                   HRegionInfo mergedRegion)
                               throws IOException
```
  Create a merged region from the merges directory under region a. In order to mock it for tests, place it with a new method.
  
  Parameters:
  a - hri of region a
  b - hri of region b
  mergedRegion - hri of merged region
  
  Returns:
  merged HRegion.
  
  Throws:
  
  IOException
- closeAndOfflineRegion
```
private Map<byte[],List<StoreFile>> closeAndOfflineRegion(RegionServerServices services,
                                                HRegion region,
                                                boolean isRegionA,
                                                boolean testing)
                                                   throws IOException
```
  Close the merging region and offline it in regionserver
  
  Parameters:
  services -
  region -
  isRegionA - true if it is merging region a, false if it is region b
  testing - true if it is testing
  
  Returns:
  a map of family name to list of store files
  
  Throws:
  
  IOException
- getMergedRegionInfo
```
public static HRegionInfo getMergedRegionInfo(HRegionInfo a,
                              HRegionInfo b)
```
  Get merged region info through the specified two regions
  
  Parameters:
  a - merging region A
  b - merging region B
  
  Returns:
  the merged region info
- openMergedRegion
```
void openMergedRegion(Server server,
                    RegionServerServices services,
                    HRegion merged)
                throws IOException
```
  Perform time consuming opening of the merged region.
  
  Parameters:
  server - Hosting server instance. Can be null when testing
  services - Used to online/offline regions.
  merged - the merged region
  
  Throws:
  
  IOException - If thrown, transaction failed. Call rollback(Server, RegionServerServices)
- mergeStoreFiles
```
private void mergeStoreFiles(Map<byte[],List<StoreFile>> hstoreFilesOfRegionA,
                   Map<byte[],List<StoreFile>> hstoreFilesOfRegionB)
                      throws IOException
```
  Create reference file(s) of merging regions under the region_a merges dir
  
  Parameters:
  hstoreFilesOfRegionA -
  hstoreFilesOfRegionB -
  
  Throws:
  
  IOException
- rollback
```
public boolean rollback(Server server,
               RegionServerServices services)
                 throws IOException
```
  Description copied from interface: RegionMergeTransaction
  
  Roll back a failed transaction
  
  Specified by:
  
  rollback in interface RegionMergeTransaction
  
  Parameters:
  server - Hosting server instance (May be null when testing).
  services - Services of regionserver, used to online regions.
  
  Returns:
  True if we successfully rolled back, false if we got to the point of no return and so now need to abort the server to minimize damage.
  
  Throws:
  
  IOException - If thrown, rollback failed. Take drastic action.
- rollback
```
public boolean rollback(Server server,
               RegionServerServices services,
               User user)
                 throws IOException
```
  Description copied from interface: RegionMergeTransaction
  
  Roll back a failed transaction
  
  Specified by:
  
  rollback in interface RegionMergeTransaction
  
  Parameters:
  server - Hosting server instance (May be null when testing).
  services - Services of regionserver, used to online regions.
  
  Returns:
  True if we successfully rolled back, false if we got to the point of no return and so now need to abort the server to minimize damage.
  
  Throws:
  
  IOException - If thrown, rollback failed. Take drastic action.
- getMergedRegionInfo
```
public HRegionInfo getMergedRegionInfo()
```
  Specified by:
  
  getMergedRegionInfo in interface RegionMergeTransaction
  
  Returns:
  merged region info
- getMergesDir
```
org.apache.hadoop.fs.Path getMergesDir()
```
- useCoordination
```
private boolean useCoordination(Server server)
```
- hasMergeQualifierInMeta
```
boolean hasMergeQualifierInMeta(RegionServerServices services,
                              byte[] regionName)
                          throws IOException
```
  Checks if the given region has merge qualifier in hbase:meta
  
  Parameters:
  services -
  regionName - name of specified region
  
  Returns:
  true if the given region has merge qualifier in META.(It will be cleaned by CatalogJanitor)
  
  Throws:
  
  IOException
- getJournal
```
public List<RegionMergeTransaction.JournalEntry> getJournal()
```
  Description copied from interface: RegionMergeTransaction
  
  Get the journal for the transaction.
  Journal entries are an opaque type represented as JournalEntry. They can also provide useful debugging information via their toString method.
  
  Specified by:
  
  getJournal in interface RegionMergeTransaction
  
  Returns:
  the transaction journal
- registerTransactionListener
```
public RegionMergeTransaction registerTransactionListener(RegionMergeTransaction.TransactionListener listener)
```
  Description copied from interface: RegionMergeTransaction
  
  Register a listener for transaction preparation, execution, and possibly rollback phases.
  A listener can abort a transaction by throwing an exception.
  
  Specified by:
  
  registerTransactionListener in interface RegionMergeTransaction
  
  Parameters:
  listener - the listener
  
  Returns:
  'this' for chaining
- getServer
```
public Server getServer()
```
  Description copied from interface: RegionMergeTransaction
  
  Get the Server running the transaction or rollback
  
  Specified by:
  
  getServer in interface RegionMergeTransaction
  
  Returns:
  server instance
- getRegionServerServices
```
public RegionServerServices getRegionServerServices()
```
  Description copied from interface: RegionMergeTransaction
  
  Get the RegonServerServices of the server running the transaction or rollback
  
  Specified by:
  
  getRegionServerServices in interface RegionMergeTransaction
  
  Returns:
  region server services

Class RegionMergeTransactionImpl

Nested Class Summary

Nested classes/interfaces inherited from interface org.apache.hadoop.hbase.regionserver.RegionMergeTransaction

Field Summary

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Field Detail

LOG

mergedRegionInfo

region_a

region_b

mergesdir

forcible

useCoordinationForAssignment

masterSystemTime

currentPhase

server

rsServices

journal

listeners

closedByOtherException

rsCoprocessorHost

rmd

Constructor Detail

RegionMergeTransactionImpl

RegionMergeTransactionImpl

Method Detail

transition

transition

prepare

execute

execute

stepsAfterPONR

stepsAfterPONR

createMergedRegion

mergeRegionsAndPutMetaEntries

prepareMutationsForMerge

addLocation

addEmptyLocation

stepsBeforePONR

createMergedRegionFromMerges

closeAndOfflineRegion

getMergedRegionInfo

openMergedRegion

mergeStoreFiles

rollback

rollback

getMergedRegionInfo

getMergesDir

useCoordination

hasMergeQualifierInMeta

getJournal

registerTransactionListener

getServer

getRegionServerServices