func ReadParsingConfig(s ServerContext, w http.ResponseWriter, r *http.Request) {
name := mux.Vars(r)["name"]
repo := s.GetRepository()
combainerCfg := repo.GetCombainerConfig()
var parsingCfg configs.ParsingConfig
cfg, err := repo.GetParsingConfig(name)
if err != nil {
fmt.Fprintf(w, "%s", err)
return
}
err = cfg.Decode(&parsingCfg)
if err != nil {
fmt.Fprintf(w, "%s", err)
return
}
parsingCfg.UpdateByCombainerConfig(&combainerCfg)
aggregationConfigs, err := GetAggregationConfigs(repo, &parsingCfg)
if err != nil {
log.Errorf("Unable to read aggregation configs: %s", err)
return
}
data, err := common.Encode(&parsingCfg)
if err != nil {
fmt.Fprintf(w, "%s", err)
return
}
fmt.Fprintf(w, "============ %s ============\n", name)
fmt.Fprintf(w, "%s", data)
for aggname, v := range *aggregationConfigs {
fmt.Fprintf(w, "============ %s ============\n", aggname)
d, err := common.Encode(&v)
if err != nil {
fmt.Fprintf(w, "%s", err)
return
}
fmt.Fprintf(w, "%s\n", d)
}
}
func (cl *Client) UpdateSessionParams(config string) (sp *sessionParams, err error) {
startTime := time.Now()
defer cl.Stats.timingPreparing.UpdateSince(startTime)
cl.Log.WithFields(logrus.Fields{
"config": config,
}).Info("updating session parametrs")
var (
// tasks
pTasks []tasks.ParsingTask
aggTasks []tasks.AggregationTask
// timeouts
parsingTime time.Duration
wholeTime time.Duration
)
encodedParsingConfig, err := cl.Repository.GetParsingConfig(config)
if err != nil {
cl.Log.WithFields(logrus.Fields{
"config": config,
"error": err,
}).Error("unable to load config")
return nil, err
}
var parsingConfig configs.ParsingConfig
if err := encodedParsingConfig.Decode(&parsingConfig); err != nil {
cl.Log.WithFields(logrus.Fields{
"config": config,
"error": err,
}).Error("unable to decode parsingConfig")
return nil, err
}
cfg := cl.Repository.GetCombainerConfig()
parsingConfig.UpdateByCombainerConfig(&cfg)
aggregationConfigs, err := GetAggregationConfigs(cl.Repository, &parsingConfig)
if err != nil {
cl.Log.WithFields(logrus.Fields{
"config": config,
"error": err,
}).Error("unable to read aggregation configs")
return nil, err
}
cl.Log.Infof("updating config: group %s, metahost %s",
parsingConfig.GetGroup(), parsingConfig.GetMetahost())
hostFetcher, err := LoadHostFetcher(cl.Context, parsingConfig.HostFetcher)
if err != nil {
cl.Log.WithFields(logrus.Fields{
"config": config,
"error": err,
}).Error("Unable to construct SimpleFetcher")
return
}
allHosts := make(hosts.Hosts)
for _, item := range parsingConfig.Groups {
hosts_for_group, err := hostFetcher.Fetch(item)
if err != nil {
cl.Log.WithFields(logrus.Fields{
"config": config,
"error": err,
"group": item,
}).Warn("unable to get hosts")
continue
}
allHosts.Merge(&hosts_for_group)
}
listOfHosts := allHosts.AllHosts()
if len(listOfHosts) == 0 {
err := fmt.Errorf("No hosts in given groups")
cl.Log.WithFields(logrus.Fields{
"config": config,
"group": parsingConfig.Groups,
}).Warn("no hosts in given groups")
return nil, err
}
cl.Log.WithFields(logrus.Fields{
"config": config,
}).Infof("hosts: %s", listOfHosts)
// Tasks for parsing
for _, host := range listOfHosts {
pTasks = append(pTasks, tasks.ParsingTask{
CommonTask: tasks.EmptyCommonTask,
Host: host,
ParsingConfigName: config,
ParsingConfig: parsingConfig,
AggregationConfigs: *aggregationConfigs,
})
}
for _, name := range parsingConfig.AggConfigs {
aggTasks = append(aggTasks, tasks.AggregationTask{
CommonTask: tasks.EmptyCommonTask,
Config: name,
ParsingConfigName: config,
ParsingConfig: parsingConfig,
AggregationConfig: (*aggregationConfigs)[name],
Hosts: allHosts,
})
}
parsingTime, wholeTime = GenerateSessionTimeFrame(parsingConfig.IterationDuration)
if parsingTime == 0 || wholeTime == 0 {
return nil, err
}
sp = &sessionParams{
ParsingTime: parsingTime,
WholeTime: wholeTime,
PTasks: pTasks,
AggTasks: aggTasks,
}
cl.Log.WithFields(logrus.Fields{
"config": config,
}).Infof("Session parametrs have been updated successfully. %v", sp)
return sp, nil
}