func main() {
flag.Parse()
args := flag.Args()
installSignalHandlers()
servenv.Init()
defer servenv.Close()
ts := topo.GetServer()
defer topo.CloseServers()
// the logger will be replaced when we start a job
wr = wrangler.New(logutil.NewConsoleLogger(), ts, 30*time.Second, 30*time.Second)
if len(args) == 0 {
// interactive mode, initialize the web UI to chose a command
initInteractiveMode()
} else {
// single command mode, just runs it
runCommand(args)
}
initStatusHandling()
servenv.RunDefault()
}
func main() {
flag.Parse()
servenv.Init()
var schema *planbuilder.Schema
log.Info(*cell, *schemaFile)
if *schemaFile != "" {
var err error
if schema, err = planbuilder.LoadSchemaJSON(*schemaFile); err != nil {
log.Fatal(err)
}
}
ts := topo.GetServer()
defer topo.CloseServers()
resilientSrvTopoServer = vtgate.NewResilientSrvTopoServer(ts, "ResilientSrvTopoServer")
// For the initial phase vtgate is exposing
// topoReader api. This will be subsumed by
// vtgate once vtgate's client functions become active.
topoReader = NewTopoReader(resilientSrvTopoServer)
servenv.Register("toporeader", topoReader)
vtgate.Init(resilientSrvTopoServer, schema, *cell, *retryDelay, *retryCount, *timeout, *maxInFlight)
servenv.RunDefault()
}
func main() {
dbconfigs.RegisterFlags()
mysqlctl.RegisterFlags()
flag.Parse()
if len(flag.Args()) > 0 {
flag.Usage()
log.Fatalf("vttablet doesn't take any positional arguments")
}
servenv.Init()
if *tabletPath == "" {
log.Fatalf("tabletPath required")
}
tabletAlias := tabletParamToTabletAlias(*tabletPath)
mycnf, err := mysqlctl.NewMycnfFromFlags(tabletAlias.Uid)
if err != nil {
log.Fatalf("mycnf read failed: %v", err)
}
dbcfgs, err := dbconfigs.Init(mycnf.SocketFile)
if err != nil {
log.Warning(err)
}
dbcfgs.App.EnableRowcache = *enableRowcache
if *tableAclConfig != "" {
tableacl.Init(*tableAclConfig)
}
tabletserver.InitQueryService()
binlog.RegisterUpdateStreamService(mycnf)
// Load custom query rules
err = tabletserver.SqlQueryRpcService.SetQueryRules(tabletserver.CustomQueryRules, tabletserver.LoadCustomRules())
if err != nil {
log.Warningf("Fail to load query rule set %s, Error message: %s", tabletserver.CustomQueryRules, err)
}
// Depends on both query and updateStream.
agent, err = tabletmanager.NewActionAgent(tabletAlias, dbcfgs, mycnf, *servenv.Port, *servenv.SecurePort, *overridesFile, *lockTimeout)
if err != nil {
log.Fatal(err)
}
tabletmanager.HttpHandleSnapshots(mycnf, tabletAlias.Uid)
servenv.OnTerm(func() {
tabletserver.DisallowQueries()
binlog.DisableUpdateStreamService()
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 exit.RecoverAll()
defer logutil.Flush()
flag.Parse()
args := flag.Args()
if len(args) == 0 {
flag.Usage()
exit.Return(1)
}
action := args[0]
installSignalHandlers()
startMsg := fmt.Sprintf("USER=%v SUDO_USER=%v %v", os.Getenv("USER"), os.Getenv("SUDO_USER"), strings.Join(os.Args, " "))
if syslogger, err := syslog.New(syslog.LOG_INFO, "vtctl "); err == nil {
syslogger.Info(startMsg)
} else {
log.Warningf("cannot connect to syslog: %v", err)
}
topoServer := topo.GetServer()
defer topo.CloseServers()
wr := wrangler.New(logutil.NewConsoleLogger(), topoServer, *waitTime, *lockWaitTimeout)
err := vtctl.RunCommand(wr, args)
switch err {
case vtctl.ErrUnknownCommand:
flag.Usage()
exit.Return(1)
case nil:
// keep going
default:
log.Errorf("action failed: %v %v", action, err)
exit.Return(255)
}
}
func main() {
flag.Parse()
servenv.Init()
defer servenv.Close()
templateLoader = NewTemplateLoader(*templateDir, dummyTemplate, *debug)
ts = topo.GetServer()
defer topo.CloseServers()
wr := wrangler.New(logutil.NewConsoleLogger(), ts, 30*time.Second, 30*time.Second)
actionRepo = NewActionRepository(ts)
// keyspace actions
actionRepo.RegisterKeyspaceAction("ValidateKeyspace",
func(wr *wrangler.Wrangler, keyspace string, r *http.Request) (string, error) {
return "", wr.ValidateKeyspace(keyspace, false)
})
actionRepo.RegisterKeyspaceAction("ValidateSchemaKeyspace",
func(wr *wrangler.Wrangler, keyspace string, r *http.Request) (string, error) {
return "", wr.ValidateSchemaKeyspace(keyspace, nil, false)
})
actionRepo.RegisterKeyspaceAction("ValidateVersionKeyspace",
func(wr *wrangler.Wrangler, keyspace string, r *http.Request) (string, error) {
return "", wr.ValidateVersionKeyspace(keyspace)
})
actionRepo.RegisterKeyspaceAction("ValidatePermissionsKeyspace",
func(wr *wrangler.Wrangler, keyspace string, r *http.Request) (string, error) {
return "", wr.ValidatePermissionsKeyspace(keyspace)
})
// shard actions
actionRepo.RegisterShardAction("ValidateShard",
func(wr *wrangler.Wrangler, keyspace, shard string, r *http.Request) (string, error) {
return "", wr.ValidateShard(keyspace, shard, false)
})
actionRepo.RegisterShardAction("ValidateSchemaShard",
func(wr *wrangler.Wrangler, keyspace, shard string, r *http.Request) (string, error) {
return "", wr.ValidateSchemaShard(keyspace, shard, nil, false)
})
actionRepo.RegisterShardAction("ValidateVersionShard",
func(wr *wrangler.Wrangler, keyspace, shard string, r *http.Request) (string, error) {
return "", wr.ValidateVersionShard(keyspace, shard)
})
actionRepo.RegisterShardAction("ValidatePermissionsShard",
func(wr *wrangler.Wrangler, keyspace, shard string, r *http.Request) (string, error) {
return "", wr.ValidatePermissionsShard(keyspace, shard)
})
// tablet actions
actionRepo.RegisterTabletAction("Ping", "",
func(wr *wrangler.Wrangler, tabletAlias topo.TabletAlias, r *http.Request) (string, error) {
ti, err := wr.TopoServer().GetTablet(tabletAlias)
if err != nil {
return "", err
}
return "", wr.TabletManagerClient().Ping(wr.Context(), ti)
})
actionRepo.RegisterTabletAction("ScrapTablet", acl.ADMIN,
func(wr *wrangler.Wrangler, tabletAlias topo.TabletAlias, r *http.Request) (string, error) {
// refuse to scrap tablets that are not spare
ti, err := wr.TopoServer().GetTablet(tabletAlias)
if err != nil {
return "", err
}
if ti.Type != topo.TYPE_SPARE {
return "", fmt.Errorf("Can only scrap spare tablets")
}
return "", wr.Scrap(tabletAlias, false, false)
})
actionRepo.RegisterTabletAction("ScrapTabletForce", acl.ADMIN,
func(wr *wrangler.Wrangler, tabletAlias topo.TabletAlias, r *http.Request) (string, error) {
// refuse to scrap tablets that are not spare
ti, err := wr.TopoServer().GetTablet(tabletAlias)
if err != nil {
return "", err
}
if ti.Type != topo.TYPE_SPARE {
return "", fmt.Errorf("Can only scrap spare tablets")
}
return "", wr.Scrap(tabletAlias, true, false)
})
actionRepo.RegisterTabletAction("DeleteTablet", acl.ADMIN,
func(wr *wrangler.Wrangler, tabletAlias topo.TabletAlias, r *http.Request) (string, error) {
return "", wr.DeleteTablet(tabletAlias)
})
// toplevel index
http.HandleFunc("/", func(w http.ResponseWriter, r *http.Request) {
templateLoader.ServeTemplate("index.html", indexContent, w, r)
})
// keyspace actions
http.HandleFunc("/keyspace_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
}
keyspace := r.FormValue("keyspace")
if keyspace == "" {
http.Error(w, "no keyspace provided", http.StatusBadRequest)
return
}
result := actionRepo.ApplyKeyspaceAction(action, keyspace, r)
templateLoader.ServeTemplate("action.html", result, w, r)
})
// shard actions
http.HandleFunc("/shard_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
}
keyspace := r.FormValue("keyspace")
if keyspace == "" {
http.Error(w, "no keyspace provided", http.StatusBadRequest)
return
}
shard := r.FormValue("shard")
if shard == "" {
http.Error(w, "no shard provided", http.StatusBadRequest)
return
}
result := actionRepo.ApplyShardAction(action, keyspace, shard, r)
templateLoader.ServeTemplate("action.html", result, w, r)
})
// tablet actions
http.HandleFunc("/tablet_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
}
alias := r.FormValue("alias")
if alias == "" {
http.Error(w, "no alias provided", http.StatusBadRequest)
return
}
tabletAlias, err := topo.ParseTabletAliasString(alias)
if err != nil {
http.Error(w, "bad alias provided", http.StatusBadRequest)
return
}
result := actionRepo.ApplyTabletAction(action, tabletAlias, r)
templateLoader.ServeTemplate("action.html", result, w, r)
})
// topology server
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 := topotools.DbTopology(context.TODO(), wr.TopoServer())
if err != nil {
result.Error = err.Error()
} else {
result.Topology = topology
}
templateLoader.ServeTemplate("dbtopo.html", result, w, r)
})
// serving graph
http.HandleFunc("/serving_graph/", func(w http.ResponseWriter, r *http.Request) {
parts := strings.Split(r.URL.Path, "/")
cell := parts[len(parts)-1]
if cell == "" {
cells, err := ts.GetKnownCells()
if err != nil {
httpError(w, "cannot get known cells: %v", err)
return
} else {
templateLoader.ServeTemplate("serving_graph_cells.html", cells, w, r)
}
return
}
servingGraph := topotools.DbServingGraph(wr.TopoServer(), cell)
templateLoader.ServeTemplate("serving_graph.html", servingGraph, w, r)
})
// redirects for explorers
http.HandleFunc("/explorers/redirect", func(w http.ResponseWriter, r *http.Request) {
if err := r.ParseForm(); err != nil {
httpError(w, "cannot parse form: %s", err)
return
}
var explorer Explorer
switch len(explorers) {
case 0:
http.Error(w, "no explorer configured", http.StatusInternalServerError)
return
case 1:
for _, ex := range explorers {
explorer = ex
}
default:
explorerName := r.FormValue("explorer")
var ok bool
explorer, ok = explorers[explorerName]
if !ok {
http.Error(w, "bad explorer name", http.StatusBadRequest)
return
}
}
var target string
switch r.FormValue("type") {
case "keyspace":
keyspace := r.FormValue("keyspace")
if keyspace == "" {
http.Error(w, "keyspace is obligatory for this redirect", http.StatusBadRequest)
return
}
target = explorer.GetKeyspacePath(keyspace)
case "shard":
keyspace, shard := r.FormValue("keyspace"), r.FormValue("shard")
if keyspace == "" || shard == "" {
http.Error(w, "keyspace and shard are obligatory for this redirect", http.StatusBadRequest)
return
}
target = explorer.GetShardPath(keyspace, shard)
case "srv_keyspace":
cell := r.FormValue("cell")
if cell == "" {
http.Error(w, "cell is obligatory for this redirect", http.StatusBadRequest)
return
}
keyspace := r.FormValue("keyspace")
if keyspace == "" {
http.Error(w, "keyspace is obligatory for this redirect", http.StatusBadRequest)
return
}
target = explorer.GetSrvKeyspacePath(cell, keyspace)
case "srv_shard":
cell := r.FormValue("cell")
if cell == "" {
http.Error(w, "cell is obligatory for this redirect", http.StatusBadRequest)
return
}
keyspace := r.FormValue("keyspace")
if keyspace == "" {
http.Error(w, "keyspace is obligatory for this redirect", http.StatusBadRequest)
return
}
shard := r.FormValue("shard")
if shard == "" {
http.Error(w, "shard is obligatory for this redirect", http.StatusBadRequest)
return
}
target = explorer.GetSrvShardPath(cell, keyspace, shard)
case "srv_type":
cell := r.FormValue("cell")
if cell == "" {
http.Error(w, "cell is obligatory for this redirect", http.StatusBadRequest)
return
}
keyspace := r.FormValue("keyspace")
if keyspace == "" {
http.Error(w, "keyspace is obligatory for this redirect", http.StatusBadRequest)
return
}
shard := r.FormValue("shard")
if shard == "" {
http.Error(w, "shard is obligatory for this redirect", http.StatusBadRequest)
return
}
tabletType := r.FormValue("tablet_type")
if tabletType == "" {
http.Error(w, "tablet_type is obligatory for this redirect", http.StatusBadRequest)
return
}
target = explorer.GetSrvTypePath(cell, keyspace, shard, topo.TabletType(tabletType))
case "tablet":
aliasName := r.FormValue("alias")
if aliasName == "" {
http.Error(w, "keyspace is obligatory for this redirect", http.StatusBadRequest)
return
}
alias, err := topo.ParseTabletAliasString(aliasName)
if err != nil {
http.Error(w, "bad tablet alias", http.StatusBadRequest)
return
}
target = explorer.GetTabletPath(alias)
case "replication":
cell := r.FormValue("cell")
if cell == "" {
http.Error(w, "cell is obligatory for this redirect", http.StatusBadRequest)
return
}
keyspace := r.FormValue("keyspace")
if keyspace == "" {
http.Error(w, "keyspace is obligatory for this redirect", http.StatusBadRequest)
return
}
shard := r.FormValue("shard")
if shard == "" {
http.Error(w, "shard is obligatory for this redirect", http.StatusBadRequest)
return
}
target = explorer.GetReplicationSlaves(cell, keyspace, shard)
default:
http.Error(w, "bad redirect type", http.StatusBadRequest)
return
}
http.Redirect(w, r, target, http.StatusFound)
})
servenv.RunDefault()
}