Codis源码解析——处理slot操作（1）

上一篇我们讲了slot在集群中的分配方式，重点讲了auto-rebalance的原理。之前我们说过，再启动dashboard的时候，有一个goroutine专门用来处理slot的操作。这一篇我们就来看看slot的操作是如何进行的。我们这里举例也是用集群中有两个group和1024个从未分配的slot。

首先复习一下，在slot还处于未分配状态的时候，上下文中的1024个SlotMapping如下所示。后面就是以SlotMapping为单位进行处理，所以这里一定要对其结构掌握清楚

接下来，当我们使用auto-rebalance对集群进行处理后，每个slot都被指定了相应的迁移计划

func (s *Topom) ProcessSlotAction() error {
    for s.IsOnline() {
        var (
            marks = make(map[int]bool)
            //分配slot的时候点击弹窗的confirm之后，这个plans才能取出值
            plans = make(map[int]bool)
        )
        var accept = func(m *models.SlotMapping) bool {
            if marks[m.GroupId] || marks[m.Action.TargetId] {
                return false
            }
            if plans[m.Id] {
                return false
            }
            return true
        }
        //对plans和marks进行初始化
        var update = func(m *models.SlotMapping) bool {
            //只有在槽当前的GroupId为0的时候，marks[m.GroupId]才是false
            if m.GroupId != 0 {
                marks[m.GroupId] = true
            }
            marks[m.Action.TargetId] = true
            plans[m.Id] = true
            return true
        }
        //按照默认的配置文件，这个值是100，并行迁移的slot数量，是一个阀值
        var parallel = math2.MaxInt(1, s.config.MigrationParallelSlots)
        //第一次的时候plans为空，所以下面的方法一定会执行一次，这个过程中plans会初始化。后面如果plans的长度大于100，就直接对所有plans做处理；
        //否则如果集群中所有Slotmapping中Action.state最小的那个Slotmapping如果处于pending，preparing或者prepared，也可以跳出循环对plans进行处理
        for parallel > len(plans) {
            //对是否满足plans的处理情况做过滤，后面会讲这个方法
            _, ok, err := s.SlotActionPrepareFilter(accept, update)
            if err != nil {
                return err
            } else if !ok {
                break
            }
        }
        //在指定slot的分配plan之前，这个一直是return nil
        if len(plans) == 0 {
            return nil
        }
        var fut sync2.Future
        //从plans中取出具体的每个slot的迁移计划，前面我们已经说过，plans的键是每一个slot的id，值是要迁移到的groupId
        for sid, _ := range plans {
            fut.Add()
            go func(sid int) {
                log.Warnf("slot-[%d] process action", sid)
                //针对每个slot做处理
                var err = s.processSlotAction(sid)
                if err != nil {
                    status := fmt.Sprintf("[ERROR] Slot[%04d]: %s", sid, err)
                    s.action.progress.status.Store(status)
                } else {
                    s.action.progress.status.Store("")
                }
                //在Future的vmap中存储slotId和对应的error，并调用WaitGroup.Done
                fut.Done(strconv.Itoa(sid), err)
            }(sid)
        }
        //当所有slot操作结束之后，遍历Future的vmap，取出有error的并返回
        for _, v := range fut.Wait() {
            if v != nil {
                return v.(error)
            }
        }
        time.Sleep(time.Millisecond * 10)
    }
    return nil
}

一个slot共有七种状态，分别是：
nothing（用空字符串表示）、pending、preparing、prepared、migrating、finished、syncing

在看每个slot具体的操作之前，可以先看一下SlotActionPrepareFilter这个方法。

func (s *Topom) SlotActionPrepareFilter(accept, update func(m *models.SlotMapping) bool) (int, bool, error) {
    s.mu.Lock()
    defer s.mu.Unlock()
    //加载上下文
    ctx, err := s.newContext()
    if err != nil {
        return 0, false, err
    }

    //找到所有Action.State既不为空也不是pending的SlotMapping中Action.Index最小的SlotMapping
    var minActionIndex = func(filter func(m *models.SlotMapping) bool) (picked *models.SlotMapping) {
        for _, m := range ctx.slots {
            if m.Action.State == models.ActionNothing {
                continue
            }
            if filter(m) {
                if picked != nil && picked.Action.Index < m.Action.Index {
                    continue
                }
                //只有一个slot没有执行过update方法，accept才会返回true；也就是说，一个slot只会被处理一次
                if accept == nil || accept(m) {
                    picked = m
                }
            }
        }
        return picked
    }

    var m = func() *models.SlotMapping {
        var picked = minActionIndex(func(m *models.SlotMapping) bool {
            return m.Action.State != models.ActionPending
        })
        if picked != nil {
            return picked
        }
        if s.action.disabled.IsTrue() {
            return nil
        }
        //如果前面找不到Action.State既不为空也不是pending的SlotMapping中Action.Index最小的SlotMapping
        //就去找Action.State为pending的SlotMapping中Action.Index最小的SlotMapping
        return minActionIndex(func(m *models.SlotMapping) bool {
            return m.Action.State == models.ActionPending
        })
    }()

    if m == nil {
        return 0, false, nil
    }

    if update != nil && !update(m) {
        return 0, false, nil
    }

    log.Warnf("slot-[%d] action prepare:\n%s", m.Id, m.Encode())

    //变更每个SlotMapping的action.state，并与zk交互
    //另外，Action.state符合preparing或者prepared的时候，要根据SlotMapping的参数同步到Slot
    switch m.Action.State {

    case models.ActionPending:

        defer s.dirtySlotsCache(m.Id)

        //Action.State指向下一阶段
        m.Action.State = models.ActionPreparing
        //只是更新zk
        if err := s.storeUpdateSlotMapping(m); err != nil {
            return 0, false, err
        }

        fallthrough

    case models.ActionPreparing:

        defer s.dirtySlotsCache(m.Id)

        log.Warnf("slot-[%d] resync to prepared", m.Id)

        m.Action.State = models.ActionPrepared
        //同步SlotMapping操作，后面会有介绍
        if err := s.resyncSlotMappings(ctx, m); err != nil {
            log.Warnf("slot-[%d] resync-rollback to preparing", m.Id)
            m.Action.State = models.ActionPreparing
            s.resyncSlotMappings(ctx, m)
            log.Warnf("slot-[%d] resync-rollback to preparing, done", m.Id)
            return 0, false, err
        }
        if err := s.storeUpdateSlotMapping(m); err != nil {
            return 0, false, err
        }

        fallthrough

    case models.ActionPrepared:

        defer s.dirtySlotsCache(m.Id)

        log.Warnf("slot-[%d] resync to migrating", m.Id)

        m.Action.State = models.ActionMigrating
        if err := s.resyncSlotMappings(ctx, m); err != nil {
            log.Warnf("slot-[%d] resync to migrating failed", m.Id)
            return 0, false, err
        }
        if err := s.storeUpdateSlotMapping(m); err != nil {
            return 0, false, err
        }

        fallthrough

    case models.ActionMigrating:

        return m.Id, true, nil

    case models.ActionFinished:

        return m.Id, true, nil

    //如果不属于以上任何一种情况，直接返回invalid
    default:

        return 0, false, errors.Errorf("slot-[%d] action state is invalid", m.Id)

    }
}

很显然，上面的方法取出的最小的Action.State的Slotmapping是

当一个SlotMapping处于preparing和prepared转台的时候，会将其状态推进到下一阶段，并同步SlotMapping，根据[]*models.SlotMapping创建1024个models.Slot，再填充1024个pkg/proxy/slots.go中的Slot，此过程中Router为每个Slot都分配了对应的backendConn。下面就来看看这个同步方法。

func (s *Topom) resyncSlotMappings(ctx *context, slots ...*models.SlotMapping) error {
    if len(slots) == 0 {
        return nil
    }
    var fut sync2.Future
    for _, p := range ctx.proxy {
        fut.Add()
        go func(p *models.Proxy) {
            //ApiClient中存储了proxy的address以及xauth信息。其中xauth是根据ProductName，ProductAuth以及proxy的token生成的
            err := s.newProxyClient(p).FillSlots(ctx.toSlotSlice(slots, p)...)
            if err != nil {
                log.ErrorErrorf(err, "proxy-[%s] resync slots failed", p.Token)
            }
            fut.Done(p.Token, err)
        }(p)
    }
    for t, v := range fut.Wait() {
        switch err := v.(type) {
        case error:
            if err != nil {
                return errors.Errorf("proxy-[%s] resync slots failed", t)
            }
        }
    }
    return nil
}

同步的过程中有两个方法比较复杂，分别是FillSlots和toSlotSlice。这一节我们先来看toSlotSlice。这个方法实际上就是将SlotMapping切片转化为Slot切片，在Slot结构体重记录了这个Slot在迁移的不同阶段，接到的请求由哪个BackendAddr进行处理。

type Slot struct {
    Id     int  `json:"id"`
    Locked bool `json:"locked,omitempty"`

    BackendAddr        string `json:"backend_addr,omitempty"`
    BackendAddrGroupId int    `json:"backend_addr_group_id,omitempty"`
    MigrateFrom        string `json:"migrate_from,omitempty"`
    MigrateFromGroupId int    `json:"migrate_from_group_id,omitempty"`

    ForwardMethod int `json:"forward_method,omitempty"`

    ReplicaGroups [][]string `json:"replica_groups,omitempty"`
}

func (ctx *context) toSlotSlice(slots []*models.SlotMapping, p *models.Proxy) []*models.Slot {
    var slice = make([]*models.Slot, len(slots))
    for i, m := range slots {
        slice[i] = ctx.toSlot(m, p)
    }
    return slice
}
func (ctx *context) toSlot(m *models.SlotMapping, p *models.Proxy) *models.Slot {
    slot := &models.Slot{
        Id:     m.Id,
        Locked: ctx.isSlotLocked(m),

        ForwardMethod: ctx.method,
    }
    switch m.Action.State {
    case models.ActionNothing, models.ActionPending:
        //这个getGroupMaster实际上就是从每个Group中取出第一台，因为codis中认定group中添加的第一台是主服务器
        slot.BackendAddr = ctx.getGroupMaster(m.GroupId)
        slot.BackendAddrGroupId = m.GroupId
        slot.ReplicaGroups = ctx.toReplicaGroups(m.GroupId, p)
    case models.ActionPreparing:
        slot.BackendAddr = ctx.getGroupMaster(m.GroupId)
        slot.BackendAddrGroupId = m.GroupId
    case models.ActionPrepared:
        fallthrough
    case models.ActionMigrating:
        slot.BackendAddr = ctx.getGroupMaster(m.Action.TargetId)
        slot.BackendAddrGroupId = m.Action.TargetId
        slot.MigrateFrom = ctx.getGroupMaster(m.GroupId)
        slot.MigrateFromGroupId = m.GroupId
    case models.ActionFinished:
        slot.BackendAddr = ctx.getGroupMaster(m.Action.TargetId)
        slot.BackendAddrGroupId = m.Action.TargetId
    default:
        log.Panicf("slot-[%d] action state is invalid:\n%s", m.Id, m.Encode())
    }
    return slot
}

其中如果slot处于migrating状态，migrate.bc就不为空，如果恰好有请求发到这个slot，proxy就会执行一次SLOTSMGRTTAGONE让这个slot迁移完成，再由其backend.bc来执行请求

下面的ReplicaGroups是专门为了主从读写分离设置的。从优先级我们可以看到，读请求会优先转发到和proxy在一台服务器上的codis-server，也就是优先级最高的0

func (ctx *context) toReplicaGroups(gid int, p *models.Proxy) [][]string {
    g := ctx.group[gid]
    switch {
    case g == nil:
        return nil
    case g.Promoting.State != models.ActionNothing:
        return nil
    case len(g.Servers) <= 1:
        return nil
    }
    var dc string
    var ip net.IP
    if p != nil {
        dc = p.DataCenter
        ip = ctx.lookupIPAddr(p.AdminAddr)
    }
    //replica的访问优先级
    getPriority := func(s *models.GroupServer) int {
        if ip == nil || dc != s.DataCenter {
            return 2
        }
        if ip.Equal(ctx.lookupIPAddr(s.Addr)) {
            return 0
        } else {
            return 1
        }
    }
    var groups [3][]string
    for _, s := range g.Servers {
        if s.ReplicaGroup {
            p := getPriority(s)
            groups[p] = append(groups[p], s.Addr)
        }
    }
    var replicas [][]string
    for _, l := range groups {
        if len(l) != 0 {
            replicas = append(replicas, l)
        }
    }
    return replicas
}

有关于FillSlot和每个槽的处理方法processSlotAction，我们会在下一篇讲

说明
如有转载，请注明出处
http://blog.csdn.net/antony9118/article/details/77170020