HBase启动

# HBase中组件及启动流程记录

 

## 1.服务组件

- Client

    -包含访问HBase的接口，并维护cache来加快对HBase的访问，比如region的位置信息

   

- Master

    - 为Region server分配region

    - 负责Region server的负载均衡

    - 发现失效的Region server并重新分配其上的region

    - 管理用户对table的增删改查操作 (这个和client是怎么关联的)

   

- Region Server

    - Regionserver维护region，处理对这些region的IO请求

    - Regionserver负责切分在运行过程中变得过大的region

    - HStore

        - HBase存储的核心。由MemStore和StoreFile组成

    - HLog

        -防止HRegionServer意外退出，MemStore中的内存数据就会丢失

   

- ZooKeeper

    -通过选举，保证任何时候，集群中只有一个master，Master与RegionServers 启动时会向ZooKeeper注册

    - 存贮所有Region的寻址入口

    - 实时监控Region server的上线和下线信息。并实时通知给Master

    - 存储HBase的schema和table元数据

    - 默认情况下，HBase 管理ZooKeeper 实例，比如，启动或者停止ZooKeeper

    - Zookeeper的引入使得Master不再是单点故障

    - Zookeeper Quorum存储-ROOT-表地址、HMaster地址

 

## 2.调用图

- HBase服务架构图

> 

 

 

-HRegionServer下结构解析图

> 

 

 

- HBase服务间调度流程图

> 

 

 

## 3.Client组件

 

 

## 4.Master组件

### HMaster的main方法调用

1.HMaster的入口是main方法，main方法需要传递一个参数，start或者stop。

```java

public classHMasterStarter {

    public static void main(String[] args)throws Exception {

            File f = TestBase.getTestDir();

            //删除临时测试目录

            deleteRecursive(f.listFiles());

            //zookeeper类启动

            new ZookeeperThread().start();

            Thread.sleep(1000);

            //运行HMaster服务,这里是开始服务

            HMaster.main(new String[] {"start" }); 

    }

   

    public static void deleteRecursive(File[]files) {

        if (files == null)

            return;

        for (File f : files) {

            if (f.isDirectory()) {

                deleteRecursive(f.listFiles());

            }

            f.delete();

        }

    }

   

    public static class ZookeeperThread extendsThread {

        public void run() {

            MiniZooKeeperClusterzooKeeperCluster = new MiniZooKeeperCluster();

 

            File zkDataPath = newFile(TestBase.sharedConf.get(HConstants.ZOOKEEPER_DATA_DIR));

            int zkClientPort =TestBase.sharedConf.getInt(HConstants.ZOOKEEPER_CLIENT_PORT, 2181);

           zooKeeperCluster.setDefaultClientPort(zkClientPort);

            try {

               zooKeeperCluster.startup(zkDataPath);

            } catch (Exception e) {

                e.printStackTrace();

            }

        }

    }

}

```

   

2.main方法内首先打印hbase版本信息，然后在调用HMasterCommandLine的doMain方法。

```java

packageorg.apache.hadoop.hbase.master;

 

@InterfaceAudience.LimitedPrivate(HBaseInterfaceAudience.TOOLS)

@SuppressWarnings("deprecation")

public class HMasterextends HRegionServer implements MasterServices, Server {

    /**

      * @seeorg.apache.hadoop.hbase.master.HMasterCommandLine

      */

    public static void main(String [] args) {

        VersionInfo.logVersion();

        newHMasterCommandLine(HMaster.class).doMain(args);

    }

   

}

```

 

3.doMain方法内会调用ToolRunner的run方法，ToolRunner为Hadoop的类。HMasterCommandLine继承自ServerCommandLine类，ServerCommandLine类实现了Tool接口。所以最后会调用HMasterCommandLine的run方法。

```java

packageorg.apache.hadoop.hbase.util;

 

/**

 * Base class for command lines that start upvarious HBase daemons.

 */

@InterfaceAudience.Private

public abstractclass ServerCommandLine extends Configured implements Tool {

    public void doMain(String args[]) {

        try {

           //this将实例HMasterCommandLine实现的run方法传递进去，达到调用的效果

            int ret =ToolRunner.run(HBaseConfiguration.create(), this, args);

            if (ret != 0) {

                System.exit(ret);

            }

        } catch (Exception e) {

            LOG.error("Failed torun", e);

            System.exit(-1);

        }

    }

}

```

```java

packageorg.apache.hadoop.util;

 

public classToolRunner {

    public static int run(Configuration conf,Tool tool, String[] args) throws Exception {

        if(conf == null) {

            conf = new Configuration();

        }

 

        GenericOptionsParser parser = newGenericOptionsParser(conf, args);

        tool.setConf(conf);

        String[] toolArgs =parser.getRemainingArgs();

        //运行外部传入的实现方法

        return tool.run(toolArgs);

    }

}

```

 

4.解析参数，根据参数值判断是执行startMaster方法还是stopMaster方法。

```java

packageorg.apache.hadoop.hbase.master;

 

@InterfaceAudience.Private

public classHMasterCommandLine extends ServerCommandLine {

    public int run(String args[]) throwsException {

        Options opt = new Options();

       opt.addOption("localRegionServers", true,

          "RegionServers to start inmaster process when running standalone");

        opt.addOption("masters",true, "Masters to start in this process");

       opt.addOption("minRegionServers", true, "MinimumRegionServers needed to host user tables");

        opt.addOption("backup",false, "Do not try to become HMaster until the primary fails");

   

        CommandLine cmd;

        try {

          cmd = new GnuParser().parse(opt,args);

        } catch (ParseException e) {

          LOG.error("Could not parse:", e);

          usage(null);

          return 1;

        }

   

   

        if(cmd.hasOption("minRegionServers")) {

          String val =cmd.getOptionValue("minRegionServers");

         getConf().setInt("hbase.regions.server.count.min",Integer.parseInt(val));

          LOG.debug("minRegionServers setto " + val);

        }

   

        // minRegionServers used to beminServers.  Support it too.

        if(cmd.hasOption("minServers")) {

          String val =cmd.getOptionValue("minServers");

         getConf().setInt("hbase.regions.server.count.min",Integer.parseInt(val));

          LOG.debug("minServers set to" + val);

        }

   

        // check if we are the backup master -override the conf if so

        if (cmd.hasOption("backup")){

         getConf().setBoolean(HConstants.MASTER_TYPE_BACKUP, true);

        }

   

        // How many regionservers to startup inthis process (we run regionservers in same process as

        // master when we are inlocal/standalone mode. Useful testing)

        if(cmd.hasOption("localRegionServers")) {

          String val =cmd.getOptionValue("localRegionServers");

         getConf().setInt("hbase.regionservers",Integer.parseInt(val));

          LOG.debug("localRegionServersset to " + val);

        }

        // How many masters to startup insidethis process; useful testing

        if (cmd.hasOption("masters")){

          String val =cmd.getOptionValue("masters");

         getConf().setInt("hbase.masters", Integer.parseInt(val));

          LOG.debug("masters set to "+ val);

        }

   

       @SuppressWarnings("unchecked")

        List<String> remainingArgs =cmd.getArgList();

        if (remainingArgs.size() != 1) {

          usage(null);

          return 1;

        }

   

        String command = remainingArgs.get(0);

   

        if ("start".equals(command)){

          return startMaster();

        } else if("stop".equals(command)) {

          return stopMaster();

        } else if("clear".equals(command)) {

          return (ZNodeClearer.clear(getConf())? 0 : 1);

        } else {

          usage("Invalid command: " +command);

          return 1;

        }

      }

}

```

 

5.假如是startMaster，分两种情况：本地模式和分布式模式。如果是分布式模式，通过反射调用HMaster的构造方法，并调用其start和join方法。如果是本地模式，将会运行一个LocalHBaseCluster，包括：LocalHMaster、HRegionServer、MiniZooKeeperCluster

```java

packageorg.apache.hadoop.hbase.master;

 

@InterfaceAudience.Private

public classHMasterCommandLine extends ServerCommandLine {

    private int startMaster() {

        Configuration conf = getConf();

        try {

            // If 'local', defer toLocalHBaseCluster instance.  Startsmaster

            // and regionserver both in the oneJVM.

            //判断是本地模式还是分布式模式

            if(LocalHBaseCluster.isLocal(conf)) {

               DefaultMetricsSystem.setMiniClusterMode(true);

                final MiniZooKeeperClusterzooKeeperCluster = new MiniZooKeeperCluster(conf);

                File zkDataPath = newFile(conf.get(HConstants.ZOOKEEPER_DATA_DIR));

 

                // find out the default clientport

                int zkClientPort = 0;

 

                // If the zookeeper client portis specified in server quorum, use it.

                String zkserver =conf.get(HConstants.ZOOKEEPER_QUORUM);

                if (zkserver != null) {

                    String[] zkservers =zkserver.split(",");

 

                    if (zkservers.length >1) {

                        // In local modedeployment, we have the master + a region server and zookeeper server

                        // started in the sameprocess. Therefore, we only support one zookeeper server.

                        String errorMsg ="Could not start ZK with " + zkservers.length +

                                " ZKservers in local mode deployment. Aborting as clients (e.g. shell) will not"

                                + "be ableto find this ZK quorum.";

                       System.err.println(errorMsg);

                        throw newIOException(errorMsg);

                    }

 

                    String[] parts =zkservers[0].split(":");

 

                    if (parts.length == 2) {

                        // the second part isthe client port

                        zkClientPort =Integer.parseInt(parts[1]);

                    }

                }

                // If the client port could notbe find in server quorum conf, try another conf

                if (zkClientPort == 0) {

                    zkClientPort =conf.getInt(HConstants.ZOOKEEPER_CLIENT_PORT, 0);

                    // The client port has tobe set by now; if not, throw exception.

                    if (zkClientPort == 0) {

                        throw newIOException("No config value for " +HConstants.ZOOKEEPER_CLIENT_PORT);

                    }

                }

               zooKeeperCluster.setDefaultClientPort(zkClientPort);

                // set the ZK tick time ifspecified

                int zkTickTime =conf.getInt(HConstants.ZOOKEEPER_TICK_TIME, 0);

                if (zkTickTime > 0) {

                   zooKeeperCluster.setTickTime(zkTickTime);

                }

 

                // login the zookeeper serverprincipal (if using security)

                ZKUtil.loginServer(conf,HConstants.ZK_SERVER_KEYTAB_FILE,

                       HConstants.ZK_SERVER_KERBEROS_PRINCIPAL, null);

                intlocalZKClusterSessionTimeout =

                       conf.getInt(HConstants.ZK_SESSION_TIMEOUT +".localHBaseCluster", 10 * 1000);

               conf.setInt(HConstants.ZK_SESSION_TIMEOUT,localZKClusterSessionTimeout);

                LOG.info("Starting azookeeper cluster");

                int clientPort =zooKeeperCluster.startup(zkDataPath);

                if (clientPort != zkClientPort){

                    String errorMsg ="Could not start ZK at requested port of " +

                            zkClientPort +".  ZK was started at port: " +clientPort +

                            ".  Aborting as clients (e.g. shell) will not beable to find " +

                            "this ZKquorum.";

                   System.err.println(errorMsg);

                    throw newIOException(errorMsg);

                }

               conf.set(HConstants.ZOOKEEPER_CLIENT_PORT,Integer.toString(clientPort));

 

                // Need to have the zk clustershutdown when master is shutdown.

                // Run a subclass that does thezk cluster shutdown on its way out.

                int mastersCount =conf.getInt("hbase.masters", 1);

                int regionServersCount =conf.getInt("hbase.regionservers", 1);

                LOG.info("Starting upinstance of localHBaseCluster; master=" + mastersCount +

                        ",regionserversCount=" + regionServersCount);

               //在这里启动一个本地集群，看到里面带有一个LocalHMaster和一个HRegionServer

                LocalHBaseCluster cluster = newLocalHBaseCluster(conf, mastersCount, regionServersCount,

                        LocalHMaster.class,HRegionServer.class);

                //在里面再加入一个MiniZooKeeperCluster

                ((LocalHMaster)cluster.getMaster(0)).setZKCluster(zooKeeperCluster);

                cluster.startup();

                waitOnMasterThreads(cluster);

            } else {

                logProcessInfo(getConf());

                CoordinatedStateManager csm =

                       CoordinatedStateManagerFactory.getCoordinatedStateManager(conf);

                //构造HMaster

                HMaster master =HMaster.constructMaster(masterClass, conf, csm);

                if (master.isStopped()) {

                    LOG.info("Won't bringthe Master up as a shutdown is requested");

                    return 1;

                }

                master.start();

                master.join();

                if (master.isAborted())

                    throw newRuntimeException("HMaster Aborted");

            }

        } catch (Throwable t) {

            LOG.error("Masterexiting", t);

            return 1;

        }

        return 0;

    }

}

```

 

6.如果是stopMaster,将会尝试调用HBaseAdmin的shutdown方法,最后使用close方法。

```java

packageorg.apache.hadoop.hbase.master;

 

public classHMasterCommandLine extends ServerCommandLine {

    private int stopMaster() {

        Admin adm = null;

        try {

            Configuration conf = getConf();

            // Don't try more than once

           conf.setInt(HConstants.HBASE_CLIENT_RETRIES_NUMBER, 1);

            adm = new HBaseAdmin(getConf());

            adm.shutdown();

        } catch (MasterNotRunningException e) {

            LOG.error("Master notrunning");

            return 1;

        } catch (ZooKeeperConnectionExceptione) {

            LOG.error("ZooKeeper notavailable");

            return 1;

        } catch (IOException e) {

            LOG.error("Got IOException:" + e.getMessage(), e);

            return 1;

        } catch (Throwable t) {

            LOG.error("Failed to stopmaster", t);

            return 1;

        } finally {

            if (adm != null) {

                try {

                    adm.close();

                } catch (Throwable t) {

                    LOG.error("Failed toclose Admin", t);

                    return 1;

                }

            }

        }

        return 0;

    }

}

```

 

 

7.HMaster继承自HasThread类，而HasThread类实现了Runnable接口，故HMaster也是一个线程。

```java

public class HMasterextends HRegionServer implements MasterServices, Server{};

public classHRegionServer extends HasThread implements RegionServerServices,LastSequenceId, ConfigurationObserver {};

public abstractclass HasThread implements Runnable {};

 

```

 

8. HMaster类继承关系

> 

 

 

### HMaster的构造方法调用

1.创建Configuration并设置和获取一些参数，默认参数在HConstants中。（发现新版HBase1.3.0代码已和老版0.9.6有较大差异，配置的运行和实现在startActiveMasterManager()方法下；而且HMaster继承HRegionServer，大部分操作实际都在HRegionServer中进行）

    - 在master上禁止block cache

    - 设置服务端重试次数

    - 获取主机名称和master绑定的ip和端口号，端口号默认为60000

    - 设置regionserver的coprocessorhandler线程数为0

    - 创建rpcServer（见下文分析）

    -初始化serverName，其值为：192.168.1.129,60000,1404117936154

    - zk授权登录和hbase授权

    - 设置当前线程名称：master + "-" +this.serverName.toString()

    -判断是否开启复制：Replication.decorateMasterConfiguration(this.conf);

    -设置mapred.task.id，如果其为空，则其值为："hb_m_" + this.serverName.toString()

    -创建ZooKeeperWatcher监听器（见下文分析），并在zookeeper上创建一些节点

    - 启动rpcServer中的线程

    - 创建一个MasterMetrics

    - 判断是否进行健康检测：HealthCheckChore

    -另外还初始化两个参数：shouldSplitMetaSeparately、waitingOnLogSplitting

   

    ```java

    package org.apache.hadoop.hbase.master;

   

    public class HMaster extends HRegionServerimplements MasterServices, Server {

        /**

         * Utility for constructing an instanceof the passed HMaster class.

         * @param masterClass

         * @param conf

         * @return HMaster instance.

         */

        public static HMasterconstructMaster(Class<? extends HMaster> masterClass,

                                             final Configuration conf, final CoordinatedStateManager cp) {

            try {

                Constructor<? extendsHMaster> c =

                       masterClass.getConstructor(Configuration.class,CoordinatedStateManager.class);

                //这里的conf就是配置文件

                return c.newInstance(conf, cp);

            } catch (Exception e) {

                Throwable error = e;

                if (e instanceofInvocationTargetException &&

                       ((InvocationTargetException) e).getTargetException() != null) {

                    error =((InvocationTargetException) e).getTargetException();

                }

                throw newRuntimeException("Failed construction of Master: " +masterClass.toString() + ". "

                        , error);

            }

        }

    }

    ```

 

    以下为涉及参数(网上复制,没有验证准确性，和代码核对后，发现后很多都已经改动或者移除)

    >

        hfile.block.cache.size

        hbase.master.dns.interface

        hbase.master.dns.nameserver

        hbase.master.port

        hbase.master.ipc.address

        hbase.master.handler.count

        hbase.regionserver.handler.count

        hbase.master.buffer.for.rs.fatals

        hbase.zookeeper.client.keytab.file

       hbase.zookeeper.client.kerberos.principal

        hbase.master.keytab.file

        hbase.master.kerberos.principal

        hbase.master.logcleaner.plugins

        mapred.task.id

        hbase.node.health.script.frequency

       hbase.regionserver.separate.hlog.for.meta

        hbase.master.wait.for.log.splitting

 

2.创建rpcServer并启动其中的线程

 

    2.1通过反射创建RpcEngine的实现类，实现类可以在配置文件中配置（hbase.rpc.engine现在已变为hbase.security.authentication），默认实现为WritableRpcEngine。调用getServer方法，其实也就是new一个HBaseServer类。

   

    2.2 运行构造方法

    >

       启动一个Listener线程，功能是监听client的请求，将请求放入nio请求队列，逻辑如下：

          –>创建n个selector，和一个n个线程的readpool，n由ipc.server.read.threadpool.size决定，默认为10

          –>读取每个请求的头和内容，将内容放入priorityQueue中

       

       启动一个Responder线程，功能是将响应队列里的数据写给各个client的connection通道，逻辑如下：

          –>创建nio selector

          –>默认超时时间为15 mins

          –>依次将responseQueue中的内容写回各通道，并关闭连接，buffer=8k

          –>如果该请求的返回没有写完，则放回队列头，推迟再发送

          –>对于超时未完成的响应，丢弃并关闭相应连接

       

       启动N（n默认为10）个Handler线程，功能是处理请求队列，并将结果写到响应队列

          –>读取priorityQueue中的call，调用对应的call方法获得value，写回out并调用doRespond方法，处理该请求，并唤醒writable selector

          –>启动M(m默认为0)个Handler线程以处理priority

         

        启动一个Scheduler线程，是一个调度器（自己添加的，网上都没说，在代码中发现）

 

    2.3 创建ZooKeeperWatcher

    构造函数中生成如下持久节点：

    >

        /hbase

        /hbase/root-region-server

        /hbase/rs

        /table/draining

        /hbase/master

        /hbase/backup-masters

        /hbase/shutdown

        /hbase/unassigned

        /hbase/table94

        /hbase/table

        /hbase/hbaseid

        /hbase/splitlog

 

 

### run方法调用

-我这里已经修改不下去了，1.3.0版本的HMaster根本就没有run方法，下面的步骤基本还在，但是都转移到HRegionServer的run方法下、构造方法、构造方法的startActiveMasterManager()里去了。

1. 总体过程

    - 创建MonitoredTask，并把HMaster的状态设置为Masterstartup(新版本1.3.0放入HBase自封装的线程类中运行)

    - 启动infoserver，即Jetty服务器，端口默认为60010，其对外提供两个接口：/master-status和/dump(新版本1.3.0在HMaster的构造方法中运行)

    -调用becomeActiveMaster方法（见下文分析），阻塞等待直至当前master成为activemaster(新版本1.3.0修改为startActiveMasterManager方法)

    -当成为了master之后并且当前master进程正在运行，则调用finishInitialization方法（见下文分析），并且调用loop方法循环等待，一直到stop发生

    - 当HMaster停止运行时候，会做以下事情：

        - 清理startupStatus

        - 停止balancerChore和catalogJanitorChore

        - 让RegionServers shutdown

        -停止服务线程：rpcServer、logCleaner、hfileCleaner、infoServer、executorService、healthCheckChore

        -停止以下线程：activeMasterManager、catalogTracker、serverManager、assignmentManager、fileSystemManager、snapshotManager、zooKeeper

           

2.becomeActiveMaster方法

    - 创建ActiveMasterManager

    - ZooKeeperWatcher注册activeMasterManager监听器

    - 调用stallIfBackupMaster：–>先检查配置项 “hbase.master.backup”，自己是否backup机器，如果是则直接block直至检查到系统中的active master挂掉（zookeeper.session.timeout，默认每3分钟检查一次）

    - 创建clusterStatusTracker并启动

    -调用activeMasterManager的blockUntilBecomingActiveMaster方法。

        -创建短暂的”/hbase/master”，此节点值为version+ServerName，如果创建成功，则删除备份节点；否则，创建备份节点

        -获得”/hbase/master”节点上的数据，如果不为null，则获得ServerName，并判断是否是在当前节点上创建了”/hbase/master”，如果是则删除该节点，这是因为该节点已经是备份节点了。

        ```java

        public class HMaster{

            private booleanbecomeActiveMaster(MonitoredTask startupStatus)throws InterruptedException {

                // TODO: This is wrong!!!!Should have new servername if we restart ourselves,

                // if we come back to life.

                //创建activeMasterManager对象

                this.activeMasterManager = newActiveMasterManager(zooKeeper, this.serverName,

                    this);

               //注册activeMasterManager到zookeeper

               this.zooKeeper.registerListener(activeMasterManager);

                stallIfBackupMaster(this.conf,this.activeMasterManager);

           

                // The ClusterStatusTracker issetup before the other

                // ZKBasedSystemTrackersbecause it's needed by the activeMasterManager

                // to check if the clustershould be shutdown.

                this.clusterStatusTracker = newClusterStatusTracker(getZooKeeper(), this);

               this.clusterStatusTracker.start();

                returnthis.activeMasterManager.blockUntilBecomingActiveMaster(startupStatus);

              }

        }

      ```

3.finishInitialization方法

    -创建MasterFileSystem对象，封装了master常用的一些文件系统操作，包括splitlogfile、删除region目录、删除table目录、删除cf目录、检查文件系统状态等.

    -创建FSTableDescriptors对象(新版本1.3.0在HRegionServer的构造函数上创建)

    - 设置集群id(publish cluster ID)

    ```

    ZKClusterId.setClusterId(this.zooKeeper,fileSystemManager.getClusterId());

    ```

    - 如果不是备份master：

        -创建ExecutorService，维护一个ExecutorMap,一种Event对应一个Executor(线程池)。可以提交EventHandler来执行异步事件；(新版本1.3.0在HRegionServer的构造函数中创建)

        - 创建serverManager，管理regionserver信息，维护着onlineregion server和deadregionserver列表，处理regionserver的startups、shutdowns、 deaths，同时也维护着每个regionserver rpcstub。

    -调用initializeZKBasedSystemTrackers，初始化zk文件系统：

        - 创建CatalogTracker,它包含RootRegionTracker和MetaNodeTracker，对应”/hbase/root-region-server”和/”hbase/unassigned/1028785192”这两个结点(1028785192是.META.的分区名)。如果之前从未启动过hbase，那么在startCatalogTracker时这两个结点不存在。”/hbase/root-region-server”是一个持久结点，在RootLocationEditor中建立

        - 创建LoadBalancer，负责region在regionserver之间的移动，关于balancer的策略，可以通过hbase.regions.slop来设置load区间

        - 创建AssignmentManager，负责管理和分配region，同时它也会接受zk上关于region的event，根据event来完成region的上下线、关闭打开等工作。

        - 创建 RegionServerTracker:监控”/hbase/rs”结点，通过ZK的Event来跟踪onlineregion servers，如果有rs下线，删除ServerManager中对应的onlineregions.

        - 创建 DrainingServerTracker:监控”/hbase/draining”结点.在大型集群中, 用户有时需要把一部分regionserver服务器一起停止服务迁出HBase集群，这些将要被迁出的region server称为draining region server。

        - 创建ClusterStatusTracker，监控”/hbase/shutdown”结点维护集群状态

        - 创建SnapshotManager:负责管理HBase快照功能，包括创建快照，恢复快照。快照是HBase从0.94.6开始提供的功能，创建快照时并不复制数据，因此速度很快，对regionserver性能基本没有影响。

    -如果不是备份master，初始化MasterCoprocessorHost并执行startServiceThreads()。说明：infoserver的启动移到构造函数了去了，这样可以早点通过Jetty服务器查看HMaster启动状态。

        - 创建一些executorService

        - 创建logCleaner并启动

        - 创建hfileCleaner并启动

        - 启动healthCheckChore

        - 打开rpcServer

    - 等待RegionServer注册。满足以下这些条件后返回当前所有regionserver上的region数后继续：

        - a至少等待4.5s，"hbase.master.wait.on.regionservers.timeout"

        - b成功启动regionserver节点数>=1，"hbase.master.wait.on.regionservers.mintostart"

        - c1.5s内没有regionsever死掉或重新启动，"hbase.master.wait.on.regionservers.interval"

    - serverManager注册新的在线region server

    - 如果不是备份master，启动assignmentManager

    - 获取下线的Region server，然后拆分HLog

        ```

        // get a list for previously failed RSwhich need log splitting work

        // we recover hbase:meta region serversinside master initialization and

        // handle other failed servers in SSHin order to start up master node ASAP

        Set<ServerName>previouslyFailedServers =

                       this.fileSystemManager.getFailedServersFromLogFolders();

                       

        // log splitting for hbase:metaserver               

        ServerName oldMetaServerLocation =metaTableLocator.getMetaRegionLocation(this.getZooKeeper());

        if (oldMetaServerLocation != null&& previouslyFailedServers.contains(oldMetaServerLocation)) {

           splitMetaLogBeforeAssignment(oldMetaServerLocation);

            // Note: we can't removeoldMetaServerLocation from previousFailedServers list because it

            // may also host user regions

        }

        ```

        - –>依次检查每一个hlog目录，查看它所属的region server是否online，如果是则不需要做任何动作，region server自己会恢复数据，如果不是，则需要将它分配给其它的region server

        - –>split是加锁操作:

        - –>创建一个新的hlogsplitter,遍历每一个server目录下的所有hlog文件，依次做如下操作。（如果遇到文件损坏等无法跳过的错误，配置hbase.hlog.split.skip.errors=true以忽略之）

        - –>启动hbase.regionserver.hlog.splitlog.writer.threads（默认为3）个线程，共使用128MB内存，启动这些写线程

        - –>先通过lease机制检查文件是否能够append，如果不能则死循环等待

            - –>把hlog中的内容全部加载到内存中（内存同时被几个写线程消费)）

            - –>把有损坏并且跳过的文件移到/hbase/.corrupt/目录中

            - –>把其余己经处理过的文件移到/hbase/.oldlogs中，然后删除原有的server目录

            - –>等待写线程结束，返回新写的所有路径

        - –>解锁

        - 写线程逻辑：

            - –>从内存中读出每一行数据的key和value，然后查询相应的region路径。如果该region路径不存在，说明该region很可能己经被split了，则不处理这部分数据,因为此时忽略它们是安全的。

            - –>如果上一步能查到相应的路径，则到对应路径下创建”recovered.edits”文件夹(如果该文件夹存在则删除后覆盖之)，然后将数据写入该文件夹

    -调用assignRoot方法，检查是否分配了-ROOT-表，如果没有，则通过assignmentManager.assignRoot()来分配root表，并激活该表

    - 运行this.serverManager.enableSSHForRoot()方法

    - 拆分.META. server上的HLog

    - 分配.META.表

    - enableServerShutdownHandler

    - 处理dead的server

    - assignmentManager.joinCluster();

    - 设置balancer

    - fixupDaughters(status)

    - 如果不是备份master

        - 启动balancerChore线程，运行LoadBalancer

        -启动startCatalogJanitorChore，周期性扫描.META.表上未使用的region并回收

        - registerMBean

    -serverManager.clearDeadServersWithSameHostNameAndPortOfOnlineServer()，清理dead的server

    - 如果不是备份master，cpHost.postStartMaster()

   

   

###MasterFileSystem构造方法调用

1.在HMaster.finishInitialization方法中触发了MasterFileSystem的构造方法，该类在HMaster类中会被以下类使用：

    - LogCleaner

    - HFileCleaner

   

   另外该类可以完成拆分log的工作(新版本1.3.0中由SplitLogManager完成该工作)：

    ```

    /**

      * Override to change master'ssplitLogAfterStartup. Used testing

      * @param mfs

      */

    protected void splitLogAfterStartup(finalMasterFileSystem mfs){

        mfs.splitLogAfterStartup();

    }

    ```

   

2. 构造方法运行过程

    - 获取rootdir：由参数hbase.rootdir配置

    - 获取tempdir：${hbase.rootdir}/.tmp

    -获取文件系统的uri，并设置到fs.default.name和fs.defaultFS

    -判断是否进行分布式文件拆分，参数：hbase.master.distributed.log.splitting，如果需要，则创建SplitLogManager

    -创建oldLogDir，调用createInitialFileSystemLayout方法

        - checkRootDir

            -等待fs退出安全模式(默认10秒钟轮循一次，可通过参数hbase.server.thread.wakefrequency调整

            -如果hbase.rootdir目录不存在则创建它，然后在此目录中创建名为”hbase.version”的文件，内容是文件系统版本号，当前为7；如果hbase.rootdir目录已存在，则读出”hbase.version”文件的内容与当前的版本号相比，如果不相等，则打印错误信息(提示版本不对)，抛出异常FileSystemVersionException

            -检查${hbase.rootdir}目录下是否有名为”hbase.id”的文件，如果没有则创建它，内容是随机生成的UUID(总长度36位，由5部份组成，用”-“分隔)，如：6c43f934-37a2-4cae-9d49-3f5abfdc113d

            - 读出”hbase.id”的文件的内容存到clusterId字段

            -判断hbase.rootdir目录中是否有”-ROOT-/70236052”目录，没有的话说明是第一次启动hbase，进入bootstrap方法

            - createRootTableInfo建立”-ROOT-“表的描述文件，判断hbase.rootdir/-ROOT-目录中是否存在tableinfo开头的文件，另外还创建了.tmp目录

        - checkTempDir

        -如果oldLogDir（${hbase.rootdir}/.oldlogs）不存在，则创建

           

3. bootstrap方法运行过程：

    -调用HRegion.createHRegion建立”-ROOT-“分区和”.META.”分区

    - 把”.META.”分区信息加到”-ROOT-“表，并关闭分区和hlog

   

 

### 总结

 

1.zookeeper创建目录分布式与监控类之间关系

 

|目录                       |监控类               |作用                      |

|------------------------ | ------------------- | ------------------------ |

|/hbase                    |                     |                          |

|/hbase/root-region-server|RootRegionTracker   |监控root所在的regionserver |

|/hbase/rs                 |RegionServerTracker  |监控regionserver的上线和下线|

|/table/draining          |DrainingServerTracker|监听regionserver列表的变化  |

|/hbase/master             |                    |在HMaster中建立，并且是一个短暂结点，结点的值是HMaster的ServerName：hostname,port,当前毫秒|

|/hbase/backup-masters     |                     |                          |

|/hbase/shutdown           |ClusterStatusTracker|当HMaster启动之后，会将当前时间（Bytes.toBytes(new java.util.Date().toString())）存到该节点|

|/hbase/unassigned         |MetaNodeTracker      |                          |

|/hbase/table94            |                     |                          |

|/hbase/table              |                     |                          |

|/hbase/hbaseid            |                    |在HMaster.finishInitialization方法中调用ClusterId.setClusterId建立，结点值是UUID|

|/hbase/splitlog           |                     |                          |

 

2.HMaster启动之后，${hbase.rootdir}目录

>

    .

    ├── -ROOT-                           //"-ROOT-"表名

    │  ├── ..tableinfo.0000000001.crc   //crc校验文件

    │  ├── .tableinfo.0000000001

    │  ├── .tmp

    │  └── 70236052                     //"-ROOT-"分区名

    │      ├── ..regioninfo.crc

    │      ├── .oldlogs                 //存放hlog文件

    │      │   ├── .hlog.1402551641526.crc

    │      │   └── hlog.1402551641526

    │      ├── .regioninfo              //"-ROOT-"分区描述表件

    │      ├── .tmp

    │      └── info                     //列族名

    │          ├── .5037e69a0c244bd78945aaa333d0230a.crc

    │          └── 5037e69a0c244bd78945aaa333d0230a //存放".META."分区信息的StoreFile

    ├── .META.

    │  └── 1028785192

    │      ├── ..regioninfo.crc

    │      ├── .oldlogs

    │      │   ├── .hlog.1402551641701.crc

    │      │   └── hlog.1402551641701

    │      ├── .regioninfo

    │      └── info

    ├── .hbase.id.crc

    ├── .hbase.version.crc

    ├── .oldlogs

    ├── .tmp

    ├── hbase.id                         //集群uuid

    └── hbase.version                    //hbase版本

   

3. HMaster启动主要运行过程

    - 创建rpcServer，及HBaseServer

    - 创建ZooKeeperWatcher监听器

    - 阻塞等待成为activeMaster

    - 创建master的一些文件目录

    - 初始化一些基于zk的跟踪器

    - 创建LoadBalancer

    - 创建SnapshotManager

    - 如果不是备份master

        - 创建logCleaner并启动

        - 创建hfileCleaner并启动

        - 创建jetty的infoServer并启动

        - 启动健康检查

        - 打开rpcServer

    - 等待RegionServer注册

    - 从hlog中恢复数据

    - 分配root和meta表

    - 分配region

    - 运行负载均衡线程

    - 周期性扫描.META.表上未使用的region并回收

   

 

## 5.Region Server组件

启动了HMaster之后，再启动HRegionServer。

 

###HRegionServer的mian方法调用

 

1.HRegionServer的入口是main方法，main方法需要传递一个参数，start或者stop。

```java

importorg.apache.hadoop.hbase.regionserver.HRegionServer;

 

public classHRegionServerStarter {

    public static void main(String[] args)throws Exception {

        //newHMasterStarter.ZookeeperThread().start();

        HRegionServer.main(new String[] {"start" });

    }

}

```

 

2.通过反射创建一个HRegionServer实例，然后调用其run方法。(其实步骤都和HMaster一样，难怪新版本1.3.0中HMaster已经继承HRegionServer)

 

3.HRegionServer类继承关系

> 

 

 

###HRegionServer构造方法调用

 

-设置服务端HConnection重试次数

-检查压缩编码，通过hbase.regionserver.codecs可以配置编码类，一一检测，判断是否支持其压缩算法。

-获取useHBaseChecksum值，是否开启hbase checksum校验

-获取hbase.regionserver.separate.hlog.for.meta参数值

- 获取客户端重复次数

-获取threadWakeFrequency值

-获取hbase.regionserver.msginterval值

-创建Sleeper对象，用于周期性休眠线程

-获取最大扫描结果集大小，hbase.client.scanner.max.result.size，默认无穷大

-获取hbase.regionserver.numregionstoreport值

-获取rpctimeout值，hbase.rpc.timeout，默认60000

-获取主机名和绑定的ip和端口，端口默认为60020

- 创建rpcServer

- zk授权登录和hbase授权

-创建RegionServerAccounting

- 创建CacheConfig

 

 

### run方法

   

-preRegistrationInitialization

    - initializeZooKeeper，此方法不会创建任何节点

        -创建ZooKeeperWatcher(新版本1.3.0修改为在构造函数中运行)

        - 创建MasterAddressTracker并等到”/hbase/master”节点有数据为止

        - 创建ClusterStatusTracker并等到”/hbase/shutdown”节点有数据为止

        - 创建CatalogTracker 不做任何等待

        - 创建RegionServerSnapshotManager

        - 设置集群id

    - 初始化线程：initializeThreads

        - 创建 cacheFlusher

        - 创建 compactSplitThread

        - 创建 compactionChecker

        - 创建 periodicFlusher

        - 创建 healthCheckChore

        - 创建 Leases

        - 判断是否启动 HRegionThriftServer

    -参数hbase.regionserver.nbreservationblocks默认为4，默认会预留20M(每个5M,20M = 4*5M)的内存防止OOM

    - 初始化rpcEngine =HBaseRPC.getProtocolEngine(conf)

-reportForDuty，轮询，向汇报master自己已经启动

    -getMaster()，取出”/hbase/master”节点中的数据，构造一个master的ServerName，然后基于此生成一个HMasterRegionInterface接口的代理，此代理用于调用master的方法

    - regionServerStartup

-当轮询结果不为空时，调用handleReportForDutyResponse

    -regionServerStartup会返回来一个MapWritable，这个MapWritable有三个值，这三个key的值会覆盖rs原有的conf:

        -“hbase.regionserver.hostname.seen.by.master” =master为rs重新定义的hostname(通常跟rs的InetSocketAddress.getHostName一样)rs会用它重新得到serverNameFromMasterPOV

        - “fs.default.name” = “file:///”

        -“hbase.rootdir”        = “file:///E:/hbase/tmp”

    - 查看conf中是否有”mapred.task.id”，没有就自动设一个(格式:“hb_rs_“+serverNameFromMasterPOV)，例如: hb_rs_localhost,60050,1323525314060

    - createMyEphemeralNode：在zk中建立短暂节点”/hbase/rs/localhost,60050,1323525314060”，也就是把当前rs的serverNameFromMasterPOV(为null的话用rs的InetSocketAddress、port、startcode构建新的ServerName)放到/hbase/rs节点下，”/hbase/rs/localhost,60050,1323525314060”节点没有数据

    - 设置fs.defaultFS值为hbase.rootdir的值

    -生成一个只读的FSTableDescriptors(新版本1.3.0修改为构造函数中运行)

    - 调用setupWALAndReplication

    - 初始化 hlog、metrics、dynamicMetrics、rsHost

    - 调用startServiceThreads启动服务线程

        - 启动一些ExecutorService

        - 启动hlogRoller

        - 启动cacheFlusher

        - 启动compactionChecker

        - 启动healthCheckChore

        - 启动periodicFlusher

        - leases.start()

        - 启动jetty的infoServer，默认端口为60030(新版本1.3.0修改至构造函数的putUpWebUI)

        -启动复制相关打的一些handler：replicationSourceHandler、replicationSourceHandler、replicationSinkHandler

        - rpcServer启动

        - 创建并启动SplitLogWorker

- registerMBean

-snapshotManager启动快照服务

-在master上注册之后，进入运行模式，周期性(msgInterval默认3妙)调用doMetrics，tryRegionServerReport

-isHealthy健康检查，只要Leases、MemStoreFlusher、LogRoller、periodicFlusher、CompactionChecker有一个线程退出，regionServer就停止

    - doMetrics

    -tryRegionServerReport向master汇报rs的负载HServerLoad

- shutdown之后的一些操作

    - unregisterMBean

    -停掉thriftServer、leases、rpcServer、splitLogWorker、infoServer、cacheConfig

    -中断一些线程：cacheFlusher、compactSplitThread、hlogRoller、metaHLogRoller、compactionChecker、healthCheckChore

    - 停掉napshotManager

    - 停掉 catalogTracker、compactSplitThread

    - 等待所有region关闭

    - 关闭wal

    - 删除zk上的一些临时节点，zooKeeper关闭

 

 

### 总结

 

1. 功能总结

    - 在zk上注册自己，表明自己上线了

    - 跟master汇报

    - 设置wal和复制

    - 注册协作器RegionServerCoprocessorHost

    - 启动hlogRoller

    - 定期刷新memstore

    - 定期检测是否需要压缩合并

    - 启动租约

    - 启动jetty的infoserver

    - 创建SplitLogWorker，用于拆分HLog

    - 快照管理

 

2. 对象总结

    - HBaseServer：处理客户端请求

    - Leases：租约

    - InfoServer：Jetty服务器

    - RegionServerMetrics：

    - RegionServerDynamicMetrics：

    - CompactSplitThread：合并文件线程

    - MemStoreFlusher：刷新memstore线程

    - 两个Chore：compactionChecker、periodicFlusher

    - 两个LogRoller：hlogRoller、metaHLogRoller

    - MasterAddressTracker：跟踪master地址

    - CatalogTracker：跟踪-ROOT-和.META.表

    - ClusterStatusTracker：跟踪集群状态

    - SplitLogWorker：拆分log

    - Sleeper：

    - ExecutorService：

    -ReplicationSourceService和ReplicationSinkService：复制服务

    - RegionServerAccounting：

    - CacheConfig：缓存配置和block

    -RegionServerCoprocessorHost：RegionServer协作器

    - HealthCheckChore：健康检查

 

 

## 6.ZooKeeper组件