Hadoop3.2.1 【 YARN 】源码分析 : StateMachineFactory解析[二]

水深无声 2023-01-01 01:45 121阅读 0赞

# 一. 前言 #

RMNode是ResourceManager中用于维护一个节点生命周期的数据结构， 它的实现是RMNodeImpl类， 该类维护了一个节点状态机， 记录了节点可能存在的各个状态以及导致状态间转换的事件。 当某个事件发生时， RMNodeImpl会根据实际情况进行节点状态转移， 同时触发一个行为。在这里我们拿RMNodeImpl 查看一下构建后状态机的数据存储结构. 具体的状态不做说明, 先看一下RMNodeImpl流程图.

![RMNodeImpl][]

# 二 . StateMachineFactory构建代码 #

在实现类里面有一段巨长静态变量stateMachineFactory . 通过newStateMachineFactory(NodeState.NEW) 构建一个newStateMachineFactory静态对象,然后调用addTransition方法构建状态之间的关系. 然后用installTopology方法构建拓扑图.  
在RMNodeImple的构造方法里面,通过make创建状态机对象stateMachine .

这个是代码的简化图  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3poYW5nbG9uZ180NDQ0_size_16_color_FFFFFF_t_70]

代码在下面,巨长 :

private static final StateMachineFactory<RMNodeImpl, NodeState, RMNodeEventType, RMNodeEvent> stateMachineFactory 
                     = new StateMachineFactory<RMNodeImpl, NodeState, RMNodeEventType, RMNodeEvent>(NodeState.NEW)
          //Transitions from NEW state
          .addTransition(NodeState.NEW, NodeState.RUNNING,
              RMNodeEventType.STARTED, new AddNodeTransition())
          .addTransition(NodeState.NEW, NodeState.NEW,
              RMNodeEventType.RESOURCE_UPDATE,
              new UpdateNodeResourceWhenUnusableTransition())
          .addTransition(NodeState.NEW, NodeState.DECOMMISSIONED,
              RMNodeEventType.DECOMMISSION,
              new DeactivateNodeTransition(NodeState.DECOMMISSIONED))
          .addTransition(NodeState.NEW, NodeState.NEW,
              RMNodeEventType.FINISHED_CONTAINERS_PULLED_BY_AM,
              new AddContainersToBeRemovedFromNMTransition())
    
          //Transitions from RUNNING state
          .addTransition(NodeState.RUNNING,
              EnumSet.of(NodeState.RUNNING, NodeState.UNHEALTHY),
              RMNodeEventType.STATUS_UPDATE,
              new StatusUpdateWhenHealthyTransition())
          .addTransition(NodeState.RUNNING, NodeState.DECOMMISSIONED,
              RMNodeEventType.DECOMMISSION,
              new DeactivateNodeTransition(NodeState.DECOMMISSIONED))
          .addTransition(NodeState.RUNNING, NodeState.DECOMMISSIONING,
              RMNodeEventType.GRACEFUL_DECOMMISSION,
              new DecommissioningNodeTransition(NodeState.RUNNING,
                  NodeState.DECOMMISSIONING))
          .addTransition(NodeState.RUNNING, NodeState.LOST,
              RMNodeEventType.EXPIRE,
              new DeactivateNodeTransition(NodeState.LOST))
          .addTransition(NodeState.RUNNING, NodeState.REBOOTED,
              RMNodeEventType.REBOOTING,
              new DeactivateNodeTransition(NodeState.REBOOTED))
    
    
    
          .addTransition(NodeState.RUNNING, NodeState.RUNNING,
              RMNodeEventType.CLEANUP_APP, new CleanUpAppTransition())
    
          .addTransition(NodeState.RUNNING, NodeState.RUNNING,
              RMNodeEventType.CLEANUP_CONTAINER, new CleanUpContainerTransition())
    
          .addTransition(NodeState.RUNNING, NodeState.RUNNING,
              RMNodeEventType.FINISHED_CONTAINERS_PULLED_BY_AM,
              new AddContainersToBeRemovedFromNMTransition())
    
          .addTransition(NodeState.RUNNING, EnumSet.of(NodeState.RUNNING),
              RMNodeEventType.RECONNECTED, new ReconnectNodeTransition())
    
          .addTransition(NodeState.RUNNING, NodeState.RUNNING,
              RMNodeEventType.RESOURCE_UPDATE, new UpdateNodeResourceWhenRunningTransition())
    
          .addTransition(NodeState.RUNNING, NodeState.RUNNING,
              RMNodeEventType.UPDATE_CONTAINER,
              new UpdateContainersTransition())
    
          .addTransition(NodeState.RUNNING, NodeState.RUNNING,
              RMNodeEventType.SIGNAL_CONTAINER, new SignalContainerTransition())
    
    
    
          .addTransition(NodeState.RUNNING, NodeState.SHUTDOWN,
              RMNodeEventType.SHUTDOWN,
              new DeactivateNodeTransition(NodeState.SHUTDOWN))
    
          //Transitions from REBOOTED state
          .addTransition(NodeState.REBOOTED, NodeState.REBOOTED,
              RMNodeEventType.RESOURCE_UPDATE,
              new UpdateNodeResourceWhenUnusableTransition())
    
          //Transitions from DECOMMISSIONED state
          .addTransition(NodeState.DECOMMISSIONED, NodeState.DECOMMISSIONED,
              RMNodeEventType.RESOURCE_UPDATE,
              new UpdateNodeResourceWhenUnusableTransition())
          .addTransition(NodeState.DECOMMISSIONED, NodeState.DECOMMISSIONED,
              RMNodeEventType.FINISHED_CONTAINERS_PULLED_BY_AM,
              new AddContainersToBeRemovedFromNMTransition())
    
           //Transitions from DECOMMISSIONING state
          .addTransition(NodeState.DECOMMISSIONING, NodeState.DECOMMISSIONED,
              RMNodeEventType.DECOMMISSION,
              new DeactivateNodeTransition(NodeState.DECOMMISSIONED))
    
          .addTransition(NodeState.DECOMMISSIONING, NodeState.RUNNING,
              RMNodeEventType.RECOMMISSION,
              new RecommissionNodeTransition(NodeState.RUNNING))
    
    
          .addTransition(NodeState.DECOMMISSIONING, NodeState.DECOMMISSIONING,
              RMNodeEventType.RESOURCE_UPDATE,
              new UpdateNodeResourceWhenRunningTransition())
    
          .addTransition(NodeState.DECOMMISSIONING,
              EnumSet.of(NodeState.DECOMMISSIONING, NodeState.DECOMMISSIONED),
              RMNodeEventType.STATUS_UPDATE,
              new StatusUpdateWhenHealthyTransition())
    
          .addTransition(NodeState.DECOMMISSIONING, NodeState.DECOMMISSIONING,
              RMNodeEventType.GRACEFUL_DECOMMISSION,
              new DecommissioningNodeTransition(NodeState.DECOMMISSIONING,
                  NodeState.DECOMMISSIONING))
    
          .addTransition(NodeState.DECOMMISSIONING, NodeState.LOST,
              RMNodeEventType.EXPIRE,
              new DeactivateNodeTransition(NodeState.LOST))
    
          .addTransition(NodeState.DECOMMISSIONING, NodeState.REBOOTED,
              RMNodeEventType.REBOOTING,
              new DeactivateNodeTransition(NodeState.REBOOTED))
    
          .addTransition(NodeState.DECOMMISSIONING, NodeState.DECOMMISSIONING,
             RMNodeEventType.FINISHED_CONTAINERS_PULLED_BY_AM,
             new AddContainersToBeRemovedFromNMTransition())
    
          .addTransition(NodeState.DECOMMISSIONING, NodeState.DECOMMISSIONING,
              RMNodeEventType.CLEANUP_APP, new CleanUpAppTransition())
    
          .addTransition(NodeState.DECOMMISSIONING, NodeState.SHUTDOWN,
              RMNodeEventType.SHUTDOWN,
              new DeactivateNodeTransition(NodeState.SHUTDOWN))
    
          // TODO (in YARN-3223) update resource when container finished.
          .addTransition(NodeState.DECOMMISSIONING, NodeState.DECOMMISSIONING,
              RMNodeEventType.CLEANUP_CONTAINER, new CleanUpContainerTransition())
    
          // TODO (in YARN-3223) update resource when container finished.
          .addTransition(NodeState.DECOMMISSIONING, NodeState.DECOMMISSIONING,
              RMNodeEventType.FINISHED_CONTAINERS_PULLED_BY_AM,
              new AddContainersToBeRemovedFromNMTransition())
    
          .addTransition(NodeState.DECOMMISSIONING, EnumSet.of(
              NodeState.DECOMMISSIONING, NodeState.DECOMMISSIONED),
              RMNodeEventType.RECONNECTED, new ReconnectNodeTransition())
    
    
          //Transitions from LOST state
          .addTransition(NodeState.LOST, NodeState.LOST,
              RMNodeEventType.RESOURCE_UPDATE,
              new UpdateNodeResourceWhenUnusableTransition())
          .addTransition(NodeState.LOST, NodeState.LOST,
              RMNodeEventType.FINISHED_CONTAINERS_PULLED_BY_AM,
              new AddContainersToBeRemovedFromNMTransition())
    
          //Transitions from UNHEALTHY state
          .addTransition(NodeState.UNHEALTHY,
              EnumSet.of(NodeState.UNHEALTHY, NodeState.RUNNING),
              RMNodeEventType.STATUS_UPDATE,
              new StatusUpdateWhenUnHealthyTransition())
    
          .addTransition(NodeState.UNHEALTHY, NodeState.DECOMMISSIONED,
              RMNodeEventType.DECOMMISSION,
              new DeactivateNodeTransition(NodeState.DECOMMISSIONED))
    
          .addTransition(NodeState.UNHEALTHY, NodeState.DECOMMISSIONING,
              RMNodeEventType.GRACEFUL_DECOMMISSION,
              new DecommissioningNodeTransition(NodeState.UNHEALTHY,
                  NodeState.DECOMMISSIONING))
    
          .addTransition(NodeState.UNHEALTHY, NodeState.LOST,
              RMNodeEventType.EXPIRE,
              new DeactivateNodeTransition(NodeState.LOST))
    
          .addTransition(NodeState.UNHEALTHY, NodeState.REBOOTED,
              RMNodeEventType.REBOOTING,
              new DeactivateNodeTransition(NodeState.REBOOTED))
    
          .addTransition(NodeState.UNHEALTHY, EnumSet.of(NodeState.UNHEALTHY),
              RMNodeEventType.RECONNECTED, new ReconnectNodeTransition())
    
          .addTransition(NodeState.UNHEALTHY, NodeState.UNHEALTHY,
              RMNodeEventType.CLEANUP_APP, new CleanUpAppTransition())
    
          .addTransition(NodeState.UNHEALTHY, NodeState.UNHEALTHY,
              RMNodeEventType.CLEANUP_CONTAINER, new CleanUpContainerTransition())
    
          .addTransition(NodeState.UNHEALTHY, NodeState.UNHEALTHY,
              RMNodeEventType.RESOURCE_UPDATE,
              new UpdateNodeResourceWhenUnusableTransition())
    
          .addTransition(NodeState.UNHEALTHY, NodeState.UNHEALTHY,
              RMNodeEventType.FINISHED_CONTAINERS_PULLED_BY_AM,
              new AddContainersToBeRemovedFromNMTransition())
    
          .addTransition(NodeState.UNHEALTHY, NodeState.UNHEALTHY,
              RMNodeEventType.SIGNAL_CONTAINER, new SignalContainerTransition())
    
          .addTransition(NodeState.UNHEALTHY, NodeState.SHUTDOWN,
              RMNodeEventType.SHUTDOWN,
              new DeactivateNodeTransition(NodeState.SHUTDOWN))
    
          //Transitions from SHUTDOWN state
          .addTransition(NodeState.SHUTDOWN, NodeState.SHUTDOWN,
              RMNodeEventType.RESOURCE_UPDATE,
              new UpdateNodeResourceWhenUnusableTransition())
          .addTransition(NodeState.SHUTDOWN, NodeState.SHUTDOWN,
              RMNodeEventType.FINISHED_CONTAINERS_PULLED_BY_AM,
              new AddContainersToBeRemovedFromNMTransition())
    
          // create the topology tables
          .installTopology();
    
    //------------------------------------------------------------------------------------
    
    
    //RMNodeImpl的构造方法中通过构建: stateMachine
    
    this.stateMachine = stateMachineFactory.make(this);

--------------------

# 三. transitionsListNode 数据结构. #

StateMachineFactory对象实例不断的调用addTransition方法更新transitionsListNode , 那么在执行installTopology方法之前, 数据的存储与数据结构是什么样的,这个一起看一下.

每次调用addTransition方法最终都会创建一个新的StateMachineFactory实例 .  
调用 StateMachineFactory 的私有构造方法:

// 私有构造方法 : no.1
      // addTransition内部创建StateMachineFactory对象。
      private StateMachineFactory(StateMachineFactory<OPERAND, STATE, EVENTTYPE, EVENT> that,
           ApplicableTransition<OPERAND, STATE, EVENTTYPE, EVENT> t) { 
        System.out.println("that : "+that +" -> t : "+t);
        this.defaultInitialState = that.defaultInitialState;
        this.transitionsListNode 
            = new TransitionsListNode(t, that.transitionsListNode);
        this.optimized = false;
        this.stateMachineTable = null;
      }

在这里 that是当前的StateMachineFactory对象,然后 t 是通过addTransition 新增的 转换函数&方法.  
看到这里,我们就可以发现主要操作就是更新transitionsListNode , that函数在赋值之后就没用了.

那么 new TransitionsListNode(t, that.transitionsListNode); 这句干了啥…

// 链表的数据结构 本次转换和下一个结点。
      private class TransitionsListNode { 
    
    
        // ApplicableSingleOrMultipleTransition 实现了该接口
        final ApplicableTransition<OPERAND, STATE, EVENTTYPE, EVENT> transition;
    
        final TransitionsListNode next;
    
        // 从构造函数中可以看出transition是当前状态转移对应的处理类，
        // next指向的是下一个TransitionsListNode，
    
    	// **********!!!!!!!! **********
    	// 注意这里的next 是上一节点的 StateMachineFactory实例的TransitionsListNode .
        // 所以这里的链表一直是倒叙添加的,不是顺序添加的!!!!!!!!!!
        // 后面会使用stack存储, 把数据正过来,然后再添加到stateMachineTable里面
        TransitionsListNode
            (ApplicableTransition<OPERAND, STATE, EVENTTYPE, EVENT> transition,
            TransitionsListNode next) { 
    
          this.transition = transition;
          // 此时的下一个TransitionsListNode其实是上一个StateMachineFactory中的TransitionListNode。
          this.next = next;
        }
      }

TransitionsListNode 是一个链表存储结构, 里面就两个属性,一个是transition . 即当前节点所具备的属性.next指向的是下一个TransitionsListNode, 即 通过addTransition函数新增的转换操作属性.

> new TransitionsListNode(t, that.transitionsListNode)

在这里我们要注意一下传参的顺序, 第一个参数为 addTransition新增的属性, 第二个是之前StateMachineFactory 中的transitionsListNode 属性. 所以这样的话, **最新的transitionsListNode和存入的顺序是反着来的.**

在执行installTopology方法会调用StateMachineFactory 的构造方法,在这里,我对数据做了一个输出.  
代码和输出数据如下:

// 私有构造方法 : no.2
      // 这个比较特殊: StateMachineFactory.installTopology() 方法调用 ==> optimized : true
      // addTransition内部创建StateMachineFactory对象。
      private StateMachineFactory(StateMachineFactory<OPERAND, STATE, EVENTTYPE, EVENT> that,  boolean optimized) { 
        this.defaultInitialState = that.defaultInitialState;
        this.transitionsListNode = that.transitionsListNode;
        this.optimized = optimized;
    
        //输出transitionsListNode中的结构
        getInfo(this.transitionsListNode);
    
        // 当optimized为true是，
        // 会在构造函数中调用makeStateMachineTable对stateMachineTable进行赋值。
        if (optimized) { 
          makeStateMachineTable();
        } else { 
          stateMachineTable = null;
        }
      }
      
      public void getInfo(TransitionsListNode transitionsListNode){ 
    
        if(null != transitionsListNode){ 
          ApplicableSingleOrMultipleTransition asmt = (ApplicableSingleOrMultipleTransition) transitionsListNode.transition;
          System.out.println(String.format("StateMachineFactory : preState : %s , eventType : %s , transition : %s ", asmt.preState,asmt.eventType,asmt.transition));
          TransitionsListNode next  = transitionsListNode.next ;
          if(null != next){ 
            getInfo(next);
          }
        }
      }

比如 对链表的数据做了一个输出 结果如下:.  
发现正好跟添加的顺序相反.

preState : SHUTDOWN ,  eventType : FINISHED_CONTAINERS_PULLED_BY_AM                                         , transition : org.apache.hadoop.yarn.state.StateMachineFactory$SingleInternalArc@6d42c226  
    preState : SHUTDOWN ,  eventType : RESOURCE_UPDATE                                         , transition : org.apache.hadoop.yarn.state.StateMachineFactory$SingleInternalArc@52cda68e  
    
    preState : UNHEALTHY ,  eventType : SHUTDOWN                                         , transition : org.apache.hadoop.yarn.state.StateMachineFactory$SingleInternalArc@16c4b017  
    preState : UNHEALTHY ,  eventType : SIGNAL_CONTAINER                                         , transition : org.apache.hadoop.yarn.state.StateMachineFactory$SingleInternalArc@5026145a  
    preState : UNHEALTHY ,  eventType : FINISHED_CONTAINERS_PULLED_BY_AM                                         , transition : org.apache.hadoop.yarn.state.StateMachineFactory$SingleInternalArc@2b0ebf8a  
    preState : UNHEALTHY ,  eventType : RESOURCE_UPDATE                                         , transition : org.apache.hadoop.yarn.state.StateMachineFactory$SingleInternalArc@144895b3  
    preState : UNHEALTHY ,  eventType : CLEANUP_CONTAINER                                         , transition : org.apache.hadoop.yarn.state.StateMachineFactory$SingleInternalArc@273fcb25  
    preState : UNHEALTHY ,  eventType : CLEANUP_APP                                         , transition : org.apache.hadoop.yarn.state.StateMachineFactory$SingleInternalArc@47db9f5c  
    preState : UNHEALTHY ,  eventType : RECONNECTED                                         , transition : org.apache.hadoop.yarn.state.StateMachineFactory$MultipleInternalArc@19779ac2  
    preState : UNHEALTHY ,  eventType : REBOOTING                                         , transition : org.apache.hadoop.yarn.state.StateMachineFactory$SingleInternalArc@49426152  
    preState : UNHEALTHY ,  eventType : EXPIRE                                         , transition : org.apache.hadoop.yarn.state.StateMachineFactory$SingleInternalArc@107dedbc  
    preState : UNHEALTHY ,  eventType : GRACEFUL_DECOMMISSION                                         , transition : org.apache.hadoop.yarn.state.StateMachineFactory$SingleInternalArc@b47b190  
    preState : UNHEALTHY ,  eventType : DECOMMISSION                                         , transition : org.apache.hadoop.yarn.state.StateMachineFactory$SingleInternalArc@2ec39bb0  
    preState : UNHEALTHY ,  eventType : STATUS_UPDATE                                         , transition : org.apache.hadoop.yarn.state.StateMachineFactory$MultipleInternalArc@74d127cb  
    
    preState : LOST ,  eventType : FINISHED_CONTAINERS_PULLED_BY_AM                                         , transition : org.apache.hadoop.yarn.state.StateMachineFactory$SingleInternalArc@b3e34e0  
    preState : LOST ,  eventType : RESOURCE_UPDATE                                         , transition : org.apache.hadoop.yarn.state.StateMachineFactory$SingleInternalArc@3dc3df26  
    
    preState : DECOMMISSIONING ,  eventType : RECONNECTED                                         , transition : org.apache.hadoop.yarn.state.StateMachineFactory$MultipleInternalArc@fefcd35  
    preState : DECOMMISSIONING ,  eventType : FINISHED_CONTAINERS_PULLED_BY_AM                                         , transition : org.apache.hadoop.yarn.state.StateMachineFactory$SingleInternalArc@72fd4c7c  
    preState : DECOMMISSIONING ,  eventType : CLEANUP_CONTAINER                                         , transition : org.apache.hadoop.yarn.state.StateMachineFactory$SingleInternalArc@81eeff7  
    preState : DECOMMISSIONING ,  eventType : SHUTDOWN                                         , transition : org.apache.hadoop.yarn.state.StateMachineFactory$SingleInternalArc@2b873b3d  
    preState : DECOMMISSIONING ,  eventType : CLEANUP_APP                                         , transition : org.apache.hadoop.yarn.state.StateMachineFactory$SingleInternalArc@5af0cd1d  
    preState : DECOMMISSIONING ,  eventType : FINISHED_CONTAINERS_PULLED_BY_AM                                         , transition : org.apache.hadoop.yarn.state.StateMachineFactory$SingleInternalArc@42f6f493  
    preState : DECOMMISSIONING ,  eventType : REBOOTING                                         , transition : org.apache.hadoop.yarn.state.StateMachineFactory$SingleInternalArc@3d68da6d  
    preState : DECOMMISSIONING ,  eventType : EXPIRE                                         , transition : org.apache.hadoop.yarn.state.StateMachineFactory$SingleInternalArc@2fa4502e  
    preState : DECOMMISSIONING ,  eventType : GRACEFUL_DECOMMISSION                                         , transition : org.apache.hadoop.yarn.state.StateMachineFactory$SingleInternalArc@73e0f8e2  
    preState : DECOMMISSIONING ,  eventType : STATUS_UPDATE                                         , transition : org.apache.hadoop.yarn.state.StateMachineFactory$MultipleInternalArc@6c7c861  
    preState : DECOMMISSIONING ,  eventType : RESOURCE_UPDATE                                         , transition : org.apache.hadoop.yarn.state.StateMachineFactory$SingleInternalArc@7d07c166  
    preState : DECOMMISSIONING ,  eventType : RECOMMISSION                                         , transition : org.apache.hadoop.yarn.state.StateMachineFactory$SingleInternalArc@70afcbc8  
    preState : DECOMMISSIONING ,  eventType : DECOMMISSION                                         , transition : org.apache.hadoop.yarn.state.StateMachineFactory$SingleInternalArc@4fc1ad7  
    preState : DECOMMISSIONED ,  eventType : FINISHED_CONTAINERS_PULLED_BY_AM                                         , transition : org.apache.hadoop.yarn.state.StateMachineFactory$SingleInternalArc@3c404ee9  
    preState : DECOMMISSIONED ,  eventType : RESOURCE_UPDATE                                         , transition : org.apache.hadoop.yarn.state.StateMachineFactory$SingleInternalArc@7f0fa4f6  
    
    preState : REBOOTED ,  eventType : RESOURCE_UPDATE                                         , transition : org.apache.hadoop.yarn.state.StateMachineFactory$SingleInternalArc@7170c154  
    
    preState : RUNNING ,  eventType : SHUTDOWN                                         , transition : org.apache.hadoop.yarn.state.StateMachineFactory$SingleInternalArc@153e470f  
    preState : RUNNING ,  eventType : SIGNAL_CONTAINER                                         , transition : org.apache.hadoop.yarn.state.StateMachineFactory$SingleInternalArc@2bb77447  
    preState : RUNNING ,  eventType : UPDATE_CONTAINER                                         , transition : org.apache.hadoop.yarn.state.StateMachineFactory$SingleInternalArc@291d5dd3  
    preState : RUNNING ,  eventType : RESOURCE_UPDATE                                         , transition : org.apache.hadoop.yarn.state.StateMachineFactory$SingleInternalArc@5e9043c5  
    preState : RUNNING ,  eventType : RECONNECTED                                         , transition : org.apache.hadoop.yarn.state.StateMachineFactory$MultipleInternalArc@39716127  
    preState : RUNNING ,  eventType : FINISHED_CONTAINERS_PULLED_BY_AM                                         , transition : org.apache.hadoop.yarn.state.StateMachineFactory$SingleInternalArc@29743f02  
    preState : RUNNING ,  eventType : CLEANUP_CONTAINER                                         , transition : org.apache.hadoop.yarn.state.StateMachineFactory$SingleInternalArc@6a440c3a  
    preState : RUNNING ,  eventType : CLEANUP_APP                                         , transition : org.apache.hadoop.yarn.state.StateMachineFactory$SingleInternalArc@3696f4dc  
    preState : RUNNING ,  eventType : REBOOTING                                         , transition : org.apache.hadoop.yarn.state.StateMachineFactory$SingleInternalArc@45cc370  
    preState : RUNNING ,  eventType : EXPIRE                                         , transition : org.apache.hadoop.yarn.state.StateMachineFactory$SingleInternalArc@c5860d6  
    preState : RUNNING ,  eventType : GRACEFUL_DECOMMISSION                                         , transition : org.apache.hadoop.yarn.state.StateMachineFactory$SingleInternalArc@46b788bb  
    preState : RUNNING ,  eventType : DECOMMISSION                                         , transition : org.apache.hadoop.yarn.state.StateMachineFactory$SingleInternalArc@4786a4a5  
    preState : RUNNING ,  eventType : STATUS_UPDATE                                         , transition : org.apache.hadoop.yarn.state.StateMachineFactory$MultipleInternalArc@2523a866  
    
    preState : NEW ,  eventType : FINISHED_CONTAINERS_PULLED_BY_AM                                         , transition : org.apache.hadoop.yarn.state.StateMachineFactory$SingleInternalArc@6a3232c4  
    preState : NEW ,  eventType : DECOMMISSION                                         , transition : org.apache.hadoop.yarn.state.StateMachineFactory$SingleInternalArc@103a8d69  
    preState : NEW ,  eventType : RESOURCE_UPDATE                                         , transition : org.apache.hadoop.yarn.state.StateMachineFactory$SingleInternalArc@62eba047  
    preState : NEW ,  eventType : STARTED                                         , transition : org.apache.hadoop.yarn.state.StateMachineFactory$SingleInternalArc@5a3354e4

# 四. stateMachineTable #

在使用在执行installTopology方法会调用StateMachineFactory 的构造方法 这时候会调用makeStateMachineTable 方法,对数据做一个处理. 放到stateMachineTable 表中.

private void makeStateMachineTable() { 
        // 声明一个stack数据结构，用来存储TransitionsListNode链中的TransitionsListNode
        // 之所以用stack，是因为TransitionsListNode链是按照状态转移的逆序排列的
        // 也就是说TransitionsListNode链中的第一个是状态转移中最后一个状态对应的ApplicableSingleOrMultipleTransition
        Stack<ApplicableTransition<OPERAND, STATE, EVENTTYPE, EVENT>> stack = new Stack<ApplicableTransition<OPERAND, STATE, EVENTTYPE, EVENT>>();
    
        Map<STATE, Map<EVENTTYPE, Transition<OPERAND, STATE, EVENTTYPE, EVENT>>>
          prototype = new HashMap<STATE, Map<EVENTTYPE, Transition<OPERAND, STATE, EVENTTYPE, EVENT>>>();
    
        prototype.put(defaultInitialState, null);
    
        // I use EnumMap here because it'll be faster and denser. I would
        // expect most of the states to have at least one transition.
        stateMachineTable
           = new EnumMap<STATE, Map<EVENTTYPE,
                               Transition<OPERAND, STATE, EVENTTYPE, EVENT>>>(prototype);
    
    
        // 将TransitionsListNode链中的ApplicableSingleOrMultipleTransition入stack
        for (TransitionsListNode cursor = transitionsListNode;
             cursor != null;
             cursor = cursor.next) { 
          stack.push(cursor.transition);
        }
    
        // 将ApplicableSingleOrMultipleTransition出stack，
        // 调用apply对stateMachineTable进行赋值
        while (!stack.isEmpty()) { 
          stack.pop().apply(this);
        }
      }

好了,到这里我们看一下stateMachineTable 里面的数据结构:

我改动了 StateMachineFactory 类的构造方法, 增加了输出操作

// 私有构造方法 : no.2
      // 这个比较特殊: StateMachineFactory.installTopology() 方法调用 ==> optimized : true
      // addTransition内部创建StateMachineFactory对象。
      private StateMachineFactory(StateMachineFactory<OPERAND, STATE, EVENTTYPE, EVENT> that,  boolean optimized) { 
        this.defaultInitialState = that.defaultInitialState;
        this.transitionsListNode = that.transitionsListNode;
        this.optimized = optimized;
    
        //输出transitionsListNode中的结构
        getInfo(this.transitionsListNode);
    
        // 当optimized为true是，
        // 会在构造函数中调用makeStateMachineTable对stateMachineTable进行赋值。
        if (optimized) { 
          makeStateMachineTable();
    
          if(stateMachineTable != null){ 
            for (STATE state:stateMachineTable.keySet()) { 
    
              System.out.println("--------------- "+state.name()+" start ---------------------------------");
    
              Map<EVENTTYPE,  Transition<OPERAND, STATE, EVENTTYPE, EVENT>> data = stateMachineTable.get(state);
    
              if(null != data){ 
                for (EVENTTYPE eventtype : data.keySet()) { 
                  System.out.println(String.format(" state : %s , eventtype : %s ",state.name(),eventtype));
                }
              }
    
              System.out.println("----------------"+state.name()+" end --------------------------------");
            }
          }
    
    
        } else { 
          stateMachineTable = null;
        }
      }

输出结构如下:

--------------- NEW start ---------------------------------
     state :  NEW , eventtype :  RESOURCE_UPDATE  
     state :  NEW , eventtype :  STARTED  
     state :  NEW , eventtype :  DECOMMISSION  
     state :  NEW , eventtype :  FINISHED_CONTAINERS_PULLED_BY_AM  
    ----------------NEW end --------------------------------
    --------------- RUNNING start ---------------------------------
     state :  RUNNING , eventtype :  CLEANUP_APP  
     state :  RUNNING , eventtype :  STATUS_UPDATE  
     state :  RUNNING , eventtype :  DECOMMISSION  
     state :  RUNNING , eventtype :  GRACEFUL_DECOMMISSION  
     state :  RUNNING , eventtype :  UPDATE_CONTAINER  
     state :  RUNNING , eventtype :  RECONNECTED  
     state :  RUNNING , eventtype :  RESOURCE_UPDATE  
     state :  RUNNING , eventtype :  SIGNAL_CONTAINER  
     state :  RUNNING , eventtype :  REBOOTING  
     state :  RUNNING , eventtype :  EXPIRE  
     state :  RUNNING , eventtype :  CLEANUP_CONTAINER  
     state :  RUNNING , eventtype :  FINISHED_CONTAINERS_PULLED_BY_AM  
     state :  RUNNING , eventtype :  SHUTDOWN  
    ----------------RUNNING end --------------------------------
    --------------- UNHEALTHY start ---------------------------------
     state :  UNHEALTHY , eventtype :  RECONNECTED  
     state :  UNHEALTHY , eventtype :  RESOURCE_UPDATE  
     state :  UNHEALTHY , eventtype :  CLEANUP_APP  
     state :  UNHEALTHY , eventtype :  SIGNAL_CONTAINER  
     state :  UNHEALTHY , eventtype :  STATUS_UPDATE  
     state :  UNHEALTHY , eventtype :  DECOMMISSION  
     state :  UNHEALTHY , eventtype :  GRACEFUL_DECOMMISSION  
     state :  UNHEALTHY , eventtype :  REBOOTING  
     state :  UNHEALTHY , eventtype :  EXPIRE  
     state :  UNHEALTHY , eventtype :  CLEANUP_CONTAINER  
     state :  UNHEALTHY , eventtype :  FINISHED_CONTAINERS_PULLED_BY_AM  
     state :  UNHEALTHY , eventtype :  SHUTDOWN  
    ----------------UNHEALTHY end --------------------------------
    --------------- DECOMMISSIONED start ---------------------------------
     state :  DECOMMISSIONED , eventtype :  RESOURCE_UPDATE  
     state :  DECOMMISSIONED , eventtype :  FINISHED_CONTAINERS_PULLED_BY_AM  
    ----------------DECOMMISSIONED end --------------------------------
    --------------- LOST start ---------------------------------
     state :  LOST , eventtype :  RESOURCE_UPDATE  
     state :  LOST , eventtype :  FINISHED_CONTAINERS_PULLED_BY_AM  
    ----------------LOST end --------------------------------
    --------------- REBOOTED start ---------------------------------
     state :  REBOOTED , eventtype :  RESOURCE_UPDATE  
    ----------------REBOOTED end --------------------------------
    --------------- DECOMMISSIONING start ---------------------------------
     state :  DECOMMISSIONING , eventtype :  RESOURCE_UPDATE  
     state :  DECOMMISSIONING , eventtype :  RECONNECTED  
     state :  DECOMMISSIONING , eventtype :  CLEANUP_APP  
     state :  DECOMMISSIONING , eventtype :  STATUS_UPDATE  
     state :  DECOMMISSIONING , eventtype :  DECOMMISSION  
     state :  DECOMMISSIONING , eventtype :  GRACEFUL_DECOMMISSION  
     state :  DECOMMISSIONING , eventtype :  REBOOTING  
     state :  DECOMMISSIONING , eventtype :  RECOMMISSION  
     state :  DECOMMISSIONING , eventtype :  EXPIRE  
     state :  DECOMMISSIONING , eventtype :  FINISHED_CONTAINERS_PULLED_BY_AM  
     state :  DECOMMISSIONING , eventtype :  CLEANUP_CONTAINER  
     state :  DECOMMISSIONING , eventtype :  SHUTDOWN  
    ----------------DECOMMISSIONING end --------------------------------
    --------------- SHUTDOWN start ---------------------------------
     state :  SHUTDOWN , eventtype :  RESOURCE_UPDATE  
     state :  SHUTDOWN , eventtype :  FINISHED_CONTAINERS_PULLED_BY_AM  
    ----------------SHUTDOWN end --------------------------------

# 五. InternalStateMachine 构造状态机 #

在RMNodeImpl的构造方法里面,调用.构造InternalStateMachine实现类, 注意, 这里的参数 **this**,传入的是当前RMNodeImpl 的实例…

*  this.stateMachine = stateMachineFactory.make(**this**);

通过stateMachineFactory\#make方法构建.

/* * @return a {@link StateMachine} that starts in the default initial * state and whose {@link Transition} s are applied to * {@code operand} . * * This is part of the API. * * @param operand the object upon which the returned * {@link StateMachine} will operate. * */
      public StateMachine<STATE, EVENTTYPE, EVENT> make(OPERAND operand) { 
        return new InternalStateMachine(operand, defaultInitialState);
      }
    
       InternalStateMachine(OPERAND operand, STATE initialState,
           StateTransitionListener<OPERAND, EVENT, STATE> transitionListener) { 
         this.operand = operand;
         this.currentState = initialState;
         this.listener =
             (transitionListener == null) ? NOOP_LISTENER : transitionListener;
         if (!optimized) { 
           maybeMakeStateMachineTable();
         }
       }

# 六. stateMachine.doTransition(event.getType(), event); #

@Override
        public synchronized STATE doTransition(EVENTTYPE eventType, EVENT event)
             throws InvalidStateTransitionException  { 
    
          //监听 处理数据
          listener.preTransition(operand, currentState, event);
    
          STATE oldState = currentState;
    
          // 从stateMachineTable中得到当前state和eventType对应的transition，
          // 然后调用transition.doTransition方法，
          // 调用eventType对应的hook去执行相关逻辑。
          currentState = StateMachineFactory.this.doTransition
              (operand, currentState, eventType, event);
          listener.postTransition(operand, oldState, currentState, event);
          return currentState;
        }

使用StateMachineFactory\#doTransition从transitionMap汇总获取对应的Transition, 执行doTransition方法进行具体的操作.

/** * Effect a transition due to the effecting stimulus. * @param oldState current state * @param eventType trigger to initiate the transition * @param event causal eventType context * @return transitioned state */
      private STATE doTransition (OPERAND operand, STATE oldState, EVENTTYPE eventType, EVENT event)  throws InvalidStateTransitionException { 
        // We can assume that stateMachineTable is non-null because we call
        // maybeMakeStateMachineTable() when we build an InnerStateMachine ,
        // and this code only gets called from inside a working InnerStateMachine .
        Map<EVENTTYPE, Transition<OPERAND, STATE, EVENTTYPE, EVENT>> transitionMap = stateMachineTable.get(oldState);
        if (transitionMap != null) { 
          Transition<OPERAND, STATE, EVENTTYPE, EVENT> transition = transitionMap.get(eventType);
          if (transition != null) { 
            return transition.doTransition(operand, oldState, event, eventType);
          }
        }
        throw new InvalidStateTransitionException(oldState, eventType);
      }

到这里StateMachineFactory就分析完了…

有什么不正确的地方欢迎纠正,不胜感激…

[RMNodeImpl]: /images/20221120/cfb1acc783944490a3a8cbf8440b7e24.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3poYW5nbG9uZ180NDQ0_size_16_color_FFFFFF_t_70]: /images/20221120/00ee5a61018c414a804ce84879f8ba97.png