// 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
}
}