func initLogger(lgr_cfg *LoggerConfig) (adaptor.Logger, error) {
options := make([]func(*logger.GologgingLogger), 0)
if lgr_cfg.Console_enabled != false {
enabled := lgr_cfg.Console_enabled
options = append(options, logger.SetConsoleEnabled(enabled))
}
if lgr_cfg.Console_format != "" {
format, err := logger.ParseFormat(lgr_cfg.Console_format)
if err == nil {
options = append(options, logger.SetConsoleFormat(format))
}
}
if lgr_cfg.Console_level != "" {
level, err := logger.ParseLevel(lgr_cfg.Console_level)
if err == nil {
options = append(options, logger.SetConsoleLevel(level))
}
}
if lgr_cfg.File_enabled != false {
enabled := lgr_cfg.File_enabled
options = append(options, logger.SetFileEnabled(enabled))
}
if lgr_cfg.File_format != "" {
format, err := logger.ParseFormat(lgr_cfg.File_format)
if err == nil {
options = append(options, logger.SetFileFormat(format))
}
}
if lgr_cfg.File_level != "" {
level, err := logger.ParseLevel(lgr_cfg.File_level)
if err == nil {
options = append(options, logger.SetFileLevel(level))
}
}
if lgr_cfg.File_path != "" {
path := lgr_cfg.File_path
options = append(options, logger.SetFilePath(path))
}
return logger.NewGologging(options...)
}
func New() (*Supervisor, error) {
// load configuration file
cfg := &Config{}
err := gcfg.ReadFileInto(cfg, "pbtc.cfg")
if err != nil {
return nil, err
}
// initialize struct with maps
supervisor := &Supervisor{
logr: make(map[string]adaptor.Logger),
repo: make(map[string]adaptor.Repository),
tkr: make(map[string]adaptor.Tracker),
svr: make(map[string]adaptor.Server),
pro: make(map[string]adaptor.Processor),
mgr: make(map[string]adaptor.Manager),
}
if len(cfg.Logger) == 0 {
logr, err := logger.New()
if err != nil {
return nil, err
}
supervisor.logr[""] = logr
} else if cfg.Logger[""] == nil {
for _, logr_cfg := range cfg.Logger {
logr, err := initLogger(logr_cfg)
if err != nil {
return nil, err
}
supervisor.logr[""] = logr
break
}
} else {
logr_cfg := cfg.Logger[""]
logr, err := initLogger(logr_cfg)
if err != nil {
return nil, err
}
supervisor.logr[""] = logr
}
level, err := logger.ParseLevel(cfg.Supervisor.Log_level)
if err != nil {
level = logging.CRITICAL
}
supervisor.log = supervisor.logr[""].GetLog("supervisor")
supervisor.logr[""].SetLevel("supervisor", level)
supervisor.log.Info("[SUP] Init: started")
supervisor.log.Info("[SUP] Init: default logger initialized")
supervisor.log.Info("[SUP] Init: initializing modules")
// initialize remaining modules
for name, logr_cfg := range cfg.Logger {
if name == "" {
continue
}
logr, err := initLogger(logr_cfg)
if err != nil {
supervisor.log.Warning("[SUP] Init: logger init failed (%v)", err)
continue
}
supervisor.logr[name] = logr
}
for name, repo_cfg := range cfg.Repository {
repo, err := initRepository(repo_cfg)
if err != nil {
supervisor.log.Warning("[SUP] Init: repo init failed (%v)", err)
continue
}
supervisor.repo[name] = repo
}
for name, tkr_cfg := range cfg.Tracker {
tkr, err := initTracker(tkr_cfg)
if err != nil {
supervisor.log.Warning("[SUP] Init: tracker init failed (%v)", err)
continue
}
supervisor.tkr[name] = tkr
}
for name, svr_cfg := range cfg.Server {
svr, err := initServer(svr_cfg)
if err != nil {
supervisor.log.Warning("[SUP] Init: server init failed (%v)", err)
continue
}
supervisor.svr[name] = svr
}
for name, pro_cfg := range cfg.Processor {
pro, err := initProcessor(pro_cfg)
if err != nil {
supervisor.log.Warning("[SUP] Init: proc init failed (%v)", err)
continue
}
supervisor.pro[name] = pro
}
for name, mgr_cfg := range cfg.Manager {
mgr, err := initManager(mgr_cfg)
if err != nil {
supervisor.log.Warning("[SUP] Init: manager init failed (%v)", err)
continue
}
supervisor.mgr[name] = mgr
}
supervisor.log.Info("[SUP] Init: checking module cardinality")
// check remaining modules for missing values
if len(supervisor.repo) == 0 {
supervisor.log.Warning("[SUP] Init: missing repository module")
repo, err := repository.New()
if err != nil {
return nil, err
}
supervisor.repo["default"] = repo
}
if len(supervisor.tkr) == 0 {
supervisor.log.Warning("[SUP] Init: missing tracker module")
tkr, err := tracker.New()
if err != nil {
return nil, err
}
supervisor.tkr["default"] = tkr
}
if len(supervisor.mgr) == 0 {
supervisor.log.Warning("[SUP] Init: missing manager module")
mgr, err := manager.New()
if err != nil {
return nil, err
}
supervisor.mgr["default"] = mgr
}
if len(supervisor.svr) == 0 {
supervisor.log.Notice("[SUP] Init: no server module")
}
if len(supervisor.pro) == 0 {
supervisor.log.Notice("[SUP] Init: no processor module")
}
supervisor.log.Info("[SUP] Init: injecting logging capabilities")
// inject logging dependencies
for key, logr := range supervisor.logr {
logr_cfg, ok := cfg.Logger[key]
if !ok {
continue
}
level, err := logger.ParseLevel(logr_cfg.Log_level)
if err != nil {
level = logging.CRITICAL
}
log := "logr___" + key
logr.SetLog(logr.GetLog(log))
logr.SetLevel(log, level)
}
for key, repo := range supervisor.repo {
repo_cfg, ok := cfg.Repository[key]
if !ok {
continue
}
logr, ok := supervisor.logr[repo_cfg.Logger]
if !ok {
logr = supervisor.logr[""]
}
level, err := logger.ParseLevel(repo_cfg.Log_level)
if err != nil {
level = logging.CRITICAL
}
log := "repo___" + key
repo.SetLog(logr.GetLog(log))
logr.SetLevel(log, level)
}
for key, tkr := range supervisor.tkr {
tkr_cfg, ok := cfg.Tracker[key]
if !ok {
continue
}
logr, ok := supervisor.logr[tkr_cfg.Logger]
if !ok {
logr = supervisor.logr[""]
}
level, err := logger.ParseLevel(tkr_cfg.Log_level)
if err != nil {
level = logging.CRITICAL
}
log := "tkr___" + key
tkr.SetLog(logr.GetLog(log))
logr.SetLevel(log, level)
}
for key, svr := range supervisor.svr {
svr_cfg, ok := cfg.Server[key]
if !ok {
continue
}
logr, ok := supervisor.logr[svr_cfg.Logger]
if !ok {
logr = supervisor.logr[""]
}
level, err := logger.ParseLevel(svr_cfg.Log_level)
if err != nil {
level = logging.CRITICAL
}
log := "svr___" + key
svr.SetLog(logr.GetLog(log))
logr.SetLevel(log, level)
}
for key, pro := range supervisor.pro {
pro_cfg, ok := cfg.Processor[key]
if !ok {
continue
}
logr, ok := supervisor.logr[pro_cfg.Logger]
if !ok {
logr = supervisor.logr[""]
}
level, err := logger.ParseLevel(pro_cfg.Log_level)
if err != nil {
level = logging.CRITICAL
}
log := "pro___" + key
pro.SetLog(logr.GetLog(log))
logr.SetLevel(log, level)
}
for key, mgr := range supervisor.mgr {
mgr_cfg, ok := cfg.Manager[key]
if !ok {
continue
}
logr, ok := supervisor.logr[mgr_cfg.Logger]
if !ok {
logr = supervisor.logr[""]
}
level, err := logger.ParseLevel(mgr_cfg.Log_level)
if err != nil {
level = logging.CRITICAL
}
log := "mgr___" + key
mgr.SetLog(logr.GetLog(log))
logr.SetLevel(log, level)
}
supervisor.log.Info("[SUP] Init: injecting module dependencies")
// inject manager into server
for key, svr := range supervisor.svr {
svr_cfg, ok := cfg.Server[key]
if !ok {
continue
}
mgr, ok := supervisor.mgr[svr_cfg.Manager]
if !ok {
for _, def := range supervisor.mgr {
mgr = def
break
}
}
svr.SetManager(mgr)
}
// inject repository into manager
for key, mgr := range supervisor.mgr {
mgr_cfg, ok := cfg.Manager[key]
if !ok {
continue
}
repo, ok := supervisor.repo[mgr_cfg.Repository]
if !ok {
for _, def := range supervisor.repo {
repo = def
break
}
}
mgr.SetRepository(repo)
}
// inject tracker into manager
for key, mgr := range supervisor.mgr {
mgr_cfg, ok := cfg.Manager[key]
if !ok {
continue
}
tkr, ok := supervisor.tkr[mgr_cfg.Tracker]
if !ok {
for _, def := range supervisor.tkr {
tkr = def
break
}
}
mgr.SetTracker(tkr)
}
// inject processors into managers
for key, mgr := range supervisor.mgr {
mgr_cfg, ok := cfg.Manager[key]
if !ok {
continue
}
for _, name := range mgr_cfg.Processor {
pro, ok := supervisor.pro[name]
if !ok {
continue
}
mgr.AddProcessor(pro)
}
}
// inject processors into processors
for key, pro := range supervisor.pro {
pro_cfg, ok := cfg.Processor[key]
if !ok {
continue
}
for _, name := range pro_cfg.Next {
next, ok := supervisor.pro[name]
if !ok {
continue
}
pro.AddNext(next)
}
}
supervisor.log.Info("[SUP] Init: completed")
return supervisor, nil
}