Hbase-HMaster架构

HMaster的整体结构

Hbase-HMaster架构_第1张图片
一个master包含如下部分:

1.对外的接口

   RPC服务

   jetty web服务

   Master MBean

  其中RPC服务包括了若干listener,reader,以及handler线程(IPC Handler和 用于replication的IPC Handler)

2.执行服务

都是一些线程池,当有任务出现时就就会交给这些类来处理

这些线程有

MASTER_SERVER_OPERATIONS

MASTER_META_SERVER_OPERATIONS

MASTER_CLOSE_REGION

MASTER_OPEN_REGION

MASTER_TABLE_OPERATIONS

相关的hanlder有:

OpenRegionHandler

ClosedRegionHandler

ServerShutdownHandler

MetaServerShutdownHandler

DeleteTableHandler

DisableTableHandler

EnableTableHandler

ModifyTableHandler 

CreateTableHandler 

 

Executor Service

Event Event Handler

Threads

(Default)

Master Open Region
RS_ZK_REGION_OPENED
OpenRegionHandler
5
Master Close Region
RS_ZK_REGION_CLOSED
ClosedRegionHandler
5
Master Server Operations
 
RS_ZK_REGION_SPLIT
M_SERVER_SHUTDOWN
SplitRegionHandler
ServerShutdownHandler
3
Master Meta Server Operations
M_META_SERVER_SHUTDOWN
MetaServerShutdownHandler
5
Master Table Operations
 
C_M_DELETE_TABLE C_M_DISABLE_TABLE C_M_ENABLE_TABLE C_M_MODIFY_TABLE C_M_CREATE_TABLE
DeleteTableHandler DisableTableHandler EnableTableHandler ModifyTableHandler CreateTableHandler
1

 

3.和zookeeper相关的线程

  1. 1.ActiveMasterManager  
  2. 会在ZK中创建/hbase/master短暂节点,master将其信息记录到这个节点下  
  3. 如果是备份的master会在这里阻塞,直到这个节点为空  
  4.   
  5. 2.RegionServerTracker  
  6. 用于监控region server,通过监控ZK的/hbase/rs节点,获取region server的状态  
  7. 当region server上线或者下线,ZK都会触发通知事件  
  8.   
  9. 3.DrainingServerTracker  
  10. 没太明白,貌似是处理RS增加和删除事件用的  
  11.   
  12. 4.CatalogTracker  
  13. 用来监控META表和ROOT表  
  14.   
  15. 5.ClusterStatusTracker  
  16. 用于监控ZK的/shutdown节点,监控是否有机器宕机了  
  17.   
  18. 6.AssignmentManager  
  19. 用于管理和分配region的  
  20.   
  21. 7.RootRegionTracker  
  22. 用于管理和监控/root-region-server 节点的  
  23.   
  24. 8.LoadBalancer  
  25. 用于平衡各个regoin server上的region  
  26.   
  27. 9.MetaNodeTracker  
  28. 监控/unassigned 节点,分配那些未在META表中存在的region  
  29.   
  30. 此外在 org.apache.hadoop.hbase.zookeeper.ZooKeeperWatcher类中还负责管理一些ZK节点  
  31. baseZNode           /hbase  
  32. assignmentZNode         /unassigned  
  33. rsZNode             /rs  
  34. drainingZNode           /draining  
  35. masterTableZNode        /table  
  36. masterTableZNode92      /table92    (用于hbase0.92版本)  
  37. splitLogZNode           /splitlog  
  38. backupMasterAddressesZNode  /backup-masters  
  39. clusterStateZNode       /shutdown  
  40. masterAddressZNode      /master  
  41. clusterIdZNode              /hbaseid  

 

ZK监听相关的类图

Hbase-HMaster架构_第2张图片
4.文件接口和其他

MasterFileSystem

用于创建META表和ROOT表,.oldlog目录,hbase.version文件等

 

LogCleaner

用于定期的清理.oldlog目录中的内容

 

HFileCleaner

用于定期清理归档目录下的内容

 

其他包括后台线程如LogCleaner和HFileCleaner等

ServerManager 维护一个在线和下线的RS列表

Balancer 用于执行region均衡的后台线程

 

 

 

 

 

HMaster的相关配置

参数名称 默认值 含义
hbase.master.handler.count 25 工作线程大小
hbase.master.buffer.for.rs.fatals 1M  
mapred.task.id    
hbase.master.wait.for.log.splitting false  
zookeeper.session.timeout 180秒  
hbase.master.backup    
hbase.master.impl    
hbase.master.event.waiting.time 1000  

 

 

 

 

 

HMaster的启动入口类

org.apache.hadoop.hbase.master.HMaster

hbase-site.xml中可以配置参数 hbase.master.impl来自定自己的实现,但必须继承HMaster

之后调用HMasterCommandLine (这个类继承自ServerCommandLine)

HMasterCommandLine使用hadoop提供的ToolRunner去运行

ToolRunner#run(Configuration,Tool,String[])

ToolRunner会调用GenericOptionsParser,解析一些固定的参数,如-conf,-D,-fs,-files 这样的参数

解析好之后,配置configuration对象,然后将启动参数传给Tool接口的实现

所以ToolRunner 就是一个启动参数解析,配置configuration对象的工具类,然后将这些信息交给Tool实现类

 

调用顺序是

1.HMaster#main()

2.HMasterCommandLine#doMain()

3.ToolRunner#run()

4.HMasterCommandLine#run()

5.HMasterCommandLine#startMaster()

6.HMaster#constructMaster()

7.反射调用HMaster的构造函数

Hbase-HMaster架构_第3张图片
 

 

 

 

 

初始化-调用HRgionServer构造函数

1.配置host,NDS相关

2.配置RPC连接,创建RPC连接

3.初始化ZK认证

4.创建ZooKeeperWatcher(和ZK相关的线程),RPC服务,metrics

5.创建HealthCheckChore

6.配置splitlog相关

 

 

 

 

 

启动,HMaster#run (在新线程中启动)

  1. //将当前的master变成active状态(如果是备份master则一直等待)  
  2. //完成初始化  
  3. HMaster#run() {  
  4.     becomeActiveMaster(startupStatus);  
  5.     finishInitialization(startupStatus, false);   
  6. }  
  7.   
  8.   
  9. //如果当前的master不是活跃的则一直等待  
  10. HMaster#becomeActiveMaster() {  
  11.     this.activeMasterManager = new ActiveMasterManager(zooKeeper, this.serverName,this);  
  12.     this.zooKeeper.registerListener(activeMasterManager);  
  13.     while (!amm.isActiveMaster()) {  
  14.         Thread.sleep(c.getInt("zookeeper.session.timeout"180 * 1000));      
  15.     }  
  16.     this.clusterStatusTracker = new ClusterStatusTracker(getZooKeeper(), this);  
  17.     this.clusterStatusTracker.start();  
  18.     return this.activeMasterManager.blockUntilBecomingActiveMaster(startupStatus,this.clusterStatusTracker);  
  19. }  
  20.   
  21. //初始化master组件,文件系统,ServerManager  
  22. //AssignmentManager,RegionServerTracker,CatalogTracker等  
  23. //设置Zookeeper的集群状态  
  24. //等待RegionServer的检查完毕  
  25. //如果.log目录下有文件,则执行split log任务  
  26. //分配ROOT和META的region  
  27. //处理可以运行的RegionServer和宕机的RegionServer  
  28. HMaster#finishInitialization() {  
  29.     //检查ROOT和META表是否存在,不存在则创建,还会创建tmp目录,oldlog目录  
  30.     fileSystemManager = new MasterFileSystem();  
  31.     tableDescriptors = new FSTableDescriptors(fileSystemManager.getFileSystem(),fileSystemManager.getRootDir());  
  32.       
  33.     //创建CatalogTracker,LoadBalancer,AssignmentManager  
  34.     //RegionServerTracker,DrainingServerTracker  
  35.     //ClusterStatusTracker,SnapshotManager  
  36.     initializeZKBasedSystemTrackers();  
  37.       
  38.     //开启service线程,如openregion线程,closeregion线程,serveroptions线程等  
  39.     //再开启jetty服务和RPC服务  
  40.     startServiceThreads();  
  41.       
  42.     //将所有的RegionServer加入到ServerManager中,ServerManager负责管理  
  43.     //所有在线宕机的server,并负责启动和关闭  
  44.     for (ServerName sn: regionServerTracker.getOnlineServers()) {  
  45.         ServerManager.recordNewServer(sn, HServerLoad.EMPTY_HSERVERLOAD);  
  46.     }  
  47.       
  48.     //如果有log日志则进行预处理然后挂到ZK上,再由所有RS处理  
  49.     if (waitingOnLogSplitting) {  
  50.         fileSystemManager.splitAllLogs(servers);      
  51.     }  
  52.       
  53.     //如果ROOT表和META为分配则先分配  
  54.     assignRoot();  
  55.     assignMeta();  
  56.     enableServerShutdownHandler();  
  57.       
  58.     //处理所有宕机的server  
  59.     for (ServerName curServer : failedServers) {  
  60.         serverManager.expireServer(curServer);  
  61.     }     
  62.     DefaultLoadBalancer.setMasterServices();  
  63.     startCatalogJanitorChore();  
  64.     registerMBean();  
  65. }  
  66.   
  67.   
  68.   
  69. HMaster#assignRoot() {  
  70.     //先看一下分区正在转换状态当中,  
  71.     //如果处于转换状态当中则先处理相关的状态,并等待体处理结束后再往下进行  
  72.     processRegionInTransitionAndBlockUntilAssigned();  
  73.     verifyRootRegionLocation();  
  74.     getRootLocation();  
  75.     expireIfOnline();  
  76.     //先删掉"/hbase/root-region-server",不管它存不存在  
  77.     //KeeperException.NoNodeException被忽略了    
  78.     //写入EventType.M_ZK_REGION_OFFLINE、当前时间戳、跟分区名(-ROOT-,,0)  
  79.     //master的版本化ServerName    
  80.     //到/hbase/unassigned/70236052, payload为null,所以不写入   
  81. }  

HMaster#run的时序图如下

Hbase-HMaster架构_第4张图片
 

 

 

 

 

HMaster包含的一些变量

InfoServer

ZooKeeperWatcher

ActiveMasterManager

RegionServerTracker

DrainingServerTracker

RPCServer

MasterMetrics

MasterFileSystem

ServerManager

AssignmentManager

CatalogTracker

ClusterStatusTracker

CatalogJanitor

LogCleaner

HFileCleaner

TableDescriptors

SnapshotManager

HealthCheckChore

 

 

 

 

 

HMaster的线程

RPC相关的的listener线程,reader线程,handler线程

Daemon Thread [IPC Server listener on 60000] (Suspended)

Daemon Thread [IPC Reader 3 on port 60000] (Suspended)

Daemon Thread [IPC Server handler 0 on 60000] (Suspended)

Daemon Thread [REPL IPC Server handler 2 on 60000] (Running)

Daemon Thread [IPC Server Responder] (Running)

 

ZK相关线程

Daemon Thread [main-EventThread] (Suspended)

Daemon Thread [main-SendThread(myhost:2181)] (Suspended) 

 

后台线程

Daemon Thread [myhost,60000,1427458363875-BalancerChore] (Running)

Daemon Thread [myhost,60000,1427458363875-CatalogJanitor] (Running)

Daemon Thread [master-myhost,60000,1427458363875.archivedHFileCleaner] (Running)

Daemon Thread [master-myhost,60000,1427458363875.oldLogCleaner] (Running)

Daemon Thread [myhost,60000,1427458363875.splitLogManagerTimeoutMonitor] (Running)

Daemon Thread [myhost,60000,1427458363875.timerUpdater] (Running)

 

监控线程

Daemon Thread [Timer thread for monitoring hbase] (Running)

Daemon Thread [Timer thread for monitoring jvm] (Running)

Daemon Thread [Timer thread for monitoring rpc] (Running)

Daemon Thread [myhost,60000,1427458363875.timeoutMonitor] (Running)

 

 

jetty相关线程

Thread [1008881877@qtp-314160763-0] (Running)

 

 

 

 

 

timeoutMonitor(用于分配region)线程执行原理(AssignmentManager$TimeoutMonitor)

Hbase-HMaster架构_第5张图片
执行逻辑如下:

  1. //在独立的线程中运行  
  2. //从Chore#run()函数调到这里的  
  3. AssignmentManager$TimeoutMonitor#chore() {  
  4.     for (RegionState regionState : regionsInTransition.values()) {  
  5.         if (regionState.getStamp() + timeout <= now) {  
  6.             //decide on action upon timeout  
  7.             actOnTimeOut(regionState);  
  8.         } else if (this.allRegionServersOffline && !allRSsOffline) {  
  9.             RegionPlan existingPlan = regionPlans.get(regionState.getRegion().getEncodedName());  
  10.             if (existingPlan == null || !this.serverManager.isServerOnline(existingPlan.getDestination())) {  
  11.                 actOnTimeOut(regionState);  
  12.             }  
  13.         }  
  14.     }  
  15. }  
  16.   
  17. //判断当前region的状态,如果下线了则分配  
  18. AssignmentManager$TimeoutMonitor#actOnTimeOut() {  
  19.     HRegionInfo regionInfo = regionState.getRegion();  
  20.     switch (regionState.getState()) {  
  21.     case CLOSED:  
  22.         regionState.updateTimestampToNow();  
  23.         break;  
  24.     case OFFLINE:  
  25.         invokeAssign(regionInfo);  
  26.         break;            
  27.     case PENDING_OPEN:  
  28.         invokeAssign(regionInfo);  
  29.         break;  
  30.     case OPENING:  
  31.         processOpeningState(regionInfo);  
  32.         break;                            
  33.     case OPEN:  
  34.         regionState.updateTimestampToNow();  
  35.         break;  
  36.     case PENDING_CLOSE:  
  37.         invokeUnassign(regionInfo);  
  38.         break;  
  39.     case CLOSING:  
  40.         invokeUnassign(regionInfo);  
  41.         break;        
  42. }  
  43.   
  44. //通过AssignCallable#call()调用  
  45. //分配region,先修改ZK的znode信息  
  46. //然后调用sendRegionOpen(),这里会触发HRegionServer#openRegion()函数  
  47. //最后创建OpenRegionHandler放到线程池中执行,  
  48. //再调用HRegion#openRegion()函数  
  49. AssignmentManager#assign() {  
  50.     for (int i = 0; i < this.maximumAssignmentAttempts; i++) {  
  51.         String tableName = region.getTableNameAsString();  
  52.         if (!zkTable.isEnablingTable(tableName) && !zkTable.isEnabledTable(tableName)) {  
  53.             setEnabledTable(region);                  
  54.         }     
  55.         RegionOpeningState regionOpenState = ServerManager.sendRegionOpen();      
  56.         if (regionOpenState == RegionOpeningState.OPENED) {  
  57.             return;   
  58.         } else if (regionOpenState == RegionOpeningState.ALREADY_OPENED) {  
  59.             ZKAssign.deleteOfflineNode(master.getZooKeeper(), encodedRegionName);     
  60.         }  
  61.     }  
  62. }  
  63.   
  64. //处理未分配的region,将其关闭  
  65. AssignmentManager#unassign() {  
  66.     state = regionsInTransition.get(encodedName);  
  67.     if (state == null) {  
  68.         ZKAssign.createNodeClosing(master.getZooKeeper(), region, master.getServerName());    
  69.     } else if (force && (state.isPendingClose() || state.isClosing())) {  
  70.         state.update(state.getState());   
  71.     } else {  
  72.         return;   
  73.     }  
  74.     ServerName server = regions.get(region);  
  75.     if (server == null) {  
  76.         deleteClosingOrClosedNode(region);    
  77.     }  
  78.     ServerManager.sendRegionClose();  
  79. }  

 

 

 

 

 

CatalogJanitor线程(CatalogJanitor)

这个线程用于扫描split后残留的部分,比如split之后父region的META信息可以删除了

同样split之后,info:splitA和info:splitB这两个META表中的信息也可以删除了

主要逻辑如下:

  1. //在独立的线程中运行  
  2. //从Chore#run()函数调到这里的  
  3. CatalogJanitor#scan() {  
  4.     Pair> pair = getSplitParents();  
  5.     Map splitParents = pair.getSecond();  
  6.     int cleaned = 0;  
  7.     for (Map.Entry e : splitParents.entrySet()) {  
  8.         if (!parentNotCleaned.contains(e.getKey().getEncodedName())) {  
  9.             cleanParent(e.getKey(), e.getValue());  
  10.             cleaned++;                
  11.         } else {  
  12.             //info:splitA 和 info:splitB 列  
  13.             parentNotCleaned.add(getDaughterRegionInfo("splitA");  
  14.             parentNotCleaned.add(getDaughterRegionInfo("splitB");     
  15.         }  
  16.     }  
  17. }  
  18.   
  19. //如果分割之后的splitA和splitB两个新region不再引用  
  20. //父region,则将父region删除  
  21. //最后创建Delete对象删除父对象,再将其从META表中删除  
  22. CatalogJanitor#cleanParent() {  
  23.     HRegionInfo a_region = getDaughterRegionInfo(rowContent, "splitA");  
  24.     HRegionInfo b_region = getDaughterRegionInfo(rowContent, "splitB");  
  25.     Pair a = checkDaughterInFs(parent, a_region, "splitA");  
  26.     Pair b = checkDaughterInFs(parent, b_region, "splitB");  
  27.     removeDaughtersFromParent(parent);  
  28.     FileSystem fs = this.services.getMasterFileSystem().getFileSystem();  
  29.     HFileArchiver.archiveRegion(this.services.getConfiguration(), fs, parent);  
  30.     Delete delete = new Delete(regionInfo.getRegionName());  
  31.     deleteFromMetaTable(catalogTracker, delete);  
  32. }  
  33.   
  34. //检查splitA和splitB两个新region是否还引用父region  
  35. CatalogJanitor#checkDaughterInFs() {  
  36.     FileSystem fs = this.services.getMasterFileSystem().getFileSystem();  
  37.     Path rootdir = this.services.getMasterFileSystem().getRootDir();  
  38.     Path tabledir = new Path(rootdir, split.getTableNameAsString());  
  39.     Path regiondir = new Path(tabledir, split.getEncodedName());  
  40.     exists = fs.exists(regiondir);    
  41.     HTableDescriptor parentDescriptor = getTableDescriptor(parent.getTableName());  
  42.     for (HColumnDescriptor family: parentDescriptor.getFamilies()) {  
  43.         Path p = Store.getStoreHomedir(tabledir, split.getEncodedName(),family.getName());  
  44.         if (!fs.exists(p)) {  
  45.             continue;     
  46.         }  
  47.         // Look for reference files.  Call listStatus with anonymous instance of PathFilter.  
  48.         FileStatus [] ps = FSUtils.listStatus(fs, p,  
  49.         new PathFilter () {  
  50.             public boolean accept(Path path) {  
  51.                 return StoreFile.isReference(path);  
  52.             }  
  53.         });       
  54.     }  
  55. }  
  56.   
  57. //创建Delete对象,将META表中的splitA和splitB  
  58. //这些在split时候创建的已经无用的列删除  
  59. CatalogJanitor#removeDaughtersFromParent() [  
  60.     Delete delete = new Delete(parent.getRegionName());  
  61.     delete.deleteColumns("info","splitA");  
  62.     delete.deleteColumns("info","splitB");  
  63.     deleteFromMetaTable(catalogTracker, delete);  
  64. }  

 

 

 

 

 

BalancerChore线程(HMaster#balance)

这个类负责执行balance过程,具体逻辑如下:

  1. //在单独线程中执行,通过HMaster$2#run()调用到这里的  
  2. //收集所有的region然后执行balance()  
  3. //具体细节没看明白  
  4. HMaster#balance() {  
  5.     Map>> assignmentsByTable =  
  6.         this.assignmentManager.getAssignmentsByTable();   
  7.     List plans = new ArrayList();  
  8.     for (Map> assignments : assignmentsByTable.values()) {  
  9.         List partialPlans = this.balancer.balanceCluster(assignments);  
  10.         if (partialPlans != null) {  
  11.             plans.addAll(partialPlans);  
  12.         }  
  13.     }  
  14.     for (RegionPlan plan: plans) {  
  15.         AssignmentManager.balance(plan);  
  16.     }          
  17. }  
  18.   
  19. //执行balance过程,将待执行的region放到map中  
  20. //最后执行unassign()函数没看懂  
  21. AssignmentManager#balance() {  
  22.     synchronized (this.regionPlans) {  
  23.         this.regionPlans.put(plan.getRegionName(), plan);  
  24.     }  
  25.     unassign(plan.getRegionInfo());   
  26. }  

 

 

 

 

 

archivedHFileCleaner线程(HFileCleaner#chore)

这个类用于删除archive目录下的归档文件,具体逻辑如下:

  1. //这里是调用父类CleanerChore#chore()函数  
  2. //用来清理.archive目录下的归档文件  
  3. HFileCleaner#chore() {  
  4.     FileStatus[] files = FSUtils.listStatus(this.fs, this.oldFileDir, null);  
  5.     for (FileStatus file : files) {  
  6.         if (file.isDir()) {  
  7.             checkAndDeleteDirectory(file.getPath());  
  8.         } else {  
  9.             checkAndDelete(file.getPath());  
  10.         }  
  11.     }  
  12. }  
  13.   
  14. //检查并删除目录  
  15. CleanerChore#checkAndDeleteDirectory() {  
  16.     FileStatus[] children = FSUtils.listStatus(fs, toCheck, null);  
  17.     HBaseFileSystem.deleteFileFromFileSystem(fs, toCheck);  
  18. }  
  19.   
  20. //检查并删除文件  
  21. CleanerChore#checkAndDelete() {  
  22.     HBaseFileSystem.deleteDirFromFileSystem(fs, filePath);  
  23. }  

 

 

 

 

 

oldLogCleaner线程(LogCleaner)

这个类用于oldlog目录下文件

具体执行逻辑和archivedHFileCleaner线程一样

都是调用父类CleanerChore#chore()函数去执行的

 

 

 

 

 

timerUpdater线程(AssignmentManager$TimerUpdater#chore)

这个类用于更新region的时间戳,这些region都是出于事务中的region

主要逻辑如下:

  1. //在单独线程中执行,通过Chore#run()调用到这里的  
  2. AssignmentManager$TimerUpdater#chore() {  
  3.     while (!serversInUpdatingTimer.isEmpty() && !stopper.isStopped()) {  
  4.         if (serverToUpdateTimer == null) {  
  5.             serverToUpdateTimer = serversInUpdatingTimer.first();  
  6.         } else {  
  7.             serverToUpdateTimer = serversInUpdatingTimer.higher(serverToUpdateTimer);  
  8.         }  
  9.         updateTimers(serverToUpdateTimer);  
  10.     }                 
  11. }  
  12.   
  13. //更新处于事务中的region的时间戳  
  14. //这里会迭代所有机器,然后更新每个机器上的region  
  15. AssignmentManager#updateTimers() {  
  16.     for (Map.Entry e: copy.entrySet()) {  
  17.         rs = this.regionsInTransition.get(e.getKey());  
  18.         rs.updateTimestampToNow();  
  19.     }  
  20. }  

 

 

 

 

 

splitLogManagerTimeoutMonitor线程(SplitLogManager$TimeoutMonitor#chore)

这个类用于周期性的检查是否有执行超时的任务(获取ZK的split节点的任务,然后执行切分日志工作),如果有则

需要重新提交这个任务,如果出现region下线,server宕机等情况也需要重新提交,最后删除失败的任务

具体逻辑如下:

  1. //在单独线程中执行,通过Chore#run()调用到这里的  
  2. //周期性的检查是否有处理splitlog超时的region,或者  
  3. //出现某些region下线了,这时候需要重新提交splitlog  
  4. //最后将失败的任务删除掉  
  5. SplitLogManager$TimeoutMonitor#chore() {  
  6.     for (Map.Entry e : tasks.entrySet()) {  
  7.         if (localDeadWorkers != null && localDeadWorkers.contains(cur_worker)) {  
  8.             if (resubmit(path, task, FORCE)) {  
  9.                 resubmitted++;  
  10.             } else {  
  11.                 //将死掉的工作regoin server放入列表中  
  12.                 handleDeadWorker(cur_worker);  
  13.             }     
  14.         } else if (resubmit(path, task, CHECK)) {  
  15.           resubmitted++;  
  16.         }     
  17.     }  
  18.     for (Map.Entry e : tasks.entrySet()) {  
  19.         String path = e.getKey();  
  20.         Task task = e.getValue();  
  21.         if (task.isUnassigned() && (task.status != FAILURE)) {  
  22.             // We just touch the znode to make sure its still there  
  23.             tryGetDataSetWatch(path);  
  24.         }             
  25.     }     
  26.     createRescanNode(Long.MAX_VALUE);  
  27.       
  28.     // Retry previously failed deletes  
  29.     if (failedDeletions.size() > 0) {  
  30.         for (String tmpPath : tmpPaths) {  
  31.             // deleteNode is an async call  
  32.             deleteNode(tmpPath, zkretries);  
  33.         }         
  34.     }  
  35. }  
  36.   
  37. //异步删除节点  
  38. SplitLogManager#deleteNode() {  
  39.     ZooKeeper.delete(path, -1new DeleteAsyncCallback(),retries);    
  40. }  

 

 

 

 

 

参考

HMaster架构

master和regionserver启动过程

 

你可能感兴趣的:(分布式,HBase)