func main() {
defer func() {
if panicErr := recover(); panicErr != nil {
log.Fatalf("panic: %v", tb.Errorf("%v", panicErr))
}
}()
flag.Parse()
args := flag.Args()
if len(args) != 0 {
flag.Usage()
os.Exit(1)
}
if *fromTopo == "" || *toTopo == "" {
log.Fatalf("Need both from and to topo")
}
fromTS := topo.GetServerByName(*fromTopo)
toTS := topo.GetServerByName(*toTopo)
if *doKeyspaces {
helpers.CopyKeyspaces(fromTS, toTS)
}
if *doShards {
helpers.CopyShards(fromTS, toTS, *deleteKeyspaceShards)
}
if *doShardReplications {
helpers.CopyShardReplications(fromTS, toTS)
}
if *doTablets {
helpers.CopyTablets(fromTS, toTS)
}
}
func main() {
defer exit.RecoverAll()
defer logutil.Flush()
flag.Parse()
args := flag.Args()
if len(args) != 0 {
flag.Usage()
os.Exit(1)
}
if *fromTopo == "" || *toTopo == "" {
log.Errorf("Need both from and to topo")
exit.Return(1)
}
ctx := context.Background()
fromTS := topo.GetServerByName(*fromTopo)
toTS := topo.GetServerByName(*toTopo)
if *doKeyspaces {
helpers.CopyKeyspaces(ctx, fromTS.Impl, toTS.Impl)
}
if *doShards {
helpers.CopyShards(ctx, fromTS.Impl, toTS.Impl, *deleteKeyspaceShards)
}
if *doShardReplications {
helpers.CopyShardReplications(ctx, fromTS.Impl, toTS.Impl)
}
if *doTablets {
helpers.CopyTablets(ctx, fromTS.Impl, toTS.Impl)
}
}
func main() {
defer exit.RecoverAll()
defer logutil.Flush()
flag.Parse()
args := flag.Args()
if len(args) != 0 {
flag.Usage()
os.Exit(1)
}
if *fromTopo == "" || *toTopo == "" {
log.Fatalf("Need both from and to topo")
}
fromTS := topo.GetServerByName(*fromTopo)
toTS := topo.GetServerByName(*toTopo)
if *doKeyspaces {
helpers.CopyKeyspaces(fromTS, toTS)
}
if *doShards {
helpers.CopyShards(fromTS, toTS, *deleteKeyspaceShards)
}
if *doShardReplications {
helpers.CopyShardReplications(fromTS, toTS)
}
if *doTablets {
helpers.CopyTablets(fromTS, toTS)
}
}
func init() {
// handles /zk paths
ts := topo.GetServerByName("zookeeper")
if ts == nil {
log.Error("zookeeper explorer disabled: no zktopo.Server")
return
}
HandleExplorer("zk", "/zk/", "zk.html", NewZkExplorer(ts.(*zktopo.Server).GetZConn()))
}
func main() {
defer exit.Recover()
// flag parsing
flags := dbconfigs.AppConfig | dbconfigs.DbaConfig |
dbconfigs.FilteredConfig | dbconfigs.ReplConfig
dbconfigs.RegisterFlags(flags)
mysqlctl.RegisterFlags()
flag.Parse()
if len(flag.Args()) > 0 {
flag.Usage()
log.Errorf("vtcombo doesn't take any positional arguments")
exit.Return(1)
}
// register topo server
topo.RegisterServer("fakezk", zktopo.NewServer(fakezk.NewConn()))
ts := topo.GetServerByName("fakezk")
servenv.Init()
// database configs
mycnf, err := mysqlctl.NewMycnfFromFlags(0)
if err != nil {
log.Errorf("mycnf read failed: %v", err)
exit.Return(1)
}
dbcfgs, err := dbconfigs.Init(mycnf.SocketFile, flags)
if err != nil {
log.Warning(err)
}
mysqld := mysqlctl.NewMysqld("Dba", "App", mycnf, &dbcfgs.Dba, &dbcfgs.App.ConnParams, &dbcfgs.Repl)
// tablets configuration and init
binlog.RegisterUpdateStreamService(mycnf)
initTabletMap(ts, *topology, mysqld, dbcfgs, mycnf)
// vtgate configuration and init
resilientSrvTopoServer := vtgate.NewResilientSrvTopoServer(ts, "ResilientSrvTopoServer")
healthCheck := discovery.NewHealthCheck(30*time.Second /*connTimeoutTotal*/, 1*time.Millisecond /*retryDelay*/)
vtgate.Init(healthCheck, ts, resilientSrvTopoServer, nil /*schema*/, cell, 1*time.Millisecond /*retryDelay*/, 2 /*retryCount*/, 30*time.Second /*connTimeoutTotal*/, 10*time.Second /*connTimeoutPerConn*/, 365*24*time.Hour /*connLife*/, 0 /*maxInFlight*/, "" /*testGateway*/)
servenv.OnTerm(func() {
// FIXME(alainjobart) stop vtgate, all tablets
// qsc.DisallowQueries()
// agent.Stop()
})
servenv.OnClose(func() {
// We will still use the topo server during lameduck period
// to update our state, so closing it in OnClose()
topo.CloseServers()
})
servenv.RunDefault()
}
func main() {
defer func() {
if panicErr := recover(); panicErr != nil {
relog.Fatal("panic: %v", tb.Errorf("%v", panicErr))
}
}()
flag.Parse()
args := flag.Args()
if len(args) != 0 {
flag.Usage()
os.Exit(1)
}
logLevel, err := relog.LogNameToLogLevel(*logLevel)
if err != nil {
relog.Fatal("%v", err)
}
relog.SetLevel(logLevel)
if *fromTopo == "" || *toTopo == "" {
relog.Fatal("Need both from and to topo")
}
fromTS := topo.GetServerByName(*fromTopo)
toTS := topo.GetServerByName(*toTopo)
if *doKeyspaces {
topotools.CopyKeyspaces(fromTS, toTS)
}
if *doShards {
topotools.CopyShards(fromTS, toTS, *deleteKeyspaceShards)
}
if *doTablets {
topotools.CopyTablets(fromTS, toTS)
}
}
func init() {
// handles /zk paths
ts := topo.GetServerByName("zookeeper")
if ts == nil {
log.Error("zookeeper explorer disabled: no zktopo.Server")
return
}
HandleExplorer("/zk/", "zk.html", NewZkExplorer(ts.(*zktopo.Server).GetZConn()))
// adds links for keyspaces and shards
funcMap["keyspace"] = func(keyspace string) template.HTML {
return template.HTML("<a href=\"/zk/global/vt/keyspaces/" + keyspace + "\">" + keyspace + "</a>")
}
funcMap["shard"] = func(keyspace, shard string) template.HTML {
return template.HTML("<a href=\"/zk/global/vt/keyspaces/" + keyspace + "/shards/" + shard + "\">" + shard + "</a>")
}
// add toplevel link for zookeeper
indexContent.ToplevelLinks["Zookeeper Explorer"] = "/zk"
}
func main() {
defer exit.Recover()
// flag parsing
flags := dbconfigs.AppConfig | dbconfigs.DbaConfig |
dbconfigs.FilteredConfig | dbconfigs.ReplConfig
dbconfigs.RegisterFlags(flags)
mysqlctl.RegisterFlags()
flag.Parse()
if len(flag.Args()) > 0 {
flag.Usage()
log.Errorf("vtcombo doesn't take any positional arguments")
exit.Return(1)
}
// register topo server
zkconn := fakezk.NewConn()
topo.RegisterServer("fakezk", zktopo.NewServer(zkconn))
ts = topo.GetServerByName("fakezk")
servenv.Init()
tabletserver.Init()
// database configs
mycnf, err := mysqlctl.NewMycnfFromFlags(0)
if err != nil {
log.Errorf("mycnf read failed: %v", err)
exit.Return(1)
}
dbcfgs, err := dbconfigs.Init(mycnf.SocketFile, flags)
if err != nil {
log.Warning(err)
}
mysqld := mysqlctl.NewMysqld("Dba", "App", mycnf, &dbcfgs.Dba, &dbcfgs.App.ConnParams, &dbcfgs.Repl)
servenv.OnClose(mysqld.Close)
// tablets configuration and init
initTabletMap(ts, *topology, mysqld, dbcfgs, mycnf)
// vschema
var schema *planbuilder.Schema
if *vschema != "" {
schema, err = planbuilder.LoadFile(*vschema)
if err != nil {
log.Error(err)
exit.Return(1)
}
log.Infof("v3 is enabled: loaded schema from file")
}
// vtgate configuration and init
resilientSrvTopoServer := vtgate.NewResilientSrvTopoServer(ts, "ResilientSrvTopoServer")
healthCheck := discovery.NewHealthCheck(30*time.Second /*connTimeoutTotal*/, 1*time.Millisecond /*retryDelay*/, 1*time.Minute /*healthCheckTimeout*/)
tabletTypesToWait := []topodatapb.TabletType{
topodatapb.TabletType_MASTER,
topodatapb.TabletType_REPLICA,
topodatapb.TabletType_RDONLY,
}
vtgate.Init(healthCheck, ts, resilientSrvTopoServer, schema, cell, 1*time.Millisecond /*retryDelay*/, 2 /*retryCount*/, 30*time.Second /*connTimeoutTotal*/, 10*time.Second /*connTimeoutPerConn*/, 365*24*time.Hour /*connLife*/, tabletTypesToWait, 0 /*maxInFlight*/, "" /*testGateway*/)
// vtctld configuration and init
vtctld.InitVtctld(ts)
vtctld.HandleExplorer("zk", zktopo.NewZkExplorer(zkconn))
servenv.OnTerm(func() {
// FIXME(alainjobart): stop vtgate
})
servenv.OnClose(func() {
log.Infof("Total count of new connections to MySQL: %v", expvar.Get("mysql-new-connection-count"))
// We will still use the topo server during lameduck period
// to update our state, so closing it in OnClose()
topo.CloseServers()
})
servenv.RunDefault()
}
func init() {
// handles /zk paths
http.HandleFunc("/zk/", func(w http.ResponseWriter, r *http.Request) {
zkTopoServ := topo.GetServerByName("zookeeper")
if zkTopoServ == nil {
http.Error(w, "can only look at zk with zktopo.Server", http.StatusInternalServerError)
return
}
zconn := zkTopoServ.(*zktopo.Server).GetZConn()
if err := r.ParseForm(); err != nil {
httpError(w, "cannot parse form: %s", err)
return
}
zkPath := r.URL.Path[strings.Index(r.URL.Path, "/zk"):]
if cleanPath := path.Clean(zkPath); zkPath != cleanPath && zkPath != cleanPath+"/" {
log.Infof("redirecting to %v", cleanPath)
http.Redirect(w, r, cleanPath, http.StatusTemporaryRedirect)
return
}
if strings.HasSuffix(zkPath, "/") {
zkPath = zkPath[:len(zkPath)-1]
}
result := NewZkResult(zkPath)
if zkPath == "/zk" {
cells, err := zk.ResolveWildcards(zconn, []string{"/zk/*"})
if err != nil {
httpError(w, "zk error: %v", err)
return
}
for i, cell := range cells {
cells[i] = cell[4:] // cut off "/zk/"
}
result.Children = cells
sort.Strings(result.Children)
} else {
if data, _, err := zconn.Get(zkPath); err != nil {
result.Error = err.Error()
} else {
if m, _ := path.Match("/zk/global/vt/keyspaces/*", zkPath); m {
keyspace := path.Base(zkPath)
actionRepo.PopulateKeyspaceActions(result.Actions, keyspace)
} else if m, _ := path.Match("/zk/global/vt/keyspaces/*/shards/*", zkPath); m {
zkPathParts := strings.Split(zkPath, "/")
keyspace := zkPathParts[5]
shard := zkPathParts[7]
actionRepo.PopulateShardActions(result.Actions, keyspace, shard)
} else if m, _ := path.Match("/zk/*/vt/tablets/*", result.Path); m {
zkPathParts := strings.Split(result.Path, "/")
alias := zkPathParts[2] + "-" + zkPathParts[5]
actionRepo.PopulateTabletActions(result.Actions, alias)
}
result.Data = data
if children, _, err := zconn.Children(zkPath); err != nil {
result.Error = err.Error()
} else {
result.Children = children
sort.Strings(result.Children)
}
}
}
templateLoader.ServeTemplate("zk.html", result, w, r)
})
// adds links for keyspaces and shards
funcMap["keyspace"] = func(keyspace string) template.HTML {
return template.HTML("<a href=\"/zk/global/vt/keyspaces/" + keyspace + "\">" + keyspace + "</a>")
}
funcMap["shard"] = func(keyspace, shard string) template.HTML {
return template.HTML("<a href=\"/zk/global/vt/keyspaces/" + keyspace + "/shards/" + shard + "\">" + shard + "</a>")
}
// add toplevel link for zookeeper
indexContent.ToplevelLinks["Zookeeper Explorer"] = "/zk"
}
func main() {
defer exit.Recover()
// flag parsing
flags := dbconfigs.AppConfig | dbconfigs.DbaConfig |
dbconfigs.FilteredConfig | dbconfigs.ReplConfig
dbconfigs.RegisterFlags(flags)
mysqlctl.RegisterFlags()
flag.Parse()
if len(flag.Args()) > 0 {
flag.Usage()
log.Errorf("vtcombo doesn't take any positional arguments")
exit.Return(1)
}
// set discoverygateway flag to default value
flag.Set("cells_to_watch", cell)
// register topo server
zkconn := fakezk.NewConn()
topo.RegisterServer("fakezk", zktopo.NewServer(zkconn))
ts = topo.GetServerByName("fakezk")
servenv.Init()
tabletserver.Init()
// database configs
mycnf, err := mysqlctl.NewMycnfFromFlags(0)
if err != nil {
log.Errorf("mycnf read failed: %v", err)
exit.Return(1)
}
dbcfgs, err := dbconfigs.Init(mycnf.SocketFile, flags)
if err != nil {
log.Warning(err)
}
mysqld := mysqlctl.NewMysqld("Dba", "App", mycnf, &dbcfgs.Dba, &dbcfgs.App.ConnParams, &dbcfgs.Repl)
servenv.OnClose(mysqld.Close)
// tablets configuration and init
if err := initTabletMap(ts, *protoTopo, mysqld, dbcfgs, *schemaDir, mycnf); err != nil {
log.Errorf("initTabletMapProto failed: %v", err)
exit.Return(1)
}
// vtgate configuration and init
resilientSrvTopoServer := vtgate.NewResilientSrvTopoServer(ts, "ResilientSrvTopoServer")
healthCheck := discovery.NewHealthCheck(30*time.Second /*connTimeoutTotal*/, 1*time.Millisecond /*retryDelay*/, 1*time.Hour /*healthCheckTimeout*/)
tabletTypesToWait := []topodatapb.TabletType{
topodatapb.TabletType_MASTER,
topodatapb.TabletType_REPLICA,
topodatapb.TabletType_RDONLY,
}
vtgate.Init(context.Background(), healthCheck, ts, resilientSrvTopoServer, cell, 2 /*retryCount*/, tabletTypesToWait)
// vtctld configuration and init
vtctld.InitVtctld(ts)
vtctld.HandleExplorer("zk", zktopo.NewZkExplorer(zkconn))
servenv.OnTerm(func() {
// FIXME(alainjobart): stop vtgate
})
servenv.OnClose(func() {
// We will still use the topo server during lameduck period
// to update our state, so closing it in OnClose()
topo.CloseServers()
})
servenv.RunDefault()
}
func main() {
defer exit.Recover()
// flag parsing
flags := dbconfigs.AppConfig | dbconfigs.AllPrivsConfig | dbconfigs.DbaConfig |
dbconfigs.FilteredConfig | dbconfigs.ReplConfig
dbconfigs.RegisterFlags(flags)
mysqlctl.RegisterFlags()
flag.Parse()
if len(flag.Args()) > 0 {
flag.Usage()
log.Errorf("vtcombo doesn't take any positional arguments")
exit.Return(1)
}
// parse the input topology
tpb := &vttestpb.VTTestTopology{}
if err := proto.UnmarshalText(*protoTopo, tpb); err != nil {
log.Errorf("cannot parse topology: %v", err)
exit.Return(1)
}
// default cell to "test" if unspecified
if len(tpb.Cells) == 0 {
tpb.Cells = append(tpb.Cells, "test")
}
// set discoverygateway flag to default value
flag.Set("cells_to_watch", strings.Join(tpb.Cells, ","))
// vtctld UI requires the cell flag
flag.Set("cell", tpb.Cells[0])
flag.Set("enable_realtime_stats", "true")
flag.Set("log_dir", "$VTDATAROOT/tmp")
// create zk client config file
config := path.Join(os.Getenv("VTDATAROOT"), "vt_0000000001/tmp/test-zk-client-conf.json")
cellmap := make(map[string]string)
for _, cell := range tpb.Cells {
cellmap[cell] = "localhost"
}
b, err := json.Marshal(cellmap)
if err != nil {
log.Errorf("failed to marshal json: %v", err)
}
f, err := os.Create(config)
if err != nil {
log.Errorf("failed to create zk config file: %v", err)
}
defer f.Close()
_, err = f.WriteString(string(b[:]))
if err != nil {
log.Errorf("failed to write to zk config file: %v", err)
}
os.Setenv("ZK_CLIENT_CONFIG", config)
// register topo server
zkconn := fakezk.NewConn()
topo.RegisterServer("fakezk", zktopo.NewServer(zkconn))
ts = topo.GetServerByName("fakezk")
servenv.Init()
tabletserver.Init()
// database configs
mycnf, err := mysqlctl.NewMycnfFromFlags(0)
if err != nil {
log.Errorf("mycnf read failed: %v", err)
exit.Return(1)
}
dbcfgs, err := dbconfigs.Init(mycnf.SocketFile, flags)
if err != nil {
log.Warning(err)
}
mysqld := mysqlctl.NewMysqld(mycnf, &dbcfgs.Dba, &dbcfgs.AllPrivs, &dbcfgs.App, &dbcfgs.Repl, true /* enablePublishStats */)
servenv.OnClose(mysqld.Close)
// tablets configuration and init
if err := initTabletMap(ts, tpb, mysqld, dbcfgs, *schemaDir, mycnf); err != nil {
log.Errorf("initTabletMapProto failed: %v", err)
exit.Return(1)
}
// vtgate configuration and init
resilientSrvTopoServer := vtgate.NewResilientSrvTopoServer(ts, "ResilientSrvTopoServer")
healthCheck := discovery.NewHealthCheck(30*time.Second /*connTimeoutTotal*/, 1*time.Millisecond /*retryDelay*/, 1*time.Hour /*healthCheckTimeout*/)
tabletTypesToWait := []topodatapb.TabletType{
topodatapb.TabletType_MASTER,
topodatapb.TabletType_REPLICA,
topodatapb.TabletType_RDONLY,
}
vtgate.Init(context.Background(), healthCheck, ts, resilientSrvTopoServer, tpb.Cells[0], 2 /*retryCount*/, tabletTypesToWait)
// vtctld configuration and init
vtctld.InitVtctld(ts)
vtctld.HandleExplorer("zk", zktopo.NewZkExplorer(zkconn))
servenv.OnTerm(func() {
// FIXME(alainjobart): stop vtgate
})
servenv.OnClose(func() {
// We will still use the topo server during lameduck period
// to update our state, so closing it in OnClose()
topo.CloseServers()
})
servenv.RunDefault()
}
func main() {
flag.Parse()
templateLoader := NewTemplateLoader(*templateDir, dummyTemplate, *debug)
ts := topo.GetServer()
defer topo.CloseServers()
wr := wrangler.New(ts, 30*time.Second, 30*time.Second)
actionRepo := NewActionRepository(wr)
const (
keyspacePath = "/zk/global/vt/keyspaces/*"
shardPath = "/zk/global/vt/keyspaces/*/shards/*"
tabletPath = "/zk/*/vt/tablets/*"
)
actionRepo.Register(keyspacePath, "ValidateKeyspace",
func(wr *wrangler.Wrangler, zkPath string, r *http.Request) (string, error) {
return "", wr.ValidateKeyspace(path.Base(zkPath), false)
})
actionRepo.Register(keyspacePath, "ValidateSchemaKeyspace",
func(wr *wrangler.Wrangler, zkPath string, r *http.Request) (string, error) {
return "", wr.ValidateSchemaKeyspace(path.Base(zkPath), false)
})
actionRepo.Register(keyspacePath, "ValidateVersionKeyspace",
func(wr *wrangler.Wrangler, zkPath string, r *http.Request) (string, error) {
return "", wr.ValidateVersionKeyspace(path.Base(zkPath))
})
actionRepo.Register(keyspacePath, "ValidatePermissionsKeyspace",
func(wr *wrangler.Wrangler, zkPath string, r *http.Request) (string, error) {
return "", wr.ValidatePermissionsKeyspace(path.Base(zkPath))
})
actionRepo.Register(shardPath, "ValidateShard",
func(wr *wrangler.Wrangler, zkPath string, r *http.Request) (string, error) {
zkPathParts := strings.Split(zkPath, "/")
return "", wr.ValidateShard(zkPathParts[5], zkPathParts[7], false)
})
actionRepo.Register(shardPath, "ValidateSchemaShard",
func(wr *wrangler.Wrangler, zkPath string, r *http.Request) (string, error) {
zkPathParts := strings.Split(zkPath, "/")
return "", wr.ValidateSchemaShard(zkPathParts[5], zkPathParts[7], false)
})
actionRepo.Register(shardPath, "ValidateVersionShard",
func(wr *wrangler.Wrangler, zkPath string, r *http.Request) (string, error) {
zkPathParts := strings.Split(zkPath, "/")
return "", wr.ValidateVersionShard(zkPathParts[5], zkPathParts[7])
})
actionRepo.Register(shardPath, "ValidatePermissionsShard",
func(wr *wrangler.Wrangler, zkPath string, r *http.Request) (string, error) {
zkPathParts := strings.Split(zkPath, "/")
return "", wr.ValidatePermissionsShard(zkPathParts[5], zkPathParts[7])
})
actionRepo.Register(tabletPath, "RpcPing",
func(wr *wrangler.Wrangler, zkPath string, r *http.Request) (string, error) {
zkPathParts := strings.Split(zkPath, "/")
alias, err := topo.ParseTabletAliasString(zkPathParts[2] + "-" + zkPathParts[5])
if err != nil {
return "", err
}
return "", wr.ActionInitiator().RpcPing(alias, 10*time.Second)
})
http.HandleFunc("/", func(w http.ResponseWriter, r *http.Request) {
tmpl, err := templateLoader.Lookup("index.html")
if err != nil {
httpError(w, "error in template loader: %v", err)
return
}
if err := tmpl.Execute(w, nil); err != nil {
httpError(w, "error executing template", err)
}
})
http.HandleFunc("/actions", func(w http.ResponseWriter, r *http.Request) {
if err := r.ParseForm(); err != nil {
httpError(w, "cannot parse form: %s", err)
return
}
action := r.FormValue("action")
if action == "" {
http.Error(w, "no action provided", http.StatusBadRequest)
return
}
zkPath := r.FormValue("zkpath")
if zkPath == "" {
http.Error(w, "no zookeeper path provided", http.StatusBadRequest)
return
}
result := actionRepo.Apply(action, zkPath, r)
templateLoader.ServeTemplate("action.html", result, w, r)
})
http.HandleFunc("/dbtopo", func(w http.ResponseWriter, r *http.Request) {
if err := r.ParseForm(); err != nil {
httpError(w, "cannot parse form: %s", err)
return
}
result := DbTopologyResult{}
topology, err := wr.DbTopology()
if err != nil {
result.Error = err.Error()
} else {
result.Topology = topology
}
templateLoader.ServeTemplate("dbtopo.html", result, w, r)
})
http.HandleFunc("/zk/", func(w http.ResponseWriter, r *http.Request) {
zkTopoServ := topo.GetServerByName("zookeeper")
if zkTopoServ == nil {
http.Error(w, "can only look at zk with zktopo.Server", http.StatusInternalServerError)
return
}
zconn := zkTopoServ.(*zktopo.Server).GetZConn()
if err := r.ParseForm(); err != nil {
httpError(w, "cannot parse form: %s", err)
return
}
zkPath := r.URL.Path[strings.Index(r.URL.Path, "/zk"):]
if cleanPath := path.Clean(zkPath); zkPath != cleanPath && zkPath != cleanPath+"/" {
relog.Info("redirecting to %v", cleanPath)
http.Redirect(w, r, cleanPath, http.StatusTemporaryRedirect)
return
}
if strings.HasSuffix(zkPath, "/") {
zkPath = zkPath[:len(zkPath)-1]
}
result := NewZkResult(zkPath)
if zkPath == "/zk" {
cells, err := zk.ResolveWildcards(zconn, []string{"/zk/*"})
if err != nil {
httpError(w, "zk error: %v", err)
return
}
for i, cell := range cells {
cells[i] = cell[4:] // cut off "/zk/"
}
result.Children = cells
} else {
if data, _, err := zconn.Get(zkPath); err != nil {
result.Error = err.Error()
} else {
actionRepo.PopulateAvailableActions(result)
result.Data = data
if children, _, err := zconn.Children(zkPath); err != nil {
result.Error = err.Error()
} else {
result.Children = children
}
}
}
templateLoader.ServeTemplate("zk.html", result, w, r)
})
relog.Fatal("%s", http.ListenAndServe(fmt.Sprintf(":%d", *port), nil))
}
