Codis源码解析——sharedBackendConn

在Codis源码解析——proxy监听redis请求一篇中，我们介绍过，SharedBackendConn负责实际对redis请求进行处理。

上一篇，在fillslot的过程中通过codis-server地址获取SharedBackendConn是这样用的

slot.backend.bc = s.pool.primary.Retain(addr)

为了弄清这个方法的实现，首先我们要搞清楚，基本原理是，从proxy中获取Router，然后Router的pool属性中取出属性名为primary 的sharedBackendConnPool，而这个sharedBackendConnPool又有一个map，键为codis-server的addr，值为sharedBackendConn。这个过程中涉及到的struct如下所示，它们处在不同的类中。

type Router struct {
    mu sync.RWMutex

    pool struct {
        primary *sharedBackendConnPool
        replica *sharedBackendConnPool
    }
    slots [MaxSlotNum]Slot

    config *Config
    online bool
    closed bool
}
type sharedBackendConnPool struct {
    //从启动配置文件参数封装的config
    config   *Config
    parallel int

    pool map[string]*sharedBackendConn
}
type sharedBackendConn struct {
    addr string
    host []byte
    port []byte

    //所属的池
    owner *sharedBackendConnPool
    conns [][]*BackendConn
    single []*BackendConn

    //当前sharedBackendConn的引用计数，非正数的时候表明关闭。每多一个引用就加一
    refcnt int
}
type BackendConn struct {
    stop sync.Once
    addr string

    //buffer为1024的channel
    input chan *Request
    retry struct {
        fails int
        delay Delay
    }
    state atomic2.Int64

    closed atomic2.Bool
    config *Config

    database int
}

好，搞清上面的结构之后，我们来看Retain的具体实现方法。这个方法在/pkg/proxy/backend.go中。我们以id为0的slot为例，现在从offline状态迁移到group1中。addr是group1的master的地址，即”10.0.2.15:6379”

func (p *sharedBackendConnPool) Retain(addr string) *sharedBackendConn {
    //首先从pool中直接取，取的到的话，引用计数加一
    if bc := p.pool[addr]; bc != nil {
        return bc.Retain()
    } else {
        //取不到就新建，然后放到pool里面
        bc = newSharedBackendConn(addr, p)
        p.pool[addr] = bc
        return bc
    }
}
func (s *sharedBackendConn) Retain() *sharedBackendConn {
    if s == nil {
        return nil
    }
    if s.refcnt <= 0 {
        log.Panicf("shared backend conn has been closed")
    } else {
        s.refcnt++
    }
    return s
}

如果没有从Router.pool.primary中取到，就调用newSharedBackendConn新建，然后放到primary中

func newSharedBackendConn(addr string, pool *sharedBackendConnPool) *sharedBackendConn {
    //拆分ip和端口号
    host, port, err := net.SplitHostPort(addr)
    if err != nil {
        log.ErrorErrorf(err, "split host-port failed, address = %s", addr)
    }
    s := &sharedBackendConn{
        addr: addr,
        host: []byte(host), port: []byte(port),
    }
    //确认新建的sharedBackendConn所属于的pool
    s.owner = pool
    //len和cap都默认为16的二维切片
    s.conns = make([][]*BackendConn, pool.config.BackendNumberDatabases)
    //range用一个参数遍历二维切片，datebase是0到15
    for database := range s.conns {
        //len和cap都默认为1的一维切片
        parallel := make([]*BackendConn, pool.parallel)
        //只有parallel[0]
        for i := range parallel {
            parallel[i] = NewBackendConn(addr, database, pool.config)
        }
        s.conns[database] = parallel
    }
    if pool.parallel == 1 {
        s.single = make([]*BackendConn, len(s.conns))
        for database := range s.conns {
            s.single[database] = s.conns[database][0]
        }
    }
    //新建之后，这个SharedBackendConn的引用次数就置为1
    s.refcnt = 1
    return s
}
func NewBackendConn(addr string, database int, config *Config) *BackendConn {
    bc := &BackendConn{
        addr: addr, config: config, database: database,
    }
    bc.input = make(chan *Request, 1024)
    bc.retry.delay = &DelayExp2{
        Min: 50, Max: 5000,
        Unit: time.Millisecond,
    }

    go bc.run()

    return bc
}

到这里，sharedBackendConn新建完成，结构如下所示，其中owner的config就是从启动配置文件中独出的config

conns结构如下，database属性从0到15不等

single结构如下，config是从启动配置文件中读出的配置，database也是从0到15。是conns这个二维切片每一列的第一个。

还有注意上面在NewBackendConn的时候启动了一个goroutine。下面我们重点看看这个goroutine做了什么事。

func (bc *BackendConn) run() {
    log.Warnf("backend conn [%p] to %s, db-%d start service",
        bc, bc.addr, bc.database)
    for round := 0; bc.closed.IsFalse(); round++ {
        log.Warnf("backend conn [%p] to %s, db-%d round-[%d]",
            bc, bc.addr, bc.database, round)
        if err := bc.loopWriter(round); err != nil {
            bc.delayBeforeRetry()
        }
    }
    log.Warnf("backend conn [%p] to %s, db-%d stop and exit",
        bc, bc.addr, bc.database)
}

在执行这个goroutine的过程中，控制台会循环打印两三次某个db开始服务。

backend.go:258: [WARN] backend conn [0xc42005ef60] to 127.0.0.1:6379, db-0 start service
backend.go:261: [WARN] backend conn [0xc42005ef60] to 127.0.0.1:6379, db-0 round-[0]
backend.go:334: [WARN] backend conn [0xc42005ef60] to 127.0.0.1:6379, db-0 writer-[0] exit
backend.go:267: [WARN] backend conn [0xc42005ef60] to 127.0.0.1:6379, db-0 stop and exit
backend.go:282: [WARN] backend conn [0xc42005ef60] to 127.0.0.1:6379, db-0 reader-[0] exit
backend.go:258: [WARN] backend conn [0xc42015cf60] to 127.0.0.1:6379, db-0 start service
backend.go:261: [WARN] backend conn [0xc42015cf60] to 127.0.0.1:6379, db-0 round-[0]
//16个db，每个db如此循环两三次
.
.
.

这个loopWriter方法是新建sharedBackendConn的核心方法，里面不止创建了loopWriter，也创建了loopReader。LoopWriter负责将redis请求取出并进行处理。

可能有读者会问，redis请求是什么时候写进来的？可以参照Codis源码解析——proxy监听redis请求一文，在启动proxy的时候，启动了一个goroutine监听发送到19000端口的请求，在proxy的loopReader中会将请求写入BackendConn.input这个channel

func (bc *BackendConn) loopWriter(round int) (err error) {
    //如果因为某种原因退出，还有input没来得及处理，就返回错误
    defer func() {
        for i := len(bc.input); i != 0; i-- {
            r := <-bc.input
            bc.setResponse(r, nil, ErrBackendConnReset)
        }
        log.WarnErrorf(err, "backend conn [%p] to %s, db-%d writer-[%d] exit",
            bc, bc.addr, bc.database, round)
    }()
    //这个方法内启动了loopReader
    c, tasks, err := bc.newBackendReader(round, bc.config)
    if err != nil {
        return err
    }
    defer close(tasks)

    defer bc.state.Set(0)

    bc.state.Set(stateConnected)
    bc.retry.fails = 0
    bc.retry.delay.Reset()

    p := c.FlushEncoder()
    p.MaxInterval = time.Millisecond
    p.MaxBuffered = cap(tasks) / 2

    //循环从BackendConn的input这个channel取redis请求
    for r := range bc.input {
        if r.IsReadOnly() && r.IsBroken() {
            bc.setResponse(r, nil, ErrRequestIsBroken)
            continue
        }
        //将请求取出并发送给codis-server
        if err := p.EncodeMultiBulk(r.Multi); err != nil {
            return bc.setResponse(r, nil, fmt.Errorf("backend conn failure, %s", err))
        }
        if err := p.Flush(len(bc.input) == 0); err != nil {
            return bc.setResponse(r, nil, fmt.Errorf("backend conn failure, %s", err))
        } else {
            //所有请求写入tasks这个channel
            tasks <- r
        }
    }
    return nil
}
func (bc *BackendConn) newBackendReader(round int, config *Config) (*redis.Conn, chan<- *Request, error) {
    //创建与Redis的连接Conn
    c, err := redis.DialTimeout(bc.addr, time.Second*5,
        config.BackendRecvBufsize.AsInt(),
        config.BackendSendBufsize.AsInt())    
    if err != nil {
        return nil, nil, err
    }
    c.ReaderTimeout = config.BackendRecvTimeout.Duration()
    c.WriterTimeout = config.BackendSendTimeout.Duration()
    c.SetKeepAlivePeriod(config.BackendKeepAlivePeriod.Duration())

    if err := bc.verifyAuth(c, config.ProductAuth); err != nil { 
        c.Close()
        return nil, nil, err
    }
    //选择redis库
    if err := bc.selectDatabase(c, bc.database); err != nil {   
        c.Close()
        return nil, nil, err
    }

    tasks := make(chan *Request, config.BackendMaxPipeline)    
    //读取task中的请求，并将处理结果与之对应关联
    go bc.loopReader(tasks, c, round)                                           

    return c, tasks, nil
}
func (bc *BackendConn) loopReader(tasks <-chan *Request, c *redis.Conn, round int) (err error) {
    //从连接中取完所有请求并setResponse之后，连接就会关闭
    defer func() {
        c.Close()
        for r := range tasks {
            bc.setResponse(r, nil, ErrBackendConnReset)
        }
        log.WarnErrorf(err, "backend conn [%p] to %s, db-%d reader-[%d] exit",
            bc, bc.addr, bc.database, round)
    }()
    //遍历tasks，此时的r是所有的请求
    for r := range tasks {
        //从redis.Conn中解码得到处理结果                                  
        resp, err := c.Decode()                             
        if err != nil {
            return bc.setResponse(r, nil, fmt.Errorf("backend conn failure, %s", err))
        }
        if resp != nil && resp.IsError() {
            switch {
            case bytes.HasPrefix(resp.Value, errMasterDown):
                if bc.state.CompareAndSwap(stateConnected, stateDataStale) {
                    log.Warnf("backend conn [%p] to %s, db-%d state = DataStale, caused by 'MASTERDOWN'",
                        bc, bc.addr, bc.database)
                }
            }
        }
        //请求结果设置为请求的属性
        bc.setResponse(r, resp, nil)                      
    }
    return nil
}
func (bc *BackendConn) setResponse(r *Request, resp *redis.Resp, err error) error {
    r.Resp, r.Err = resp, err
    if r.Group != nil {
        r.Group.Done()
    }
    if r.Batch != nil {
        r.Batch.Done()
    }
    return err
}

控制台也输出了

这个过程中对于channel的使用方式是值得读者学习的。分为如下几个步骤：proxy的router负责将收到的请求写到bc.input；newBackendReader创建一个名为task的channel，启动一个goroutine loopReader循环读出task的内容作处理，newBackendReader立即返回创建好的task给主线程loopwriter。主线程loopwriter中bc.input循环读出内容写入task。并且loopwriter和loopReader都做了range channel过程中因为异常退出的处理。

总结一下，backendConn负责实际对redis请求进行处理。在fillSlot的时候，主要目的就是给slot填充backend.bc(实际上是sharedBackendConn)。从models.slot得到BackendAddr和MigrateFrom的地址addr，根据这个addr，首先从proxy.Router的primary sharedBackendConnPool中取sharedBackendConn，如果没有获取到，就新建sharedBackendConn再放回sharedBackendConnPool。创建sharedBackendConn的过程中启动了两个goroutine，分别是loopWriter和loopReader，loopWriter负责从backendConn.input中取出请求并发送，loopReader负责遍历所有请求，从redis.Conn中解码得到resp并设置为相关的请求的属性，这样每一个请求及其结果就关联起来了。

另外补充一下，sharedBackendConn与codis-server连接的属性主要是conns和single这两个BackendConn，这两个BackendConn又是如何新建的呢？在调用fillslot的时候，会关闭每个slot之前的backend.bc,migrate.bc,replica.bc(关闭sharedBackendConn的时候，会逐个关闭它的conns，parallel这些backendConn)，在一个sharedBackendConn被关闭之前，每个BackendConn都会调用loopWriter，loopWriter中调用newBackendReader来新建与codis-server的连接，每个连接有效期默认75秒。

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