Ejemplo n.º 1
0
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, optionKVs string) (
	*mux.Router, error) {
	if server == "" {
		return nil, fmt.Errorf("error: server URL required (-server)")
	}

	if server != "." {
		_, 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)
		}
	}

	options := map[string]string{}
	if optionKVs != "" {
		for _, kv := range strings.Split(optionKVs, ",") {
			a := strings.Split(kv, "=")
			if len(a) >= 2 {
				options[a[0]] = a[1]
			}
		}
	}

	mgr := cbgt.NewManagerEx(cbgt.VERSION, cfg,
		uuid, tags, container, weight,
		extras, bindHttp, dataDir, server, &MainHandlers{}, options)
	err := mgr.Start(register)
	if err != nil {
		return nil, err
	}

	router, _, err :=
		cbft.NewRESTRouter(VERSION, mgr, staticDir, staticETag, mr)

	// register handlers needed by ns_server
	router.Handle("/api/nsstats", cbft.NewNsStatsHandler(mgr))
	nsStatusHandler, err := cbft.NewNsStatusHandler(mgr, server)
	if err != nil {
		return nil, err
	}
	router.Handle("/api/nsstatus", nsStatusHandler)

	return router, err
}
Ejemplo n.º 2
0
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
}