Harbor 源码分析之状态机（五）

Harbor里面有很多job，譬如镜像同步，这些job有很多状态，应为job这执行过程中会有很多任务，在每种任务下面会有不同的任务状态，状态之前可以切换并触发动作，这个就是状态机，如果对Hadoop中的YARN调度熟悉可能知道，YARN里面就是通过状态机完成任务的管理和状态切换。下面介绍一下状态机

type SM struct {
    JobID         int64
    CurrentState  string
    PreviousState string
    //The states that don't have to exist in transition map, such as "Error", "Canceled"
    ForcedStates map[string]struct{}
    Transitions  map[string]map[string]struct{}
    Handlers     map[string]StateHandler
    desiredState string
    Logger       *log.Logger
    Parms        *RepJobParm
    lock         *sync.Mutex
}

那么这个状态机状态怎么转换呢？要看看Transitions他是一个二层的map。

func (sm *SM) AddTransition(from string, to string, h StateHandler) {
    _, ok := sm.Transitions[from]
    if !ok {
        sm.Transitions[from] = make(map[string]struct{})
    }
    sm.Transitions[from][to] = struct{}{}
    sm.Handlers[to] = h
}

AddTransition添加过渡，从from状态到to状态切换，执行StateHandler的动作。

func (sm *SM) RemoveTransition(from string, to string) {
    _, ok := sm.Transitions[from]
    if !ok {
        return
    }
    delete(sm.Transitions[from], to)
}

删除简单就不介绍了。
当状态机启动的时候

func (sm *SM) Start(s string) {
    n, err := sm.EnterState(s)
    log.Debugf("Job id: %d, next state from handler: %s", sm.JobID, n)
    for len(n) > 0 && err == nil {
        if d := sm.getDesiredState(); len(d) > 0 {
            log.Debugf("Job id: %d. Desired state: %s, will ignore the next state from handler", sm.JobID, d)
            n = d
            sm.setDesiredState("")
            continue
        }
        if n == models.JobContinue && len(sm.Transitions[sm.CurrentState]) == 1 {
            for n = range sm.Transitions[sm.CurrentState] {
                break
            }
            log.Debugf("Job id: %d, Continue to state: %s", sm.JobID, n)
            continue
        }
        if n == models.JobContinue && len(sm.Transitions[sm.CurrentState]) != 1 {
            log.Errorf("Job id: %d, next state is continue but there are %d possible next states in transition table", sm.JobID, len(sm.Transitions[sm.CurrentState]))
            err = fmt.Errorf("Unable to continue")
            break
        }
        n, err = sm.EnterState(n)
        log.Debugf("Job id: %d, next state from handler: %s", sm.JobID, n)
    }
    if err != nil {
        log.Warningf("Job id: %d, the statemachin will enter error state due to error: %v", sm.JobID, err)
        sm.EnterState(models.JobError)
    }
}

Start传入的目标状态，上一篇启动镜像复制的时候就是传入JobRunning状态。Start先调用EnterState进入状态，

func (sm *SM) EnterState(s string) (string, error) {
    log.Debugf("Job id: %d, transiting from State: %s, to State: %s", sm.JobID, sm.CurrentState, s)
    targets, ok := sm.Transitions[sm.CurrentState]
    _, exist := targets[s]
    _, isForced := sm.ForcedStates[s]
    if !exist && !isForced {
        return "", fmt.Errorf("job id: %d, transition from %s to %s does not exist", sm.JobID, sm.CurrentState, s)
    }
    exitHandler, ok := sm.Handlers[sm.CurrentState]
    if ok {
        if err := exitHandler.Exit(); err != nil {
            return "", err
        }
    } else {
        log.Debugf("Job id: %d, no handler found for state:%s, skip", sm.JobID, sm.CurrentState)
    }
    enterHandler, ok := sm.Handlers[s]
    var next = models.JobContinue
    var err error
    if ok {
        if next, err = enterHandler.Enter(); err != nil {
            return "", err
        }
    } else {
        log.Debugf("Job id: %d, no handler found for state:%s, skip", sm.JobID, s)
    }
    sm.PreviousState = sm.CurrentState
    sm.CurrentState = s
    log.Debugf("Job id: %d, transition succeeded, current state: %s", sm.JobID, s)
    return next, nil
}

这里先判断这个transition是否存在，如果不存在报错，然后判断Handler是否存在，如果存在就调用enterHandler.Enter()，调用完成返回下一个状态next，最后把当前状态修改成传入的目标状态。
接着说Start方法，返回next后，任务会接着从next往下走，再次调用EnterState往下，直到for循环结束或者是JobContinue状态将退出。
停止就简单了

func (sm *SM) Stop(id int64) {
    log.Debugf("Trying to stop the job: %d", id)
    sm.lock.Lock()
    defer sm.lock.Unlock()
    if id == sm.JobID {
        sm.desiredState = models.JobStopped
        log.Debugf("Desired state of job %d is set to stopped", id)
    } else {
        log.Debugf("State machine has switched to job %d, so the action to stop job %d will be ignored", sm.JobID, id)
    }
}

直接将目标状态修改成JobStopped。这样就能结束任务，并把work放回到workerpool。
下面我就针对镜像同步为例分析一下

sm.AddTransition(models.JobPending, models.JobRunning, StatusUpdater{sm.JobID, models.JobRunning})
sm.AddTransition(models.JobRetrying, models.JobRunning, StatusUpdater{sm.JobID, models.JobRunning})

sm.AddTransition(models.JobRunning, replication.StateInitialize, &replication.Initializer{BaseHandler: base})
sm.AddTransition(replication.StateInitialize, replication.StateCheck, &replication.Checker{BaseHandler: base})
sm.AddTransition(replication.StateCheck, replication.StatePullManifest, &replication.ManifestPuller{BaseHandler: base})
sm.AddTransition(replication.StatePullManifest, replication.StateTransferBlob, &replication.BlobTransfer{BaseHandler: base})
sm.AddTransition(replication.StatePullManifest, models.JobFinished, &StatusUpdater{sm.JobID, models.JobFinished})
sm.AddTransition(replication.StateTransferBlob, replication.StatePushManifest, &replication.ManifestPusher{BaseHandler: base})
sm.AddTransition(replication.StatePushManifest, replication.StatePullManifest, &replication.ManifestPuller{BaseHandler: base})

上面截取过渡机，当把任务启动后，由于初始状态为JobPending将进入JobRunning

1. JobPending->JobRunning 此时将任务状态改成JobRunning，返回JobContinue，JobContinue是让job直行到下一个状态！

 func (su StatusUpdater) Enter() (string, error) {
    err := dao.UpdateRepJobStatus(su.JobID, su.State)
    if err != nil {
        log.Warningf("Failed to update state of job: %d, state: %s, error: %v", su.JobID, su.State, err)
    }
    var next = models.JobContinue
    if su.State == models.JobStopped || su.State == models.JobError || su.State == models.JobFinished {
        next = ""
    }
    return next, err
}

1. JobRunning->StateInitialize 创建客户端
2. StateInitialize->StateCheck 检查本地project创建远端project
3. StateCheck->StatePullManifest 获取mainfest，和远端比较分析需要同步的层
4. StatePullManifest->StateTransferBlob 传输分层
5. StateTransferBlob->StatePushManifest 推送manifest到远端
6. StatePushManifest->StatePullManifest 然后又获取manifest比较一直重复下去
7. StatePullManifest->JobFinished 这个是没有需要同步的镜像的时候停止运行。
   这样就把这个镜像推送整个过程完成了。