ZKProcedureMemberRpcs (Apache HBase 1.2.12 API)

java.lang.Object
- org.apache.hadoop.hbase.procedure.ZKProcedureMemberRpcs

All Implemented Interfaces:

Closeable, AutoCloseable, ProcedureMemberRpcs
```
@InterfaceAudience.Private
public class ZKProcedureMemberRpcs
extends Object
implements ProcedureMemberRpcs
```
ZooKeeper based controller for a procedure member.
There can only be one ZKProcedureMemberRpcs per procedure type per member, since each procedure type is bound to a single set of znodes. You can have multiple ZKProcedureMemberRpcs on the same server, each serving a different member name, but each individual rpcs is still bound to a single member name (and since they are used to determine global progress, its important to not get this wrong).
To make this slightly more confusing, you can run multiple, concurrent procedures at the same time (as long as they have different types), from the same controller, but the same node name must be used for each procedure (though there is no conflict between the two procedure as long as they have distinct names).
There is no real error recovery with this mechanism currently -- if any the coordinator fails, its re-initialization will delete the znodes and require all in progress subprocedures to start anew.

Field Summary

Fields
Modifier and Type	Field and Description
`private static org.apache.commons.logging.Log`	`LOG`
`protected ProcedureMember`	`member`
`private String`	`memberName`
`private ZKProcedureUtil`	`zkController`

Constructor Summary

Constructors
Constructor and Description
`ZKProcedureMemberRpcs(ZooKeeperWatcher watcher, String procType)` Must call `start(String, ProcedureMember)` before this can be used.

Method Summary

Methods
Modifier and Type	Method and Description
`protected void`	`abort(String abortZNode)` Pass along the found abort notification to the listener
`void`	`close()`
`String`	`getMemberName()` Each subprocedure is being executed on a member.
`ZKProcedureUtil`	`getZkController()`
`private void`	`receivedReachedGlobalBarrier(String path)` Pass along the procedure global barrier notification to any listeners
`void`	`sendMemberAborted(Subprocedure sub, ForeignException ee)` This should be called by the member and should write a serialized root cause exception as to the abort znode.
`void`	`sendMemberAcquired(Subprocedure sub)` This attempts to create an acquired state znode for the procedure (snapshot name).
`void`	`sendMemberCompleted(Subprocedure sub, byte[] data)` This acts as the ack for a completed procedure
`void`	`start(String memberName, ProcedureMember listener)` Initialize and start any threads or connections the member needs.
`private void`	`startNewSubprocedure(String path)` Kick off a new sub-procedure on the listener with the data stored in the passed znode.
`private void`	`waitForNewProcedures()`
`private void`	`watchForAbortedProcedures()`

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
```
  - zkController
```
private final ZKProcedureUtil zkController
```
  - member
```
protected ProcedureMember member
```
  - memberName
```
private String memberName
```
- Constructor Detail
  - ZKProcedureMemberRpcs
```
public ZKProcedureMemberRpcs(ZooKeeperWatcher watcher,
                     String procType)
                      throws org.apache.zookeeper.KeeperException
```
    Must call start(String, ProcedureMember) before this can be used.
    
    Parameters:
    watcher - ZooKeeperWatcher to be owned by this. Closed via close().
    procType - name of the znode describing the procedure type
    
    Throws:
    
    org.apache.zookeeper.KeeperException - if we can't reach zookeeper
- Method Detail
  - getZkController
```
public ZKProcedureUtil getZkController()
```
  - getMemberName
```
public String getMemberName()
```
    Description copied from interface: ProcedureMemberRpcs
    
    Each subprocedure is being executed on a member. This is the identifier for the member.
    
    Specified by:
    
    getMemberName in interface ProcedureMemberRpcs
    
    Returns:
    the member name
  - receivedReachedGlobalBarrier
```
private void receivedReachedGlobalBarrier(String path)
```
    Pass along the procedure global barrier notification to any listeners
    
    Parameters:
    path - full znode path that cause the notification
  - watchForAbortedProcedures
```
private void watchForAbortedProcedures()
```
  - waitForNewProcedures
```
private void waitForNewProcedures()
```
  - startNewSubprocedure
```
private void startNewSubprocedure(String path)
```
    Kick off a new sub-procedure on the listener with the data stored in the passed znode.
    Will attempt to create the same procedure multiple times if an procedure znode with the same name is created. It is left up the coordinator to ensure this doesn't occur.
    
    Parameters:
    path - full path to the znode for the procedure to start
  - sendMemberAcquired
```
public void sendMemberAcquired(Subprocedure sub)
                        throws IOException
```
    This attempts to create an acquired state znode for the procedure (snapshot name). It then looks for the reached znode to trigger in-barrier execution. If not present we have a watcher, if present then trigger the in-barrier action.
    
    Specified by:
    
    sendMemberAcquired in interface ProcedureMemberRpcs
    
    Parameters:
    sub - the specified Subprocedure
    
    Throws:
    
    IOException - if we can't reach the coordinator
  - sendMemberCompleted
```
public void sendMemberCompleted(Subprocedure sub,
                       byte[] data)
                         throws IOException
```
    This acts as the ack for a completed procedure
    
    Specified by:
    
    sendMemberCompleted in interface ProcedureMemberRpcs
    
    Parameters:
    sub - the specified Subprocedure
    data - the data the member returns to the coordinator along with the notification
    
    Throws:
    
    IOException - if we can't reach the coordinator
  - sendMemberAborted
```
public void sendMemberAborted(Subprocedure sub,
                     ForeignException ee)
```
    This should be called by the member and should write a serialized root cause exception as to the abort znode.
    
    Specified by:
    
    sendMemberAborted in interface ProcedureMemberRpcs
    
    Parameters:
    sub - the Subprocedure we are aborting
    ee - the reason why the member's subprocedure aborted
  - abort
```
protected void abort(String abortZNode)
```
    Pass along the found abort notification to the listener
    
    Parameters:
    abortZNode - full znode path to the failed procedure information
  - start
```
public void start(String memberName,
         ProcedureMember listener)
```
    Description copied from interface: ProcedureMemberRpcs
    
    Initialize and start any threads or connections the member needs.
    
    Specified by:
    
    start in interface ProcedureMemberRpcs
  - close
```
public void close()
           throws IOException
```
    Specified by:
    
    close in interface Closeable
    
    Specified by:
    
    close in interface AutoCloseable
    
    Throws:
    
    IOException

Class ZKProcedureMemberRpcs

Field Summary

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Field Detail

LOG

zkController

member

memberName

Constructor Detail

ZKProcedureMemberRpcs

Method Detail

getZkController

getMemberName

receivedReachedGlobalBarrier

watchForAbortedProcedures

waitForNewProcedures

startNewSubprocedure

sendMemberAcquired

sendMemberCompleted

sendMemberAborted

abort

start

close