// ResetConfig accepts a full-set or subset of global configuration
// and updates projector related fields.
func (p *Projector) ResetConfig(config c.Config) {
p.rw.Lock()
defer p.rw.Unlock()
defer logging.Infof("%v\n", c.LogRuntime())
// reset configuration.
if cv, ok := config["projector.settings.log_level"]; ok {
logging.SetLogLevel(logging.Level(cv.String()))
}
if cv, ok := config["projector.maxCpuPercent"]; ok {
c.SetNumCPUs(cv.Int())
}
p.config = p.config.Override(config)
// CPU-profiling
cpuProfile, ok := config["projector.cpuProfile"]
if ok && cpuProfile.Bool() && p.cpuProfFd == nil {
cpuProfFname, ok := config["projector.cpuProfFname"]
if ok {
fname := cpuProfFname.String()
logging.Infof("%v cpu profiling => %q\n", p.logPrefix, fname)
p.cpuProfFd = p.startCPUProfile(fname)
} else {
logging.Errorf("Missing cpu-profile o/p filename\n")
}
} else if ok && !cpuProfile.Bool() {
if p.cpuProfFd != nil {
pprof.StopCPUProfile()
logging.Infof("%v cpu profiling stopped\n", p.logPrefix)
}
p.cpuProfFd = nil
} else if ok {
logging.Warnf("%v cpu profiling already active !!\n", p.logPrefix)
}
// MEM-profiling
memProfile, ok := config["projector.memProfile"]
if ok && memProfile.Bool() {
memProfFname, ok := config["projector.memProfFname"]
if ok {
fname := memProfFname.String()
if p.takeMEMProfile(fname) {
logging.Infof("%v mem profile => %q\n", p.logPrefix, fname)
}
} else {
logging.Errorf("Missing mem-profile o/p filename\n")
}
}
}
func (s *settingsManager) metaKVCallback(path string, value []byte, rev interface{}) error {
if path == common.IndexingSettingsMetaPath {
logging.Infof("New settings received: \n%s", string(value))
config := s.config.Clone()
config.Update(value)
setBlockPoolSize(s.config, config)
s.config = config
ncpu := common.SetNumCPUs(config["indexer.settings.max_cpu_percent"].Int())
logging.Infof("Setting maxcpus = %d", ncpu)
setLogger(config)
indexerConfig := s.config.SectionConfig("indexer.", true)
s.supvMsgch <- &MsgConfigUpdate{
cfg: indexerConfig,
}
} else if path == indexCompactonMetaPath {
currentToken := s.compactionToken
s.compactionToken = value
if bytes.Equal(currentToken, value) {
return nil
}
logging.Infof("Manual compaction trigger requested")
replych := make(chan []IndexStorageStats)
statReq := &MsgIndexStorageStats{respch: replych}
s.supvMsgch <- statReq
stats := <-replych
// XXX: minFile size check can be applied
go func() {
for _, is := range stats {
errch := make(chan error)
compactReq := &MsgIndexCompact{
instId: is.InstId,
errch: errch,
}
logging.Infof("ManualCompaction: Compacting index instance:%v", is.InstId)
s.supvMsgch <- compactReq
err := <-errch
if err == nil {
logging.Infof("ManualCompaction: Finished compacting index instance:%v", is.InstId)
} else {
logging.Errorf("ManualCompaction: Index instance:%v Compaction failed with reason - %v", is.InstId, err)
}
}
}()
}
return 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{}
}