func (s *testModelSuite) TestNewAction(c *C) {
log.Info("[TestNewAction][start]")
fakeCoordConn := zkhelper.NewConn()
err := NewAction(fakeCoordConn, productName, ACTION_TYPE_SLOT_CHANGED, nil, "desc", false)
c.Assert(err, IsNil)
prefix := GetWatchActionPath(productName)
exist, _, err := fakeCoordConn.Exists(prefix)
c.Assert(exist, Equals, true)
c.Assert(err, IsNil)
// test if response node exists
d, _, err := fakeCoordConn.Get(prefix + "/0000000001")
c.Assert(err, IsNil)
// test get action data
d, _, err = fakeCoordConn.Get(GetActionResponsePath(productName) + "/0000000001")
c.Assert(err, IsNil)
var action Action
json.Unmarshal(d, &action)
c.Assert(action.Desc, Equals, "desc")
c.Assert(action.Type, Equals, ACTION_TYPE_SLOT_CHANGED)
fakeCoordConn.Close()
log.Info("[TestNewAction][end]")
}
func TestForceRemoveLock(t *testing.T) {
fakeZkConn := zkhelper.NewConn()
zkLock := utils.GetZkLock(fakeZkConn, productName)
if zkLock == nil {
t.Error("create lock error")
}
zkLock.Lock("force remove lock")
zkPath := fmt.Sprintf("/zk/codis/db_%s/LOCK", productName)
children, _, err := fakeZkConn.Children(zkPath)
if err != nil {
t.Error(err)
}
if len(children) == 0 {
t.Error("create lock error")
}
ForceRemoveLock(fakeZkConn, productName)
children, _, err = fakeZkConn.Children(zkPath)
if err != nil {
t.Error(err)
}
if len(children) != 0 {
t.Error("remove lock error")
}
}
// NewTimestampOracle creates a tso server with special config.
func NewTimestampOracle(cfg *Config) (*TimestampOracle, error) {
if cfg.SaveInterval <= 0 {
cfg.SaveInterval = defaultSaveInterval
}
tso := &TimestampOracle{
cfg: cfg,
isLeader: 0,
}
var err error
tso.listener, err = net.Listen("tcp", cfg.Addr)
if err != nil {
return nil, errors.Trace(err)
}
if len(cfg.ZKAddr) == 0 {
// no zookeeper, use a fake zk conn instead
tso.zkConn = zkhelper.NewConn()
} else {
tso.zkConn, err = zkhelper.ConnectToZkWithTimeout(cfg.ZKAddr, zkTimeout)
if err != nil {
return nil, errors.Trace(err)
}
}
tso.conns = map[net.Conn]struct{}{}
return tso, nil
}
func TestNewAction(t *testing.T) {
fakeZkConn := zkhelper.NewConn()
err := NewAction(fakeZkConn, productName, ACTION_TYPE_SLOT_CHANGED, nil, "desc", false)
if err != nil {
t.Error(errors.ErrorStack(err))
}
prefix := GetWatchActionPath(productName)
if exist, _, err := fakeZkConn.Exists(prefix); !exist {
t.Error(errors.ErrorStack(err))
}
//test if response node exists
d, _, err := fakeZkConn.Get(prefix + "/0000000001")
if err != nil {
t.Error(errors.ErrorStack(err))
}
//test get action data
d, _, err = fakeZkConn.Get(GetActionResponsePath(productName) + "/0000000001")
if err != nil {
t.Error(errors.ErrorStack(err))
}
var action Action
json.Unmarshal(d, &action)
if action.Desc != "desc" || action.Type != ACTION_TYPE_SLOT_CHANGED {
t.Error("create action error")
}
}
func TestProxyOfflineInWaitActionReceiver(t *testing.T) {
log.Info("test proxy offline when waiting action response")
fakeZkConn := zkhelper.NewConn()
for i := 1; i <= 4; i++ {
CreateProxyInfo(fakeZkConn, productName, &ProxyInfo{
Id: strconv.Itoa(i),
State: PROXY_STATE_ONLINE,
})
go waitForProxyMarkOffline(fakeZkConn, strconv.Itoa(i))
}
lst, _ := ProxyList(fakeZkConn, productName, nil)
if len(lst) != 4 {
t.Error("create proxy info error")
}
go func() {
time.Sleep(500 * time.Millisecond)
actionPath := path.Join(GetActionResponsePath(productName), fakeZkConn.Seq2Str(1))
//create test response for proxy 4, means proxy 1,2,3 are timeout
fakeZkConn.Create(path.Join(actionPath, "4"), nil,
0, zkhelper.DefaultFileACLs())
}()
err := NewActionWithTimeout(fakeZkConn, productName, ACTION_TYPE_SLOT_CHANGED, nil, "desc", true, 3*1000)
if err != nil && err.Error() != ErrReceiverTimeout.Error() {
t.Error(errors.ErrorStack(err))
}
for i := 1; i <= 3; i++ {
if info, _ := GetProxyInfo(fakeZkConn, productName, strconv.Itoa(i)); info.State != PROXY_STATE_OFFLINE {
t.Error("shutdown offline proxy error")
}
}
}
func resetEnv() {
conn = zkhelper.NewConn()
once.Do(func() {
go runFakeRedisSrv("127.0.0.1:1111")
go runFakeRedisSrv("127.0.0.1:2222")
time.Sleep(1 * time.Second)
})
}
func TestSlots(t *testing.T) {
fakeZkConn := zkhelper.NewConn()
path := GetSlotBasePath(productName)
children, _, _ := fakeZkConn.Children(path)
if len(children) != 0 {
t.Error("slot is no empty")
}
err := InitSlotSet(fakeZkConn, productName, 1024)
if err != nil {
t.Error(err)
}
children, _, _ = fakeZkConn.Children(path)
if len(children) != 1024 {
t.Error("init slots error")
}
s, err := GetSlot(fakeZkConn, productName, 1)
if err != nil {
t.Error(err)
}
if s.GroupId != -1 {
t.Error("init slots error")
}
err = SetSlotRange(fakeZkConn, productName, 0, 1023, 1, SLOT_STATUS_ONLINE)
if err != nil {
t.Error(err)
}
s, err = GetSlot(fakeZkConn, productName, 1)
if err != nil {
t.Error(err)
}
if s.GroupId != 1 {
t.Error("range set error")
}
err = s.SetMigrateStatus(fakeZkConn, 1, 2)
if err != nil {
t.Error(err)
}
if s.GroupId != 2 || s.State.Status != SLOT_STATUS_MIGRATE {
t.Error("migrate error")
}
}
func (s *testModelSuite) TestAddSlaveToEmptyGroup(c *C) {
log.Info("[TestAddSlaveToEmptyGroup][start]")
fakeCoordConn := zkhelper.NewConn()
g := NewServerGroup(productName, 1)
g.Create(fakeCoordConn)
s1 := NewServer(SERVER_TYPE_SLAVE, s.s1.addr)
err := g.AddServer(fakeCoordConn, s1, auth)
c.Assert(err, IsNil)
c.Assert(g.Servers[0].Type, Equals, SERVER_TYPE_MASTER)
fakeCoordConn.Close()
log.Info("[TestAddSlaveToEmptyGroup][end]")
}
func (s *testModelSuite) TestServerGroup(c *C) {
log.Info("[TestServerGroup][start]")
fakeCoordConn := zkhelper.NewConn()
g := NewServerGroup(productName, 1)
g.Create(fakeCoordConn)
// test create new group
groups, err := ServerGroups(fakeCoordConn, productName)
c.Assert(err, IsNil)
c.Assert(len(groups), Not(Equals), 0)
ok, err := g.Exists(fakeCoordConn)
c.Assert(err, IsNil)
c.Assert(ok, Equals, true)
gg, err := GetGroup(fakeCoordConn, productName, 1)
c.Assert(err, IsNil)
c.Assert(gg, NotNil)
c.Assert(gg.Id, Equals, g.Id)
s1 := NewServer(SERVER_TYPE_MASTER, s.s1.addr)
s2 := NewServer(SERVER_TYPE_MASTER, s.s2.addr)
err = g.AddServer(fakeCoordConn, s1, auth)
c.Assert(err, IsNil)
servers, err := g.GetServers(fakeCoordConn)
c.Assert(err, IsNil)
c.Assert(len(servers), Equals, 1)
g.AddServer(fakeCoordConn, s2, auth)
c.Assert(len(g.Servers), Equals, 1)
s2.Type = SERVER_TYPE_SLAVE
g.AddServer(fakeCoordConn, s2, auth)
c.Assert(len(g.Servers), Equals, 2)
err = g.Promote(fakeCoordConn, s2.Addr, auth)
c.Assert(err, IsNil)
m, err := g.Master(fakeCoordConn)
c.Assert(err, IsNil)
c.Assert(m.Addr, Equals, s2.Addr)
fakeCoordConn.Close()
log.Info("[TestServerGroup][stop]")
}
func (s *testModelSuite) TestSlots(c *C) {
log.Info("[TestSlots][start]")
fakeCoordConn := zkhelper.NewConn()
path := GetSlotBasePath(productName)
children, _, _ := fakeCoordConn.Children(path)
c.Assert(len(children), Equals, 0)
err := InitSlotSet(fakeCoordConn, productName, 1024)
c.Assert(err, IsNil)
children, _, err = fakeCoordConn.Children(path)
c.Assert(err, IsNil)
c.Assert(len(children), Equals, 1024)
sl, err := GetSlot(fakeCoordConn, productName, 1)
c.Assert(err, IsNil)
c.Assert(sl.GroupId, Equals, -1)
g := NewServerGroup(productName, 1)
g.Create(fakeCoordConn)
// test create new group
_, err = ServerGroups(fakeCoordConn, productName)
c.Assert(err, IsNil)
ok, err := g.Exists(fakeCoordConn)
c.Assert(err, IsNil)
c.Assert(ok, Equals, true)
err = SetSlotRange(fakeCoordConn, productName, 0, 1023, 1, SLOT_STATUS_ONLINE)
c.Assert(err, IsNil)
sl, err = GetSlot(fakeCoordConn, productName, 1)
c.Assert(err, IsNil)
c.Assert(sl.GroupId, Equals, 1)
err = sl.SetMigrateStatus(fakeCoordConn, 1, 2)
c.Assert(err, IsNil)
c.Assert(sl.GroupId, Equals, 2)
c.Assert(sl.State.Status, Equals, SLOT_STATUS_MIGRATE)
fakeCoordConn.Close()
log.Info("[TestSlots][end]")
}
func (s *testModelSuite) TestForceRemoveLock(c *C) {
log.Info("[TestForceRemoveLock][start]")
fakeCoordConn := zkhelper.NewConn()
zkLock := utils.GetCoordLock(fakeCoordConn, productName)
c.Assert(zkLock, NotNil)
zkLock.Lock("force remove lock")
coordPath := fmt.Sprintf("/zk/reborn/db_%s/LOCK", productName)
children, _, err := fakeCoordConn.Children(coordPath)
c.Assert(err, IsNil)
c.Assert(len(children), Not(Equals), 0)
ForceRemoveLock(fakeCoordConn, productName)
children, _, err = fakeCoordConn.Children(coordPath)
c.Assert(err, IsNil)
c.Assert(len(children), Equals, 0)
fakeCoordConn.Close()
log.Info("[TestForceRemoveLock][end]")
}
func TestMigrateManager(t *testing.T) {
fakeZkConn := zkhelper.NewConn()
mgr := NewMigrateManager(fakeZkConn, testProductName, nil)
if mgr == nil {
t.Error("mgr is null")
}
nodePath := fmt.Sprintf("/zk/codis/db_%s/migrate_manager", testProductName)
b, _, err := fakeZkConn.Exists(nodePath)
if !b || err != nil {
t.Error("create migrate mgr node error")
}
err = mgr.removeNode()
if err != nil {
t.Error(err)
}
b, _, err = fakeZkConn.Exists(nodePath)
if b {
t.Error("remove migrate mgr node error")
}
}
func TestProxy(t *testing.T) {
fakeZkConn := zkhelper.NewConn()
pi := &ProxyInfo{
Id: "proxy_1",
Addr: "localhost:1234",
State: PROXY_STATE_OFFLINE,
}
_, err := CreateProxyInfo(fakeZkConn, productName, pi)
if err != nil {
t.Error(err)
}
ps, err := ProxyList(fakeZkConn, productName, nil)
if err != nil {
t.Error(err)
}
if len(ps) != 1 || ps[0].Id != "proxy_1" {
t.Error("create proxy error")
}
err = SetProxyStatus(fakeZkConn, productName, pi.Id, PROXY_STATE_ONLINE)
if err != nil {
t.Error(err)
}
p, err := GetProxyInfo(fakeZkConn, productName, pi.Id)
if err != nil {
t.Error(err)
}
if p.State != PROXY_STATE_ONLINE {
t.Error("change status error")
}
}
func (s *testModelSuite) TestProxyOfflineInWaitActionReceiver(c *C) {
log.Info("[TestProxyOfflineInWaitActionReceiver][start]")
fakeCoordConn := zkhelper.NewConn()
proxyNum := 4
for i := 1; i <= proxyNum; i++ {
CreateProxyInfo(fakeCoordConn, productName, &ProxyInfo{
ID: strconv.Itoa(i),
State: PROXY_STATE_ONLINE,
})
go waitForProxyMarkOffline(fakeCoordConn, strconv.Itoa(i))
}
lst, _ := ProxyList(fakeCoordConn, productName, nil)
c.Assert(len(lst), Equals, proxyNum)
go func() {
time.Sleep(500 * time.Millisecond)
actionPath := path.Join(GetActionResponsePath(productName), fakeCoordConn.Seq2Str(1))
// create test response for proxy 4, means proxy 1,2,3 are timeout
fakeCoordConn.Create(path.Join(actionPath, "4"), nil,
0, zkhelper.DefaultFileACLs())
}()
err := NewActionWithTimeout(fakeCoordConn, productName, ACTION_TYPE_SLOT_CHANGED, nil, "desc", true, 3*1000)
if c.Check(err, NotNil) {
c.Assert(err.Error(), Equals, ErrReceiverTimeout.Error())
}
for i := 1; i <= proxyNum-1; i++ {
info, _ := GetProxyInfo(fakeCoordConn, productName, strconv.Itoa(i))
c.Assert(info.State, Equals, PROXY_STATE_OFFLINE)
}
fakeCoordConn.Close()
log.Info("[TestProxyOfflineInWaitActionReceiver][end]")
}
func InitEnv() {
go once.Do(func() {
conn = zkhelper.NewConn()
conf = &Conf{
proxyId: "proxy_test",
productName: "test",
zkAddr: "localhost:2181",
netTimeout: 5,
f: func(string) (zkhelper.Conn, error) { return conn, nil },
proto: "tcp4",
}
//init action path
prefix := models.GetWatchActionPath(conf.productName)
err := models.CreateActionRootPath(conn, prefix)
if err != nil {
log.Fatal(err)
}
//init slot
err = models.InitSlotSet(conn, conf.productName, 1024)
if err != nil {
log.Fatal(err)
}
//init server group
g1 := models.NewServerGroup(conf.productName, 1)
g1.Create(conn)
g2 := models.NewServerGroup(conf.productName, 2)
g2.Create(conn)
redis1, _ = miniredis.Run()
redis2, _ = miniredis.Run()
s1 := models.NewServer(models.SERVER_TYPE_MASTER, redis1.Addr())
s2 := models.NewServer(models.SERVER_TYPE_MASTER, redis2.Addr())
g1.AddServer(conn, s1)
g2.AddServer(conn, s2)
//set slot range
err = models.SetSlotRange(conn, conf.productName, 0, 511, 1, models.SLOT_STATUS_ONLINE)
if err != nil {
log.Fatal(err)
}
err = models.SetSlotRange(conn, conf.productName, 512, 1023, 2, models.SLOT_STATUS_ONLINE)
if err != nil {
log.Fatal(err)
}
go func() { //set proxy online
time.Sleep(3 * time.Second)
err := models.SetProxyStatus(conn, conf.productName, conf.proxyId, models.PROXY_STATE_ONLINE)
if err != nil {
log.Fatal(errors.ErrorStack(err))
}
time.Sleep(2 * time.Second)
proxyMutex.Lock()
defer proxyMutex.Unlock()
pi := s.getProxyInfo()
if pi.State != models.PROXY_STATE_ONLINE {
log.Fatalf("should be online, we got %s", pi.State)
}
}()
proxyMutex.Lock()
s = NewServer(":19000", ":11000",
conf,
)
proxyMutex.Unlock()
s.Run()
})
waitonce.Do(func() {
time.Sleep(10 * time.Second)
})
}
func (s *testModelSuite) TestProxy(c *C) {
log.Info("[TestProxy][start]")
fakeCoordConn := zkhelper.NewConn()
path := GetSlotBasePath(productName)
children, _, _ := fakeCoordConn.Children(path)
c.Assert(len(children), Equals, 0)
g := NewServerGroup(productName, 1)
g.Create(fakeCoordConn)
// test create new group
_, err := ServerGroups(fakeCoordConn, productName)
c.Assert(err, IsNil)
ok, err := g.Exists(fakeCoordConn)
c.Assert(err, IsNil)
c.Assert(ok, Equals, true)
s1 := NewServer(SERVER_TYPE_MASTER, "localhost:1111")
g.AddServer(fakeCoordConn, s1, auth)
err = InitSlotSet(fakeCoordConn, productName, 1024)
c.Assert(err, IsNil)
children, _, err = fakeCoordConn.Children(path)
c.Assert(err, IsNil)
c.Assert(len(children), Equals, 1024)
sl, err := GetSlot(fakeCoordConn, productName, 1)
c.Assert(err, IsNil)
c.Assert(sl.GroupId, Equals, -1)
err = SetSlotRange(fakeCoordConn, productName, 0, 1023, 1, SLOT_STATUS_ONLINE)
c.Assert(err, IsNil)
pi := &ProxyInfo{
ID: "proxy_1",
Addr: "localhost:1234",
State: PROXY_STATE_OFFLINE,
}
_, err = CreateProxyInfo(fakeCoordConn, productName, pi)
c.Assert(err, IsNil)
ps, err := ProxyList(fakeCoordConn, productName, nil)
c.Assert(err, IsNil)
c.Assert(len(ps), Equals, 1)
c.Assert(ps[0].ID, Equals, "proxy_1")
err = SetProxyStatus(fakeCoordConn, productName, pi.ID, PROXY_STATE_ONLINE)
c.Assert(err, IsNil)
p, err := GetProxyInfo(fakeCoordConn, productName, pi.ID)
c.Assert(err, IsNil)
c.Assert(p.State, Equals, PROXY_STATE_ONLINE)
fakeCoordConn.Close()
log.Info("[TestProxy][end]")
}
func TestProxy(t *testing.T) {
fakeZkConn := zkhelper.NewConn()
path := GetSlotBasePath(productName)
children, _, _ := fakeZkConn.Children(path)
if len(children) != 0 {
t.Error("slot is no empty")
}
g := NewServerGroup(productName, 1)
g.Create(fakeZkConn)
// test create new group
_, err := ServerGroups(fakeZkConn, productName)
if err != nil {
t.Error(err)
}
ok, err := g.Exists(fakeZkConn)
if !ok || err != nil {
t.Error("create group error")
}
s1 := NewServer(SERVER_TYPE_MASTER, "localhost:1111")
g.AddServer(fakeZkConn, s1)
err = InitSlotSet(fakeZkConn, productName, 1024)
if err != nil {
t.Error(err)
}
children, _, _ = fakeZkConn.Children(path)
if len(children) != 1024 {
t.Error("init slots error")
}
s, err := GetSlot(fakeZkConn, productName, 1)
if err != nil {
t.Error(err)
}
if s.GroupId != -1 {
t.Error("init slots error")
}
err = SetSlotRange(fakeZkConn, productName, 0, 1023, 1, SLOT_STATUS_ONLINE)
if err != nil {
t.Error(err)
}
pi := &ProxyInfo{
Id: "proxy_1",
Addr: "localhost:1234",
State: PROXY_STATE_OFFLINE,
}
_, err = CreateProxyInfo(fakeZkConn, productName, pi)
if err != nil {
t.Error(err)
}
ps, err := ProxyList(fakeZkConn, productName, nil)
if err != nil {
t.Error(err)
}
if len(ps) != 1 || ps[0].Id != "proxy_1" {
t.Error("create proxy error")
}
err = SetProxyStatus(fakeZkConn, productName, pi.Id, PROXY_STATE_ONLINE)
if err != nil {
t.Error(err)
}
p, err := GetProxyInfo(fakeZkConn, productName, pi.Id)
if err != nil {
t.Error(err)
}
if p.State != PROXY_STATE_ONLINE {
t.Error("change status error")
}
}
func TestServerGroup(t *testing.T) {
fakeZkConn := zkhelper.NewConn()
g := NewServerGroup(productName, 1)
g.Create(fakeZkConn)
// test create new group
groups, err := ServerGroups(fakeZkConn, productName)
if err != nil {
t.Error(err)
}
if len(groups) == 0 {
t.Error("create group error")
}
ok, err := g.Exists(fakeZkConn)
if !ok || err != nil {
t.Error("create group error")
}
gg, err := GetGroup(fakeZkConn, productName, 1)
if err != nil {
t.Error(err)
}
if gg == nil || gg.Id != g.Id {
t.Error("get group error")
}
s1 := NewServer(SERVER_TYPE_MASTER, "localhost:1111")
s2 := NewServer(SERVER_TYPE_MASTER, "localhost:2222")
g.AddServer(fakeZkConn, s1)
servers, err := g.GetServers(fakeZkConn)
if err != nil {
t.Error("add server error")
}
if len(servers) != 1 {
t.Error("add server error", len(servers))
}
g.AddServer(fakeZkConn, s1)
if len(g.Servers) != 1 {
t.Error("create group error")
}
g.AddServer(fakeZkConn, s2)
// add another master
if len(g.Servers) != 1 {
t.Error("add server error")
}
s2.Type = SERVER_TYPE_SLAVE
g.AddServer(fakeZkConn, s2)
if len(g.Servers) != 2 {
t.Error("add server error")
}
g.Promote(fakeZkConn, s2.Addr)
s, err := g.Master(fakeZkConn)
if err != nil {
t.Error(err)
}
// already exist master
if s.Addr != s1.Addr {
t.Error("prompt error")
}
s, err = g.Master(fakeZkConn)
if err != nil {
t.Error(err)
}
// already exist master
if s.Addr != s1.Addr {
t.Error("master error")
}
}
func (s *testProxyRouterSuite) initEnv(c *C) {
go once.Do(func() {
conn = zkhelper.NewConn()
conf = &Conf{
ProductName: "test",
CoordinatorAddr: "localhost:2181",
NetTimeout: 5,
f: func(string) (zkhelper.Conn, error) { return conn, nil },
Proto: "tcp4",
ProxyID: "proxy_test",
Addr: ":19000",
HTTPAddr: ":11000",
ProxyAuth: proxyAuth,
StoreAuth: storeAuth,
}
// init action path
prefix := models.GetWatchActionPath(conf.ProductName)
err := models.CreateActionRootPath(conn, prefix)
c.Assert(err, IsNil)
// init slot
err = models.InitSlotSet(conn, conf.ProductName, 1024)
c.Assert(err, IsNil)
// init server group
g1 := models.NewServerGroup(conf.ProductName, 1)
g1.Create(conn)
g2 := models.NewServerGroup(conf.ProductName, 2)
g2.Create(conn)
s1 := models.NewServer(models.SERVER_TYPE_MASTER, s.s1.addr)
s2 := models.NewServer(models.SERVER_TYPE_MASTER, s.s2.addr)
g1.AddServer(conn, s1, storeAuth)
g2.AddServer(conn, s2, storeAuth)
// set slot range
err = models.SetSlotRange(conn, conf.ProductName, 0, 511, 1, models.SLOT_STATUS_ONLINE)
c.Assert(err, IsNil)
err = models.SetSlotRange(conn, conf.ProductName, 512, 1023, 2, models.SLOT_STATUS_ONLINE)
c.Assert(err, IsNil)
go func() { //set proxy online
time.Sleep(3 * time.Second)
err := models.SetProxyStatus(conn, conf.ProductName, conf.ProxyID, models.PROXY_STATE_ONLINE)
c.Assert(err, IsNil)
time.Sleep(2 * time.Second)
proxyMutex.Lock()
defer proxyMutex.Unlock()
pi := ss.getProxyInfo()
c.Assert(pi.State, Equals, models.PROXY_STATE_ONLINE)
}()
proxyMutex.Lock()
ss = NewServer(conf)
proxyMutex.Unlock()
ss.Run()
})
waitonce.Do(func() {
time.Sleep(10 * time.Second)
})
}
