func runAddServerGroup(groupId int) error {
serverGroup := models.NewServerGroup(productName, groupId)
if err := serverGroup.Create(zkConn); err != nil {
return err
}
return nil
}
func runRemoveServerGroup(groupId int) error {
serverGroup := models.NewServerGroup(productName, groupId)
err := serverGroup.Remove(zkConn)
if err != nil {
log.Warning(err)
return err
}
return nil
}
func runAddServerToGroup(groupId int, addr string, role string) error {
serverGroup := models.NewServerGroup(productName, groupId)
if len(addr) > 0 && len(role) > 0 {
exists, err := serverGroup.Exists(zkConn)
if err != nil {
log.Warning(err)
return err
}
// if server group not exists, create it first
if !exists {
serverGroup.Create(zkConn)
}
server := models.NewServer(role, addr)
if err := serverGroup.AddServer(zkConn, server); err != nil {
log.Warning(err)
return err
}
}
return nil
}
func InitEnv() {
go once.Do(func() {
conn = zkhelper.NewConn()
conf = &Conf{
proxyId: "proxy_test",
productName: "test",
zkAddr: "localhost:2181",
net_timeout: 5,
f: func(string) (zkhelper.Conn, error) { return conn, nil },
slot_num: 16,
//broker: LedisBroker,
}
//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, conf.slot_num)
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, conf.slot_num/2-1, 1, models.SLOT_STATUS_ONLINE)
if err != nil {
log.Fatal(err)
}
err = models.SetSlotRange(conn, conf.productName, conf.slot_num/2, conf.slot_num-1, 2, models.SLOT_STATUS_ONLINE)
if err != nil {
log.Fatal(err)
}
go func() { //set proxy online
time.Sleep(5 * 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)
})
}