func myMIncr(in proto.PkgMultiOp, au Authorize, wa *WriteAccess, expected bool,
t *testing.T) proto.PkgMultiOp {
var pkg = make([]byte, in.Length())
_, err := in.Encode(pkg)
if err != nil {
t.Fatalf("Encode failed: ", err)
}
pkg, ok := testTbl.MIncr(&PkgArgs{in.Cmd, in.DbId, in.Seq, pkg}, au, wa)
if ok != expected {
if expected {
t.Fatalf("MIncr failed")
} else {
t.Fatalf("MIncr should fail")
}
}
var out proto.PkgMultiOp
_, err = out.Decode(pkg)
if err != nil {
t.Fatalf("Decode failed: ", err)
}
if expected {
if out.ErrCode != 0 {
t.Fatalf("Failed with ErrCode %d", out.ErrCode)
}
}
if out.DbId != in.DbId || out.Seq != in.Seq {
t.Fatalf("DbId/Seq mismatch")
}
return out
}
func myMGet(in proto.PkgMultiOp, au Authorize, wa *WriteAccess,
t *testing.T) proto.PkgMultiOp {
var pkg = make([]byte, in.Length())
_, err := in.Encode(pkg)
if err != nil {
t.Fatalf("Encode failed: ", err)
}
pkg = testTbl.MGet(&PkgArgs{in.Cmd, in.DbId, in.Seq, pkg}, au, wa)
var out proto.PkgMultiOp
_, err = out.Decode(pkg)
if err != nil {
t.Fatalf("Decode failed: ", err)
}
if out.ErrCode != 0 {
t.Fatalf("Failed with ErrCode %d", out.ErrCode)
}
if out.DbId != in.DbId || out.Seq != in.Seq {
t.Fatalf("DbId/Seq mismatch")
}
return out
}
func (srv *Server) replyMultiOp(req *Request, errCode int8) {
var out proto.PkgMultiOp
out.Cmd = req.Cmd
out.DbId = req.DbId
out.Seq = req.Seq
out.ErrCode = errCode
var pkg = make([]byte, out.Length())
_, err := out.Encode(pkg)
if err != nil {
log.Fatalf("Encode failed: %s\n", err)
}
srv.sendResp(false, req, pkg)
}
func replyMulti(out *proto.PkgMultiOp) []byte {
var pkgLen = out.Length()
if pkgLen > proto.MaxPkgLen {
out.Kvs = nil
out.SetErrCode(table.EcInvPkgLen)
pkgLen = out.Length()
}
var pkg = make([]byte, pkgLen)
_, err := out.Encode(pkg)
if err != nil {
log.Fatalf("Encode failed: %s\n", err)
}
return pkg
}
// MGet, MSet, MDel, MIncr, ZMGet, ZMSet, ZMDel, ZMIncr
func (c *Context) goMultiOp(zop bool, args multiArgs, cmd uint8,
done chan *Call) (*Call, error) {
call := c.cli.newCall(cmd, done)
if call.err != nil {
return call, call.err
}
var p proto.PkgMultiOp
p.Seq = call.seq
p.DbId = c.dbId
p.Cmd = call.cmd
// ZMGet, ZMSet, ZMDel, ZMIncr
if zop {
p.PkgFlag |= proto.FlagZop
}
p.Kvs = make([]proto.KeyValue, args.length())
args.toKV(p.Kvs)
var pkgLen = p.Length()
if pkgLen > proto.MaxPkgLen {
c.cli.errCall(call, ErrInvPkgLen)
return call, call.err
}
call.pkg = make([]byte, pkgLen)
_, err := p.Encode(call.pkg)
if err != nil {
c.cli.errCall(call, err)
return call, err
}
c.cli.sending <- call
return call, nil
}
func (ms *master) fullSync(tbl *store.Table) (uint64, error) {
var lastSeq uint64
if ms.lastSeq > 0 {
lastSeq = ms.lastSeq
if ms.migration {
log.Printf("Migration lastSeq is not 0, close now!\n")
return lastSeq, errors.New("migration lastSeq is not 0")
} else {
log.Printf("Already full synced to %s\n", ms.slaveAddr)
return lastSeq, nil
}
}
// Stop write globally
rwMtx := tbl.GetRWMutex()
rwMtx.Lock()
var chanLen int
for lastSeq, chanLen = ms.bin.GetLogSeqChanLen(); chanLen != 0; {
log.Println("Stop write globally for 1ms")
time.Sleep(time.Millisecond)
lastSeq, chanLen = ms.bin.GetLogSeqChanLen()
}
var it = tbl.NewIterator(false)
rwMtx.Unlock()
defer it.Destroy()
// Open BinLog reader to keep log files from deleting
var err = ms.openReader(lastSeq)
if err != nil {
return lastSeq, err
}
// Full sync
var p proto.PkgMultiOp
p.Cmd = proto.CmdSync
for it.SeekToFirst(); it.Valid(); {
ok := store.SeekAndCopySyncPkg(it, &p, ms.migration, ms.slotId)
if ms.cli.IsClosed() {
return lastSeq, nil
}
if len(p.Kvs) > 0 {
p.Seq = 0
var pkg = make([]byte, p.Length())
p.Encode(pkg)
ms.cli.AddResp(pkg)
}
if !ok {
break
}
}
// Tell slave full sync finished
if ms.migration {
ms.syncStatus(store.KeyFullSyncEnd, 0)
log.Printf("Full migration to %s slotId %d finished\n",
ms.slaveAddr, ms.slotId)
} else {
ms.syncStatus(store.KeyFullSyncEnd, lastSeq)
log.Printf("Full sync to %s finished\n", ms.slaveAddr)
}
return lastSeq, nil
}
