// NewProjector creates a news projector instance and // starts a corresponding adminport. func NewProjector(maxvbs int, config c.Config) *Projector { p := &Projector{ topics: make(map[string]*Feed), topicSerialize: make(map[string]*sync.Mutex), maxvbs: maxvbs, pooln: "default", // TODO: should this be configurable ? } // Setup dynamic configuration propagation config, err := c.GetSettingsConfig(config) c.CrashOnError(err) pconfig := config.SectionConfig("projector.", true /*trim*/) p.name = pconfig["name"].String() p.clusterAddr = pconfig["clusterAddr"].String() p.adminport = pconfig["adminport.listenAddr"].String() ef := config["projector.routerEndpointFactory"] config["projector.routerEndpointFactory"] = ef p.config = config p.ResetConfig(config) p.logPrefix = fmt.Sprintf("PROJ[%s]", p.adminport) callb := func(cfg c.Config) { logging.Infof("%v settings notifier from metakv\n", p.logPrefix) cfg.LogConfig(p.logPrefix) p.ResetConfig(cfg) } c.SetupSettingsNotifier(callb, make(chan struct{})) cluster := p.clusterAddr if !strings.HasPrefix(p.clusterAddr, "http://") { cluster = "http://" + cluster } apConfig := config.SectionConfig("projector.adminport.", true) apConfig.SetValue("name", "PRAM") reqch := make(chan ap.Request) p.admind = ap.NewHTTPServer(apConfig, reqch) watchInterval := config["projector.watchInterval"].Int() staleTimeout := config["projector.staleTimeout"].Int() go p.mainAdminPort(reqch) go p.watcherDameon(watchInterval, staleTimeout) logging.Infof("%v started ...\n", p.logPrefix) return p }
func getSingletonClient(clusterURL string) (*qclient.GsiClient, error) { muclient.Lock() defer muclient.Unlock() if singletonClient == nil { l.Debugf("creating singleton for URL %v", clusterURL) conf, err := c.GetSettingsConfig(c.SystemConfig) if err != nil { return nil, err } qconf := conf.SectionConfig("queryport.client.", true /*trim*/) client, err := qclient.NewGsiClient(clusterURL, qconf) if err != nil { return nil, fmt.Errorf("in NewGsiClient(): %v", err) } singletonClient = client } return singletonClient, nil }
func NewSettingsManager(supvCmdch MsgChannel, supvMsgch MsgChannel, config common.Config) (settingsManager, common.Config, Message) { s := settingsManager{ supvCmdch: supvCmdch, supvMsgch: supvMsgch, config: config, cancelCh: make(chan struct{}), } config, err := common.GetSettingsConfig(config) if err != nil { return s, nil, &MsgError{ err: Error{ category: INDEXER, cause: err, severity: FATAL, }} } ncpu := common.SetNumCPUs(config["indexer.settings.max_cpu_percent"].Int()) logging.Infof("Setting maxcpus = %d", ncpu) setBlockPoolSize(nil, config) setLogger(config) http.HandleFunc("/settings", s.handleSettingsReq) http.HandleFunc("/triggerCompaction", s.handleCompactionTrigger) go func() { for { err := metakv.RunObserveChildren("/", s.metaKVCallback, s.cancelCh) if err == nil { return } else { logging.Errorf("IndexerSettingsManager: metakv notifier failed (%v)..Restarting", err) } } }() indexerConfig := config.SectionConfig("indexer.", true) return s, indexerConfig, &MsgSuccess{} }
func (s *settingsManager) handleSettingsReq(w http.ResponseWriter, r *http.Request) { if !s.validateAuth(w, r) { return } if r.Method == "POST" { bytes, _ := ioutil.ReadAll(r.Body) config := s.config.FilterConfig(".settings.") current, rev, err := metakv.Get(common.IndexingSettingsMetaPath) if err == nil { if len(current) > 0 { config.Update(current) } err = config.Update(bytes) } if err != nil { s.writeError(w, err) return } //settingsConfig := config.FilterConfig(".settings.") newSettingsBytes := config.Json() if err = metakv.Set(common.IndexingSettingsMetaPath, newSettingsBytes, rev); err != nil { s.writeError(w, err) return } s.writeOk(w) } else if r.Method == "GET" { settingsConfig, err := common.GetSettingsConfig(s.config) if err != nil { s.writeError(w, err) return } s.writeJson(w, settingsConfig.FilterConfig(".settings.").Json()) } else { s.writeError(w, errors.New("Unsupported method")) return } }