func registerConfigNode() error {
zkPath := fmt.Sprintf("/zk/codis/db_%s/living-codis-config", productName)
hostname, err := os.Hostname()
if err != nil {
return errors.Trace(err)
}
pid := os.Getpid()
content := fmt.Sprintf(`{"hostname": "%v", "pid": %v}`, hostname, pid)
nodeName := fmt.Sprintf("%v-%v", hostname, pid)
zkhelper.CreateRecursive(zkConn, zkPath, "", 0, zkhelper.DefaultDirACLs())
pathCreated, err := zkConn.Create(path.Join(zkPath, nodeName), []byte(content),
zk.FlagEphemeral, zkhelper.DefaultDirACLs())
log.Info("living node created:", pathCreated)
if err != nil {
return errors.Trace(err)
}
livingNode = pathCreated
return nil
}
func CreateProxyInfo(zkConn zkhelper.Conn, productName string, pi *ProxyInfo) (string, error) {
data, err := json.Marshal(pi)
if err != nil {
return "", errors.Trace(err)
}
dir := GetProxyPath(productName)
zkhelper.CreateRecursive(zkConn, dir, "", 0, zkhelper.DefaultDirACLs())
return zkConn.Create(path.Join(dir, pi.Id), data, zk.FlagEphemeral, zkhelper.DefaultFileACLs())
}
func (m *MigrateManager) createNode() error {
zkhelper.CreateRecursive(m.zkConn, fmt.Sprintf("/zk/codis/db_%s/migrate_tasks", m.productName), "", 0, zkhelper.DefaultDirACLs())
_, err := m.zkConn.Create(getManagerPath(m.productName),
[]byte(""), zk.FlagEphemeral, zkhelper.DefaultFileACLs())
if err != nil {
log.Error("dashboard already exists! err: ", err)
}
return nil
}
func (s *testUtilSuite) SetUpSuite(c *C) {
conn, err := zkhelper.ConnectToZkWithTimeout(*testZKAddr, time.Second)
c.Assert(err, IsNil)
s.zkConn = conn
s.rootPath = "/zk/tso_util_test"
_, err = zkhelper.CreateRecursive(s.zkConn, s.rootPath, "", 0, zk.WorldACL(zkhelper.PERM_DIRECTORY))
c.Assert(err, IsNil)
}
func addAgent(a *agentInfo) error {
basePath := agentPath()
zkhelper.CreateRecursive(globalConn, basePath, "", 0, zkhelper.DefaultDirACLs())
contents, err := json.Marshal(a)
if err != nil {
return errors.Trace(err)
}
_, err = globalConn.Create(path.Join(basePath, a.ID), contents, zk.FlagEphemeral, zkhelper.DefaultFileACLs())
return errors.Trace(err)
}
func (s *testUtilSuite) TestLeader(c *C) {
conn, err := zkhelper.ConnectToZkWithTimeout(*testZKAddr, time.Second)
c.Assert(err, IsNil)
defer conn.Close()
leaderPath := getLeaderPath(s.rootPath)
conn.Delete(leaderPath, -1)
_, err = GetLeader(conn, s.rootPath)
c.Assert(err, NotNil)
_, _, err = GetWatchLeader(conn, s.rootPath)
c.Assert(err, NotNil)
_, err = zkhelper.CreateRecursive(conn, leaderPath, "", 0, zk.WorldACL(zkhelper.PERM_FILE))
c.Assert(err, IsNil)
_, err = GetLeader(conn, s.rootPath)
c.Assert(err, NotNil)
_, _, err = GetWatchLeader(conn, s.rootPath)
c.Assert(err, NotNil)
addr := "127.0.0.1:1234"
m := map[string]interface{}{
"Addr": addr,
}
data, err := json.Marshal(m)
c.Assert(err, IsNil)
_, err = conn.Set(leaderPath, data, -1)
c.Assert(err, IsNil)
v, err := GetLeader(conn, s.rootPath)
c.Assert(err, IsNil)
c.Assert(v, Equals, addr)
v, _, err = GetWatchLeader(conn, s.rootPath)
c.Assert(err, IsNil)
c.Assert(v, Equals, addr)
}
func createDashboardNode() error {
conn := CreateZkConn()
defer conn.Close()
// make sure root dir is exists
rootDir := fmt.Sprintf("/zk/codis/db_%s", globalEnv.ProductName())
zkhelper.CreateRecursive(conn, rootDir, "", 0, zkhelper.DefaultDirACLs())
zkPath := fmt.Sprintf("%s/dashboard", rootDir)
// make sure we're the only one dashboard
if exists, _, _ := conn.Exists(zkPath); exists {
data, _, _ := conn.Get(zkPath)
return errors.New("dashboard already exists: " + string(data))
}
content := fmt.Sprintf(`{"addr": "%v", "pid": %v}`, globalEnv.DashboardAddr(), os.Getpid())
pathCreated, err := conn.Create(zkPath, []byte(content),
zk.FlagEphemeral, zkhelper.DefaultFileACLs())
log.Info("dashboard node created:", pathCreated, string(content))
return errors.Trace(err)
}
func createDashboardNode(conn zkhelper.Conn) error {
// make sure root dir is exists
rootDir := fmt.Sprintf("/zk/reborn/db_%s", globalEnv.ProductName())
zkhelper.CreateRecursive(conn, rootDir, "", 0, zkhelper.DefaultDirACLs())
coordPath := fmt.Sprintf("%s/dashboard", rootDir)
// make sure we're the only one dashboard
timeoutCh := time.After(60 * time.Second)
for {
if exists, _, ch, _ := conn.ExistsW(coordPath); exists {
data, _, _ := conn.Get(coordPath)
if checkDashboardAlive(data) {
return errors.Errorf("dashboard already exists: %s", string(data))
} else {
log.Warningf("dashboard %s exists in zk, wait it removed", data)
select {
case <-ch:
case <-timeoutCh:
return errors.Errorf("wait existed dashboard %s removed timeout", string(data))
}
}
} else {
break
}
}
content := fmt.Sprintf(`{"addr": "%v", "pid": %v}`, globalEnv.DashboardAddr(), os.Getpid())
pathCreated, err := conn.Create(coordPath, []byte(content),
zk.FlagEphemeral, zkhelper.DefaultFileACLs())
log.Infof("dashboard node %s created, data %s, err %v", pathCreated, string(content), err)
return errors.Trace(err)
}
func CreateProxyFenceNode(zkConn zkhelper.Conn, productName string, pi *ProxyInfo) (string, error) {
return zkhelper.CreateRecursive(zkConn, path.Join(GetProxyFencePath(productName), pi.Addr), "",
0, zkhelper.DefaultFileACLs())
}
