聊聊dbsync的jobs

codecraft

本文主要研究一下dbsync的jobs

Job

//Job represents db sync job
type Job struct {
    ID        string
    Error     string
    Status    string
    Progress  Progress
    Items     []*Transferable
    Chunked   bool
    mutex     *sync.Mutex
    StartTime time.Time
    EndTime   *time.Time
}

//NewJob creates a new job
func NewJob(id string) *Job {
    return &Job{
        ID:        id,
        StartTime: time.Now(),
        mutex:     &sync.Mutex{},
        Items:     make([]*Transferable, 0),
    }
}
Job方法定义了ID、Error、Status、Progress、Items、Chunked、mutex、StartTime、EndTime

Update

//Update updates job progress
func (j *Job) Update() {
    if len(j.Items) == 0 {
        return
    }
    sourceCount := 0
    destCount := 0
    transferred := 0
    for i := range j.Items {
        if j.Items[i].Status == nil {
            continue
        }
        sourceCount += j.Items[i].Source.Count()
        destCount += j.Items[i].Dest.Count()
        transferred += int(atomic.LoadUint32(&j.Items[i].Transferred))

    }
    j.Progress.Transferred = transferred
    j.Progress.SourceCount = sourceCount
    j.Progress.DestCount = destCount
    if sourceCount > 0 {
        j.Progress.Pct = transferred / sourceCount
    }
}
Update方法遍历Items,统计transferred、sourceCount、destCount

Done

//Done flag job as done
func (j *Job) Done(now time.Time) {
    if j.Status != shared.StatusError {
        j.Status = shared.StatusDone
    }
    j.EndTime = &now
}
Done方法更新Status和EndTime

Add

//Add add transferable
func (j *Job) Add(transferable *Transferable) {
    j.mutex.Lock()
    defer j.mutex.Unlock()
    j.Items = append(j.Items, transferable)
}
Add方法往transferable添加Items

IsRunning

//IsRunning returns true if jos has running status
func (j *Job) IsRunning() bool {
    return j.Status == shared.StatusRunning || j.EndTime == nil
}
IsRunning方法通过status和EndTime来判断是否是running

Service

//Service represents a job service
type Service interface {
    //List lists all active or recently active jobs
    List(request *ListRequest) *ListResponse
    //Create creates a new job
    Create(ID string) *core.Job
    //Get returns a job for supplied ID or nil
    Get(ID string) *core.Job
}

type service struct {
    registry *registry
}

//New create a job service
func New() Service {
    return &service{
        registry: newRegistry(),
    }
}
Service接口定义了List、Create、Get

Get

//Get returns job by ID or nil
func (s *service) Get(ID string) *core.Job {
    jobs := s.registry.list()
    for i := range jobs {
        if jobs[i].ID == ID {
            jobs[i].Update()
            return jobs[i]
        }
    }
    return nil

}
Get方法先执行registry.list(),然后遍历list找到ID对应的job,然后执行Update

List

//List lists all jobs
func (s *service) List(request *ListRequest) *ListResponse {
    jobs := s.registry.list()
    if len(request.IDs) == 0 {
        return &ListResponse{
            Jobs: jobs,
        }
    }
    var requestedIDs = make(map[string]bool)
    for i := range request.IDs {
        requestedIDs[request.IDs[i]] = true
    }
    var filtered = make([]*core.Job, 0)
    for i := range jobs {
        if _, has := requestedIDs[jobs[i].ID]; !has {
            continue
        }
        jobs[i].Update()
        filtered = append(filtered, jobs[i])
    }
    return &ListResponse{
        Jobs: filtered,
    }
}
List方法先执行registry.list(),之后根据requestedIDs找出对应的job,执行Update,最后返回

Create

//Create creates a new job
func (s *service) Create(ID string) *core.Job {
    job := core.NewJob(ID)
    s.registry.add(job)
    return job
}
Create方法通过core.NewJob(ID)创建job,然后执行registry.add(job)

小结

dbsync的Schedulable定义了URL、ID、*contract.Sync、Schedule、Status、status属性,它提供了Clone、Done、IsRunning、ScheduleNexRun、Init、Validate方法。

doc

阅读 167

code-craft
spring boot , docker and so on 欢迎关注微信公众号: geek_luandun

当一个代码的工匠回首往事时,不因虚度年华而悔恨,也不因碌碌无为而羞愧,这样,当他老的时候,可以很自豪告诉世人,我曾经将代码注入生命去打造互联网的浪潮之巅,那是个很疯狂的时代,我在一波波的浪潮上留下了或重如泰山或轻如鸿毛的几笔。

11.5k 声望
1.9k 粉丝
0 条评论
你知道吗?

当一个代码的工匠回首往事时,不因虚度年华而悔恨,也不因碌碌无为而羞愧,这样,当他老的时候,可以很自豪告诉世人,我曾经将代码注入生命去打造互联网的浪潮之巅,那是个很疯狂的时代,我在一波波的浪潮上留下了或重如泰山或轻如鸿毛的几笔。

11.5k 声望
1.9k 粉丝
宣传栏