SplitLogManagerCoordination (Apache HBase 1.4.11 API)

All Known Implementing Classes:

ZKSplitLogManagerCoordination
```
@InterfaceAudience.Private
public interface SplitLogManagerCoordination
```
Coordination for SplitLogManager. It creates and works with tasks for split log operations
Manager prepares task by calling prepareTask(java.lang.String) and submit it by submitTask(String). After that it periodically check the number of remaining tasks by remainingTasksInCoordination() and waits until it become zero.
Methods required for task life circle:
markRegionsRecovering(ServerName, Set) mark regions for log replaying. Used by MasterFileSystem
removeRecoveringRegions(Set, Boolean) make regions cleanup that previous were marked as recovering. Called after all tasks processed
removeStaleRecoveringRegions(Set) remove stale recovering. called by MasterFileSystem after Active Master is initialized
getLastRecoveryTime() required for garbage collector and should indicate when the last recovery has been made
checkTaskStillAvailable(String) Check that task is still there
checkTasks() check for unassigned tasks and resubmit them

Nested Class Summary

Nested Classes
Modifier and Type	Interface and Description
`static class`	`SplitLogManagerCoordination.SplitLogManagerDetails` Detail class that shares data between coordination and split log manager

Method Summary

Methods
Modifier and Type	Method and Description
`void`	`checkTasks()` tells Coordination that it should check for new tasks
`void`	`checkTaskStillAvailable(String task)` Check that the task is still there
`void`	`deleteTask(String taskName)`
`SplitLogManagerCoordination.SplitLogManagerDetails`	`getDetails()` Returns the configuration that was provided previously
`long`	`getLastRecoveryTime()`
`org.apache.hadoop.hbase.protobuf.generated.ZooKeeperProtos.SplitLogTask.RecoveryMode`	`getRecoveryMode()` Temporary function, mostly for UTs.
`void`	`init()` Support method to init constants such as timeout.
`boolean`	`isReplaying()`
`boolean`	`isSplitting()`
`void`	`markRegionsRecovering(ServerName serverName, Set<HRegionInfo> userRegions)` Mark regions in recovering state for distributed log replay
`String`	`prepareTask(String taskName)` Prepare the new task
`int`	`remainingTasksInCoordination()` Return the number of remaining tasks
`void`	`removeRecoveringRegions(Set<String> serverNames, Boolean isMetaRecovery)` It removes recovering regions from Coordination
`void`	`removeStaleRecoveringRegions(Set<String> knownServers)` Removes known stale servers
`boolean`	`resubmitTask(String taskName, SplitLogManager.Task task, SplitLogManager.ResubmitDirective force)` Resubmit the task in case if found unassigned or failed
`void`	`setDetails(SplitLogManagerCoordination.SplitLogManagerDetails details)` Provide the configuration from the SplitLogManager
`void`	`setRecoveryMode(boolean b)` Change the recovery mode.
`void`	`submitTask(String taskName)`

- Method Detail
  - setDetails
```
void setDetails(SplitLogManagerCoordination.SplitLogManagerDetails details)
```
    Provide the configuration from the SplitLogManager
  - getDetails
```
SplitLogManagerCoordination.SplitLogManagerDetails getDetails()
```
    Returns the configuration that was provided previously
  - prepareTask
```
String prepareTask(String taskName)
```
    Prepare the new task
    
    Parameters:
    taskName - name of the task
    
    Returns:
    the task id
  - markRegionsRecovering
```
void markRegionsRecovering(ServerName serverName,
                         Set<HRegionInfo> userRegions)
                           throws IOException,
                                  InterruptedIOException
```
    Mark regions in recovering state for distributed log replay
    
    Parameters:
    serverName - server name
    userRegions - set of regions to be marked
    
    Throws:
    
    IOException - in case of failure
    
    InterruptedIOException
  - checkTasks
```
void checkTasks()
```
    tells Coordination that it should check for new tasks
  - removeRecoveringRegions
```
void removeRecoveringRegions(Set<String> serverNames,
                           Boolean isMetaRecovery)
                             throws IOException
```
    It removes recovering regions from Coordination
    
    Parameters:
    serverNames - servers which are just recovered
    isMetaRecovery - whether current recovery is for the meta region on serverNames
    
    Throws:
    
    IOException
  - remainingTasksInCoordination
```
int remainingTasksInCoordination()
```
    Return the number of remaining tasks
  - checkTaskStillAvailable
```
void checkTaskStillAvailable(String task)
```
    Check that the task is still there
    
    Parameters:
    task - node to check
  - setRecoveryMode
```
void setRecoveryMode(boolean b)
                     throws InterruptedIOException,
                            IOException
```
    Change the recovery mode.
    
    Parameters:
    b - the recovery mode state
    
    Throws:
    
    InterruptedIOException
    
    IOException - in case of failure
  - removeStaleRecoveringRegions
```
void removeStaleRecoveringRegions(Set<String> knownServers)
                                  throws IOException,
                                         InterruptedIOException
```
    Removes known stale servers
    
    Parameters:
    knownServers - set of previously failed servers
    
    Throws:
    
    IOException - in case of failure
    
    InterruptedIOException
  - resubmitTask
```
boolean resubmitTask(String taskName,
                   SplitLogManager.Task task,
                   SplitLogManager.ResubmitDirective force)
```
    Resubmit the task in case if found unassigned or failed
    
    Parameters:
    taskName - path related to task
    task - to resubmit
    force - whether it should be forced
    
    Returns:
    whether it was successful
  - submitTask
```
void submitTask(String taskName)
```
    Parameters:
    taskName - to be submitted
  - deleteTask
```
void deleteTask(String taskName)
```
    Parameters:
    taskName - to be removed
  - isReplaying
```
boolean isReplaying()
```
    Returns:
    shows whether the log recovery mode is in replaying state
  - isSplitting
```
boolean isSplitting()
```
    Returns:
    shows whether the log recovery mode is in splitting state
  - getLastRecoveryTime
```
long getLastRecoveryTime()
```
    Returns:
    the time of last attempt to recover
  - getRecoveryMode
```
org.apache.hadoop.hbase.protobuf.generated.ZooKeeperProtos.SplitLogTask.RecoveryMode getRecoveryMode()
```
    Temporary function, mostly for UTs. In the regular code isReplaying or isSplitting should be used.
    
    Returns:
    the current log recovery mode.
  - init
```
void init()
          throws IOException
```
    Support method to init constants such as timeout. Mostly required for UTs.
    
    Throws:
    
    IOException

Interface SplitLogManagerCoordination

Nested Class Summary

Method Summary

Method Detail

setDetails

getDetails

prepareTask

markRegionsRecovering

checkTasks

removeRecoveringRegions

remainingTasksInCoordination

checkTaskStillAvailable

setRecoveryMode

removeStaleRecoveringRegions

resubmitTask

submitTask

deleteTask

isReplaying

isSplitting

getLastRecoveryTime

getRecoveryMode

init