func MainStart(cfg cbgt.Cfg, uuid string, tags []string, container string,
weight int, extras, bindHttp, dataDir, staticDir, staticETag, server string,
register string, mr *cbgt.MsgRing, options map[string]string) (
*mux.Router, error) {
if server == "" {
return nil, fmt.Errorf("error: server URL required (-server)")
}
err := InitOptions(options)
if err != nil {
return nil, err
}
err = InitMossOptions(options)
if err != nil {
return nil, err
}
err = InitBleveOptions(options)
if err != nil {
return nil, err
}
if options["logStatsEvery"] != "" {
logStatsEvery, err := strconv.Atoi(options["logStatsEvery"])
if err != nil {
return nil, err
}
if logStatsEvery >= 0 {
cbft.LogEveryNStats = logStatsEvery
}
}
err = cbft.InitResultCacheOptions(options)
if err != nil {
return nil, err
}
err = cbft.InitBleveResultCacheOptions(options)
if err != nil {
return nil, err
}
exitCode := MainTool(cfg, uuid, tags, flags, options)
if exitCode >= 0 {
os.Exit(exitCode)
}
if server != "." && options["startCheckServer"] != "skip" {
_, err := couchbase.Connect(server)
if err != nil {
if !strings.HasPrefix(server, "http://") &&
!strings.HasPrefix(server, "https://") {
return nil, fmt.Errorf("error: not a URL, server: %q\n"+
" Please check that your -server parameter"+
" is a valid URL\n"+
" (http://HOST:PORT),"+
" such as \"http://*****:*****@HOST:PORT)",
server, err, server)
}
}
meh := &MainHandlers{}
mgr := cbgt.NewManagerEx(cbgt.VERSION, cfg,
uuid, tags, container, weight,
extras, bindHttp, dataDir, server, meh, options)
meh.mgr = mgr
err = mgr.Start(register)
if err != nil {
return nil, err
}
var adtSvc *audit.AuditSvc
if options["cbaudit"] == "true" {
adtSvc, _ = audit.NewAuditSvc(server)
}
router, _, err :=
cbft.NewRESTRouter(VERSION, mgr, staticDir, staticETag, mr,
adtSvc)
// register handlers needed by ns_server
prefix := mgr.Options()["urlPrefix"]
router.Handle(prefix+"/api/nsstats", cbft.NewNsStatsHandler(mgr))
nsStatusHandler, err := cbft.NewNsStatusHandler(mgr, server)
if err != nil {
return nil, err
}
router.Handle(prefix+"/api/nsstatus", nsStatusHandler)
nsSearchResultRedirectHandler, err := cbft.NsSearchResultRedirctHandler(mgr)
if err != nil {
return nil, err
}
router.Handle(prefix+"/api/nsSearchResultRedirect/{pIndexName}/{docID}", nsSearchResultRedirectHandler)
cbAuthBasicLoginHadler, err := cbft.CBAuthBasicLoginHandler(mgr)
if err != nil {
return nil, err
}
router.Handle(prefix+"/login", cbAuthBasicLoginHadler)
// ------------------------------------------------
tagsMap := mgr.TagsMap()
if tagsMap != nil && tagsMap["cbauth_service"] {
dryRun := false
dryRunV := mgr.Options()["cbauth_service.dryRun"]
if dryRunV != "" {
dryRun, err = strconv.ParseBool(dryRunV)
if err != nil {
return nil, err
}
}
waitForMemberNodes := 30 // In seconds.
waitForMemberNodesV := mgr.Options()["cbauth_service.waitForMemberNodes"]
if waitForMemberNodesV != "" {
waitForMemberNodes, err = strconv.Atoi(waitForMemberNodesV)
if err != nil {
return nil, err
}
}
verbose := DefaultCtlVerbose
verboseV := mgr.Options()["cbauth_service.verbose"]
if verboseV != "" {
verbose, err = strconv.Atoi(verboseV)
if err != nil {
return nil, err
}
}
log.Printf("main: cbauth_service ctl starting,"+
" dryRun: %v, waitForMemberNodes: %d, verbose: %d",
dryRun, waitForMemberNodes, verbose)
c, err := ctl.StartCtl(cfg, server, mgr.Options(), ctl.CtlOptions{
DryRun: dryRun,
Verbose: verbose,
FavorMinNodes: false,
WaitForMemberNodes: waitForMemberNodes,
})
if err != nil {
return nil, fmt.Errorf("main: ctl.StartCtl, err: %v", err)
}
nodeInfo := &service.NodeInfo{
NodeID: service.NodeID(uuid),
}
err = cfg.Refresh()
if err != nil {
return nil, err
}
ctlMgr := ctl.NewCtlMgr(nodeInfo, c)
if ctlMgr != nil {
go func() {
log.Printf("main: cbauth_service registering...")
err := service.RegisterManager(ctlMgr, nil)
if err != nil {
log.Printf("main: cbauth_service register err: %v", err)
return
}
log.Printf("main: cbauth_service registering... done")
}()
}
}
// ------------------------------------------------
return router, err
}
func main() {
flag.Parse()
if flags.Help {
flag.Usage()
os.Exit(2)
}
if flags.Version {
fmt.Printf("%s main: %s, data: %s\n",
path.Base(os.Args[0]), cbgt.VERSION, cbgt.VERSION)
os.Exit(0)
}
cmd.MainCommon(cbgt.VERSION, flagAliases)
cfg, err := cmd.MainCfgClient(path.Base(os.Args[0]), flags.CfgConnect)
if err != nil {
log.Fatalf("%v", err)
return
}
if flags.IndexTypes != "" {
cmd.RegisterIndexTypes(strings.Split(flags.IndexTypes, ","))
}
nodesToRemove := []string(nil)
if len(flags.RemoveNodes) > 0 {
nodesToRemove = strings.Split(flags.RemoveNodes, ",")
}
steps := map[string]bool{}
if flags.Steps != "" {
steps = cbgt.StringsToMap(strings.Split(flags.Steps, ","))
}
// ------------------------------------------------
if steps != nil && steps["rebalance"] {
steps["rebalance_"] = true
steps["unregister"] = true
steps["planner"] = true
}
// ------------------------------------------------
if steps != nil && steps["rebalance_"] {
log.Printf("main: step rebalance_")
err := rebalance.RunRebalance(cfg, flags.Server, nodesToRemove,
flags.FavorMinNodes, flags.DryRun, flags.Verbose, nil)
if err != nil {
log.Fatalf("main: RunRebalance, err: %v", err)
return
}
}
// ------------------------------------------------
err = cmd.PlannerSteps(steps, cfg, cbgt.VERSION,
flags.Server, nodesToRemove, flags.DryRun, nil)
if err != nil {
log.Fatalf("main: PlannerSteps, err: %v", err)
return
}
// ------------------------------------------------
var c *ctl.Ctl
if steps != nil && (steps["service"] || steps["rest"] || steps["prompt"]) {
c, err = ctl.StartCtl(cfg, flags.Server, ctl.CtlOptions{
DryRun: flags.DryRun,
Verbose: flags.Verbose,
FavorMinNodes: flags.FavorMinNodes,
WaitForMemberNodes: flags.WaitForMemberNodes,
})
if err != nil {
log.Fatalf("main: StartCtl, err: %v", err)
return
}
if steps["service"] {
// TODO.
}
if steps["rest"] {
bindHttp := flags.BindHttp
if bindHttp[0] == ':' {
bindHttp = "localhost" + bindHttp
}
if strings.HasPrefix(bindHttp, "0.0.0.0:") {
bindHttp = "localhost" + bindHttp[len("0.0.0.0"):]
}
http.Handle("/", newRestRouter(c))
go func() {
log.Printf("------------------------------------------------------------")
log.Printf("REST API is available: http://%s", bindHttp)
log.Printf("------------------------------------------------------------")
err := http.ListenAndServe(bindHttp, nil) // Blocks.
if err != nil {
log.Fatalf("main: listen, err: %v\n"+
" Please check that your -bindHttp parameter (%q)\n"+
" is correct and available.", err, bindHttp)
}
}()
}
if steps["prompt"] {
go runCtlPrompt(c)
}
<-make(chan struct{})
}
// ------------------------------------------------
log.Printf("main: done")
}
