// 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 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{}
}
// NewScanCoordinator returns an instance of scanCoordinator or err message
// It listens on supvCmdch for command and every command is followed
// by a synchronous response on the supvCmdch.
// Any async message to supervisor is sent to supvMsgch.
// If supvCmdch get closed, ScanCoordinator will shut itself down.
func NewScanCoordinator(supvCmdch MsgChannel, supvMsgch MsgChannel,
config common.Config, snapshotNotifych chan IndexSnapshot) (ScanCoordinator, Message) {
var err error
s := &scanCoordinator{
supvCmdch: supvCmdch,
supvMsgch: supvMsgch,
lastSnapshot: make(map[common.IndexInstId]IndexSnapshot),
snapshotNotifych: snapshotNotifych,
logPrefix: "ScanCoordinator",
reqCounter: platform.NewAlignedUint64(0),
}
s.config.Store(config)
addr := net.JoinHostPort("", config["scanPort"].String())
queryportCfg := config.SectionConfig("queryport.", true)
s.serv, err = queryport.NewServer(addr, s.serverCallback, queryportCfg)
if err != nil {
errMsg := &MsgError{err: Error{code: ERROR_SCAN_COORD_QUERYPORT_FAIL,
severity: FATAL,
category: SCAN_COORD,
cause: err,
},
}
return nil, errMsg
}
// main loop
go s.run()
go s.listenSnapshot()
return s, &MsgSuccess{}
}