Hadoop-2.7.0 HA实现细节分析之HealthMonitor-阿里云开发者社区

开发者社区> 大数据> 正文
登录阅读全文

Hadoop-2.7.0 HA实现细节分析之HealthMonitor

简介: 一、HealthMonitor是什么       HealthMonitor是一个周期性工作的后台线程,它在一个循环中周期性的同HA服务进行心跳,负责跟踪NameNode服务的健康状况,并在健康状况变化时调用failover控制器的回调方法。

一、HealthMonitor是什么

      HealthMonitor是一个周期性工作的后台线程,它在一个循环中周期性的同HA服务进行心跳,负责跟踪NameNode服务的健康状况,并在健康状况变化时调用failover控制器的回调方法。

二、HealthMonitor是如何实现的

      1、成员变量

            HealthMonitor内部有如下主要成员变量:

            1)后台工作线程:真正卖力干活的

  private Daemon daemon;// 后台工作线程
            2)一些时间间隔、rpc超时参数等配置信息,见注释

  // 重连、周期性检查、失连后的睡眠时间等时间间隔
  private long connectRetryInterval;
  private long checkIntervalMillis;
  private long sleepAfterDisconnectMillis;

  // rpc超时时间
  private int rpcTimeout;
    // 配置信息
  private final Configuration conf;

            3)连接代理相关

  /** The connected proxy */
  // 连接代理
  private HAServiceProtocol proxy;

  /** The HA service to monitor */
  // HA服务到监视器的对象,通过它来获取连接代理proxy,代表一个客户端HA管理命令的目标。
  private final HAServiceTarget targetToMonitor;

            4)监视器s,状态发生变化时需要周知监视器s,故它们都实现了相同的接口

  /**
   * Listeners for state changes
   * 状态变更监视器列表,里面的元素是实现Callback的对象
   */
  private List<Callback> callbacks = Collections.synchronizedList(
      new LinkedList<Callback>());

  /**
   * 服务状态监视器列表,里面的元素是实现ServiceStateCallback的对象
   */
  private List<ServiceStateCallback> serviceStateCallbacks = Collections
      .synchronizedList(new LinkedList<ServiceStateCallback>());

            5)状态

  // 服务状态,默认为正在初始化
  private State state = State.INITIALIZING;
  /**
   * 最后一次服务状态,默认为正在初始化
   */
  private HAServiceStatus lastServiceState = new HAServiceStatus(
      HAServiceState.INITIALIZING);

      2、状态&接口

            2.1、状态

            HealthMonitor定义了几个状态,如下:

  @InterfaceAudience.Private
  public enum State {
    /**
     * The health monitor is still starting up.
     * 健康监视器正在启动
     */
    INITIALIZING,

    /**
     * The service is not responding to health check RPCs.
     * 健康监测RPCs服务没有响应
     */
    SERVICE_NOT_RESPONDING,

    /**
     * The service is connected and healthy.
     * 服务已连接且健康
     */
    SERVICE_HEALTHY,
    
    /**
     * The service is running but unhealthy.
     * 服务正在运行但是不健康
     */
    SERVICE_UNHEALTHY,
    
    /**
     * The health monitor itself failed unrecoverably and can
     * no longer provide accurate information.
     * 健康监视器自己发生不可恢复故障且不能再提供准确信息
     */
    HEALTH_MONITOR_FAILED;
  }
            分别对应了HealthMonitor监视服务健康状况过程中的一些状态,如下:

            1)INITIALIZING:健康监视器正在启动;

            2)SERVICE_NOT_RESPONDING:健康监测RPCs服务没有响应,有可能是连接、rpc通讯问题等等;

            3)SERVICE_HEALTHY:服务已连接且健康,这是一种比较理想的结果;

            4)SERVICE_UNHEALTHY:服务正在运行但是不健康,这个结果也不赖,至少知道了服务不健康,也属于正常的检测结果;

            5)HEALTH_MONITOR_FAILED:健康监视器自己发生不可恢复故障且不能再提供准确信息,糟糕透顶,监视线程本身出故障了。
            2.2、监视器回调接口

            HealthMonitor定义了两个接口,Callback和ServiceStateCallback,分别是在状态发生变更和服务状态发生变更时的,需要周知所有监听器的回调方法,如下:

  /**
   * Callback interface for state change events.
   * 状态变更事件的回调接口,需要实现enteredState()方法,即进入一种新的状态
   * 
   * This interface is called from a single thread which also performs
   * the health monitoring. If the callback processing takes a long time,
   * no further health checks will be made during this period, nor will
   * other registered callbacks be called.
   * 这个接口被一个执行健康监测的特定线程调用。如果回调处理需要很长时间,在此期间没有进一步的健康检查进行,其他注册回调函数也不会被调用。
   * 
   * If the callback itself throws an unchecked exception, no other
   * callbacks following it will be called, and the health monitor
   * will terminate, entering HEALTH_MONITOR_FAILED state.
   * 
   * 
   */
  static interface Callback {
    void enteredState(State newState);
  }

  /**
   * Callback interface for service states.
   * 服务状态的回调接口
   */
  static interface ServiceStateCallback {
    void reportServiceStatus(HAServiceStatus status);
  }
      至于上述状态和接口如何调用,在下面会详解。

      3、内部工作流程

       HealthMonitor的工作流程,主要看内部工作线程的执行,如下:

  /**
   * 监视器后台线程
   *
   */
  private class MonitorDaemon extends Daemon {
    
   /**
    * 私有内部类的私有构造函数  
    */
   private MonitorDaemon() {
      super();
      
      // 设置线程名称
      setName("Health Monitor for " + targetToMonitor);
      
      // 设置异常处理:调用enterState()方法,并传入健康监控器自己失败的状态
      setUncaughtExceptionHandler(new UncaughtExceptionHandler() {
        @Override
        public void uncaughtException(Thread t, Throwable e) {
          LOG.fatal("Health monitor failed", e);
          enterState(HealthMonitor.State.HEALTH_MONITOR_FAILED);
        }
      });
    }
    
   /**
    * 线程核心run()方法
    */
    @Override
    public void run() {
      while (shouldRun) {// 在一个while循环内,循环的条件是shouldRun标志位
        try { 
          loopUntilConnected();// 循环直到连接上
          doHealthChecks();// 执行健康检查
        } catch (InterruptedException ie) {
          Preconditions.checkState(!shouldRun,
              "Interrupted but still supposed to run");
        }
      }
    }
  }
      首先,监视后台线程的核心run()方法,在一个while循环内,循环的条件是shouldRun标志位:

      1)循环直到连接上:不停的连接,直到连接上;

      2)执行健康检查。

      如此简单的两步,下面我们需要看下以下问题:

      1)如何连接?

      2)如何执行健康检查,得到检查结果后如何处理?


      1、如何连接?

       分析loopUntilConnected()方法如下:

  /**
   * 循环直到连接上
   */
  private void loopUntilConnected() throws InterruptedException {
    // 尝试连接
	tryConnect();
	
	// tryConnect()成功的话,proxy应该不为null
	// proxy为null,说明还需要重试,在一个while循环内进行,循环的条件就是proxy为null
    while (proxy == null) {
      // 线程休眠一段时间
      Thread.sleep(connectRetryInterval);
      
      // 再次尝试连接
      tryConnect();
    }
    
    // 最后的assert需要确保proxy不为null
    assert proxy != null;
  }


  private void tryConnect() {
    
	// 仅当代理proxy为空时才尝试连接
	Preconditions.checkState(proxy == null);
    
    try {
      synchronized (this) {// 同步代码块内创建代理proxy
        proxy = createProxy();
      }
    } catch (IOException e) {
      
      // 代理proxy创建发生异常时,proxy设置为null,方便下次重试,并且调用enterState()方法,确定状态为健康监测RPCs服务没有响应
      LOG.warn("Could not connect to local service at " + targetToMonitor +
          ": " + e.getMessage());
      proxy = null;
      enterState(State.SERVICE_NOT_RESPONDING);
    }
  }
  
  /**
   * Connect to the service to be monitored. Stubbed out for easier testing.
   */
  protected HAServiceProtocol createProxy() throws IOException {
	// 通过目标到监视器的对象targetToMonitor获取代理
    return targetToMonitor.getProxy(conf, rpcTimeout);
  }
        很简单,通过targetToMonitor获得代理,获取成功的话,直接返回,失败的话线程休眠一段时间,继续重试。



        2、如何执行健康检查,得到检查结果后如何处理?

        分析doHealthChecks()方法如下:

        在一个while循环内,循环的依据同样是shouldRun标志位为true,且线程会周期性休眠:

        1)HA服务状态status设置为null;

        2)标志位healthy默认为false,即不健康;

        3)获取服务代理的服务状态,并由代理执行健康检查;

        4)1、如果健康检查能够正确返回,标志位healthy设置为true,表明服务健康;

               2、抛出了异常:

                     2.1、如果是健康检查失败异常,调用enterState()方法,确定状态为服务正在运行但是不健康;

                     2.1、否则调用enterState()方法,确定状态为健康监测RPCs服务没有响应,停止并清空代理,线程休眠一段时间,避免异常情况下没有必要的重复尝试;

         5)设置上次服务状态;

         6)如果检测结果为健康,则调用enterState()方法,确定状态为服务已连接且健康;

         7)工作线程周期性休眠。

        可以看到,健康状况的检查是通过代理完成的,且,如果有检查结果(无论是正常还是不正常,这里的正常是指返回了明确的结果,不正常只通讯、连接或者线程本身出现问题),会通过enterState()方法通知监听器s,如下:

  private synchronized void enterState(State newState) {
    
	// 如果状态变更,调用所有监听器的enteredState()方法
	if (newState != state) {
      LOG.info("Entering state " + newState);
      state = newState;
      synchronized (callbacks) {
        for (Callback cb : callbacks) {
          cb.enteredState(newState);
        }
      }
    }
  }
        而整体HA服务状态也会通过setLastServiceStatus()方法,设置lastServiceState成员变量,并通知服务状态监听器,如下:

  // 设置上次服务状态,同步所有ServiceStateCallback服务状态监听器的服务状态
  private synchronized void setLastServiceStatus(HAServiceStatus status) {
    this.lastServiceState = status;
    for (ServiceStateCallback cb : serviceStateCallbacks) {
      cb.reportServiceStatus(lastServiceState);
    }
  }
        这也就是上述状态和接口存在的意义。而监听器的注册和注销则是通过如下实现的:

  /**
   * 以下四个为增减状态、服务状态监视器方法
   */
  public void addCallback(Callback cb) {
    this.callbacks.add(cb);
  }
  
  public void removeCallback(Callback cb) {
    callbacks.remove(cb);
  }

  public synchronized void addServiceStateCallback(ServiceStateCallback cb) {
    this.serviceStateCallbacks.add(cb);
  }

  public synchronized void removeServiceStateCallback(ServiceStateCallback cb) {
    serviceStateCallbacks.remove(cb);
  }

三、HealthMonitor的初始化及启动

        HealthMonitor的构造及启动是在ZKFailoverController的initHM()方法内完成的,它是整个Hadoop HDFS HA中的一个控制组件,初始化及启动如下:

  // ------------------------------------------
  // Begin actual guts of failover controller
  // ------------------------------------------
  
  private void initHM() {
    healthMonitor = new HealthMonitor(conf, localTarget);
    healthMonitor.addCallback(new HealthCallbacks());
    healthMonitor.addServiceStateCallback(new ServiceStateCallBacks());
    healthMonitor.start();
  }
        构造一个HealthMonitor实例,传入的代理为localTarget,并注册了一个state change的监听器HealthCallbacks和service state change的监听器ServiceStateCallBacks,然后调用start()方法启动。

        至于HealthMonitor如何与其它组件一起工作的,如何获得的代理,代理怎么执行监控检查,监听器如何处理健康检查的结果,请关注后续文章。

版权声明:本文内容由阿里云实名注册用户自发贡献,版权归原作者所有,阿里云开发者社区不拥有其著作权,亦不承担相应法律责任。具体规则请查看《阿里云开发者社区用户服务协议》和《阿里云开发者社区知识产权保护指引》。如果您发现本社区中有涉嫌抄袭的内容,填写侵权投诉表单进行举报,一经查实,本社区将立刻删除涉嫌侵权内容。

分享:
大数据
使用钉钉扫一扫加入圈子
+ 订阅

大数据计算实践乐园,近距离学习前沿技术

其他文章