From 1fd6c7e4f4950fc556accb27c5b23233bc04a924 Mon Sep 17 00:00:00 2001 From: balandi1 Date: Wed, 13 Nov 2019 11:19:04 -0500 Subject: [PATCH 01/48] Initial elektromLogging library --- elektronLogging/ElektronFormatter.go | 53 +++++++++++++++ .../clsfnTaskDistOverheadLogger.go | 53 +++++++++++++++ elektronLogging/consoleLogger.go | 48 +++++++++++++ elektronLogging/createLogDir.go | 38 +++++++++++ elektronLogging/logger.go | 48 +++++++++++++ elektronLogging/loggerChain.go | 37 ++++++++++ elektronLogging/loggerConfig.go | 68 +++++++++++++++++++ elektronLogging/pcpLogger.go | 52 ++++++++++++++ elektronLogging/schedPolicySwitchLogger.go | 53 +++++++++++++++ elektronLogging/schedTraceLogger.go | 53 +++++++++++++++ elektronLogging/schedWindowLogger.go | 51 ++++++++++++++ elektronLogging/types/types.go | 17 +++++ 12 files changed, 571 insertions(+) create mode 100644 elektronLogging/ElektronFormatter.go create mode 100644 elektronLogging/clsfnTaskDistOverheadLogger.go create mode 100644 elektronLogging/consoleLogger.go create mode 100644 elektronLogging/createLogDir.go create mode 100644 elektronLogging/logger.go create mode 100644 elektronLogging/loggerChain.go create mode 100644 elektronLogging/loggerConfig.go create mode 100644 elektronLogging/pcpLogger.go create mode 100644 elektronLogging/schedPolicySwitchLogger.go create mode 100644 elektronLogging/schedTraceLogger.go create mode 100644 elektronLogging/schedWindowLogger.go create mode 100644 elektronLogging/types/types.go diff --git a/elektronLogging/ElektronFormatter.go b/elektronLogging/ElektronFormatter.go new file mode 100644 index 0000000..a929e56 --- /dev/null +++ b/elektronLogging/ElektronFormatter.go @@ -0,0 +1,53 @@ +package elektronLogging + +import ( + "bytes" + "fmt" + "strings" + "github.com/fatih/color" + log "github.com/sirupsen/logrus" +) + +type ElektronFormatter struct { + TimestampFormat string +} + +func (f ElektronFormatter) getColor(entry *log.Entry) *color.Color { + switch entry.Level { + case log.InfoLevel: + return color.New(color.FgGreen, color.Bold) + case log.WarnLevel: + return color.New(color.FgYellow, color.Bold) + case log.ErrorLevel: + return color.New(color.FgRed, color.Bold) + case log.FatalLevel: + return color.New(color.FgRed, color.Bold) + default: + return color.New(color.FgWhite, color.Bold) + } +} +func (f ElektronFormatter) Format(entry *log.Entry) ([]byte, error) { + var b *bytes.Buffer + + if entry.Buffer != nil { + b = entry.Buffer + } else { + b = &bytes.Buffer{} + } + + levelColor := f.getColor(entry) + level := levelColor.Sprintf("[%s]:",strings.ToUpper(entry.Level.String())) + message := fmt.Sprintf("%s %s %s ",level,entry.Time.Format(f.TimestampFormat), entry.Message) + + var formattedFields []string + for key, value := range entry.Data { + formattedFields = append(formattedFields, + strings.Join([]string{key, fmt.Sprintf("%s", value)}, "=")) + } + + + b.WriteString(message) + b.WriteString(strings.Join(formattedFields, ", ")) + b.WriteByte('\n') + return b.Bytes(), nil +} diff --git a/elektronLogging/clsfnTaskDistOverheadLogger.go b/elektronLogging/clsfnTaskDistOverheadLogger.go new file mode 100644 index 0000000..76191e7 --- /dev/null +++ b/elektronLogging/clsfnTaskDistOverheadLogger.go @@ -0,0 +1,53 @@ +package elektronLogging + +import ( + //"fmt" + "os" + logrus "github.com/sirupsen/logrus" + data "gitlab.com/spdf/elektron/elektronLogging/data" +) + +type ClsfnTaskDistOverheadLogger struct { + LoggerImpl +} + +func NewClsfnTaskDistOverheadLogger(logType int, prefix string) *ClsfnTaskDistOverheadLogger { + cLog := new(ClsfnTaskDistOverheadLogger) + cLog.Type = logType + cLog.SetLogFile(prefix) + return cLog +} + +func (cLog *ClsfnTaskDistOverheadLogger) Log(logType int, level logrus.Level, logData data.LogData,message string) { + if cLog.Type == logType { + + logFields := cloneFields(logData) + + log.SetLevel(level) + + if cLog.AllowOnConsole { + log.SetOutput(os.Stdout) + log.WithFields(logFields).Println(message) + } + + log.SetOutput(cLog.LogFileName) + log.WithFields(logFields).Println(message) + } + if cLog.next != nil { + cLog.next.Log(logType, level, logData, message) + } +} + +func (cLog *ClsfnTaskDistOverheadLogger) SetLogFile(prefix string) { + + tskDistLogPrefix := prefix + config.TaskDistConfig.FilenameExtension + if logDir != "" { + tskDistLogPrefix = logDir + "/" + tskDistLogPrefix + } + if logFile, err := os.Create(tskDistLogPrefix); err != nil { + logrus.Fatal("Unable to create logFile: ", err) + } else { + cLog.LogFileName = logFile + cLog.AllowOnConsole = config.TaskDistConfig.AllowOnConsole + } +} diff --git a/elektronLogging/consoleLogger.go b/elektronLogging/consoleLogger.go new file mode 100644 index 0000000..b053e42 --- /dev/null +++ b/elektronLogging/consoleLogger.go @@ -0,0 +1,48 @@ +package elektronLogging + +import ( + "os" + log "github.com/sirupsen/logrus" + //data "github.com/spdfg/elektron/elektronLogging/data" +) + +type ConsoleLogger struct { + LoggerImpl +} + +func NewConsoleLogger(logType int, prefix string) *ConsoleLogger { + cLog := new(ConsoleLogger) + cLog.Type = logType + cLog.SetLogFile(prefix) + return cLog +} +func (cLog *ConsoleLogger) Log(logType int, level log.Level, logData log.Fields, message string) { + if logType <= cLog.Type { + + //logFields := cloneFields(logData) + log.SetLevel(level) + + log.SetOutput(os.Stdout) + log.WithFields(logData).Println(message) + + log.SetOutput(cLog.LogFileName) + log.WithFields(logData).Println(message) + } + if cLog.next != nil { + cLog.next.Log(logType, level, logData, message) + } +} + +func (cLog *ConsoleLogger) SetLogFile(prefix string) { + + consoleLogPrefix := prefix + config.ConsoleConfig.FilenameExtension + if logDir != "" { + consoleLogPrefix = logDir + "/" + consoleLogPrefix + } + if logFile, err := os.Create(consoleLogPrefix); err != nil { + log.Fatal("Unable to create logFile: ", err) + } else { + cLog.LogFileName = logFile + cLog.AllowOnConsole = true + } +} diff --git a/elektronLogging/createLogDir.go b/elektronLogging/createLogDir.go new file mode 100644 index 0000000..b365396 --- /dev/null +++ b/elektronLogging/createLogDir.go @@ -0,0 +1,38 @@ +package elektronLogging + +import ( + "os" + "strconv" + "time" + logrus "github.com/sirupsen/logrus" +) + +var logDir string + +func GetLogDir(startTime time.Time, prefix string) { + if logDir == "" { + logDir = createLogDir(prefix, startTime) + } +} + +func createLogDir(prefix string, startTime time.Time) string { + // Creating directory to store all logs for this run + logDirName := "./" + prefix + strconv.Itoa(startTime.Year()) + logDirName += "-" + logDirName += startTime.Month().String() + logDirName += "-" + logDirName += strconv.Itoa(startTime.Day()) + logDirName += "_" + logDirName += strconv.Itoa(startTime.Hour()) + logDirName += "-" + logDirName += strconv.Itoa(startTime.Minute()) + logDirName += "-" + logDirName += strconv.Itoa(startTime.Second()) + if _, err := os.Stat(logDirName); os.IsNotExist(err) { + os.Mkdir(logDirName, 0755) + } else { + logrus.Println("Unable to create log directory: ", err) + logDirName = "" + } + return logDirName +} diff --git a/elektronLogging/logger.go b/elektronLogging/logger.go new file mode 100644 index 0000000..6eef62e --- /dev/null +++ b/elektronLogging/logger.go @@ -0,0 +1,48 @@ +package elektronLogging + +import ( + "time" + "fmt" + "strconv" + . "github.com/spdfg/elektron/elektronLogging/types" + log "github.com/sirupsen/logrus" +) + +var config LoggerConfig +var logger *log.Logger +var formatter ElektronFormatter +//var logDir string + +func BuildLogger() *LoggerImpl { + + config.GetConfig() + startTime := time.Now() + formatter.TimestampFormat = "2006-01-02 15:04:05" + GetLogDir(startTime, "_") + + prefix := fmt.Sprintf("_%s%s%s%s%s",startTime.Month().String(),strconv.Itoa(startTime.Day()), + strconv.Itoa(startTime.Hour()),strconv.Itoa(startTime.Minute()),strconv.Itoa(startTime.Second())) + + logger = log.New() + logger.SetFormatter(&formatter) + + head := new(LoggerImpl) + cLog := NewConsoleLogger(CONSOLE,prefix) + pLog := NewPcpLogger(PCP,prefix) + schedTraceLog := NewSchedTraceLogger(SCHED_TRACE, prefix) + spsLog := NewSchedPolicySwitchLogger(SPS, prefix) + schedWindowLog := NewSchedWindowLogger(SCHED_WINDOW, prefix) + tskDistLog := NewClsfnTaskDistOverheadLogger(CLSFN_TASKDIST_OVERHEAD, prefix) + + head.SetNext(cLog) + cLog.SetNext(pLog) + pLog.SetNext(schedTraceLog) + schedTraceLog.SetNext(spsLog) + + spsLog.SetNext(schedWindowLog) + schedWindowLog.SetNext(tskDistLog) + + return head +} + +var ElektronLog = BuildLogger() diff --git a/elektronLogging/loggerChain.go b/elektronLogging/loggerChain.go new file mode 100644 index 0000000..baac3d5 --- /dev/null +++ b/elektronLogging/loggerChain.go @@ -0,0 +1,37 @@ +package elektronLogging + +import ( + "os" + //data "github.com/spdfg/elektron/elektronLogging/data" + log "github.com/sirupsen/logrus" +) + +type Logger interface { + SetNext(logType Logger) + Log(logType int, level log.Level, logData log.Fields, message string) + SetLogFile(prefix string) +} +type LoggerImpl struct { + Type int + AllowOnConsole bool + LogFileName *os.File + next Logger +} + +func (l *LoggerImpl) SetNext(logType Logger) { + l.next = logType +} + +func (l *LoggerImpl) Log(logType int, level log.Level, logData log.Fields, message string) { + if l.next != nil { + l.next.Log(logType, level, logData, message) + } +} + +/*func cloneFields(logData data.LogData) log.Fields { + var newMap = make(log.Fields) + for k,v := range logData { + newMap[k] = v + } + return newMap +}*/ diff --git a/elektronLogging/loggerConfig.go b/elektronLogging/loggerConfig.go new file mode 100644 index 0000000..8d67a9f --- /dev/null +++ b/elektronLogging/loggerConfig.go @@ -0,0 +1,68 @@ +package elektronLogging +import ( + "gopkg.in/yaml.v2" + "io/ioutil" + log "github.com/sirupsen/logrus" + elekEnv "gitlab.com/spdf/elektron/environment" +) + +type LoggerConfig struct { + + SchedTraceConfig struct { + Enabled bool `yaml:"enabled"` + FilenameExtension string `yaml:"filenameExtension"` + EnableColumnHeaders bool `yaml:"enableColumnHeaders"` + AllowOnConsole bool `yaml:"allowOnConsole"` + } `yaml:"schedTrace"` + + PCPConfig struct { + Enabled bool `yaml:"enabled"` + FilenameExtension string `yaml:"filenameExtension"` + EnableColumnHeaders bool `yaml:"enableColumnHeaders"` + AllowOnConsole bool `yaml:"allowOnConsole"` + } `yaml:"pcp"` + + ConsoleConfig struct { + Enabled bool `yaml:"enabled"` + FilenameExtension string `yaml:"filenameExtension"` + EnableColumnHeaders bool `yaml:"enableColumnHeaders"` + MinLogLevel string `yaml:"minLogLevel"` + } `yaml:"console"` + + SPSConfig struct { + Enabled bool `yaml:"enabled"` + FilenameExtension string `yaml:"filenameExtension"` + EnableColumnHeaders bool `yaml:"enableColumnHeaders"` + AllowOnConsole bool `yaml:"allowOnConsole"` + } `yaml:"sps"` + + TaskDistConfig struct { + Enabled bool `yaml:"enabled"` + FilenameExtension string `yaml:"filenameExtension"` + EnableColumnHeaders bool `yaml:"enableColumnHeaders"` + AllowOnConsole bool `yaml:"allowOnConsole"` + } `yaml:"clsfnTaskDistOverhead"` + + SchedWindowConfig struct { + Enabled bool `yaml:"enabled"` + FilenameExtension string `yaml:"filenameExtension"` + EnableColumnHeaders bool `yaml:"enableColumnHeaders"` + AllowOnConsole bool `yaml:"allowOnConsole"` + } `yaml:"schedWindow"` + + Format[] string `yaml:"format"` +} + +func (c *LoggerConfig) GetConfig() *LoggerConfig { + + yamlFile, err := ioutil.ReadFile(elekEnv.LogConfigYaml) + if err != nil { + log.Printf("yamlFile.Get err #%v ", err) + } + err = yaml.Unmarshal(yamlFile, c) + if err != nil { + log.Fatalf("Unmarshal: %v", err) + } + + return c +} diff --git a/elektronLogging/pcpLogger.go b/elektronLogging/pcpLogger.go new file mode 100644 index 0000000..1e0dad3 --- /dev/null +++ b/elektronLogging/pcpLogger.go @@ -0,0 +1,52 @@ +package elektronLogging + +import ( + "os" + log "github.com/sirupsen/logrus" + //data "github.com/spdfg/elektron/elektronLogging/data" +) + +type PcpLogger struct { + LoggerImpl +} + +func NewPcpLogger(logType int, prefix string) *PcpLogger { + pLog := new(PcpLogger) + pLog.Type = logType + pLog.SetLogFile(prefix) + return pLog +} + +func (pLog *PcpLogger) Log(logType int, level log.Level, logData log.Fields, message string) { + if pLog.Type == logType { + + //logFields := cloneFields(logData) + + log.SetLevel(level) + + if pLog.AllowOnConsole { + log.SetOutput(os.Stdout) + log.WithFields(logData).Println(message) + } + + log.SetOutput(pLog.LogFileName) + log.WithFields(logData).Println(message) + } + if pLog.next != nil { + pLog.next.Log(logType, level, logData, message) + } +} + +func (plog *PcpLogger) SetLogFile(prefix string) { + + pcpLogPrefix := prefix + config.PCPConfig.FilenameExtension + if logDir != "" { + pcpLogPrefix = logDir + "/" + pcpLogPrefix + } + if logFile, err := os.Create(pcpLogPrefix); err != nil { + log.Fatal("Unable to create logFile: ", err) + } else { + plog.LogFileName = logFile + plog.AllowOnConsole = config.PCPConfig.AllowOnConsole + } +} diff --git a/elektronLogging/schedPolicySwitchLogger.go b/elektronLogging/schedPolicySwitchLogger.go new file mode 100644 index 0000000..3f4e8f7 --- /dev/null +++ b/elektronLogging/schedPolicySwitchLogger.go @@ -0,0 +1,53 @@ +package elektronLogging + +import ( + //"fmt" + "os" + log "github.com/sirupsen/logrus" + //data "github.com/spdfg/elektron/elektronLogging/data" +) + +type SchedPolicySwitchLogger struct { + LoggerImpl +} + +func NewSchedPolicySwitchLogger(logType int, prefix string) *SchedPolicySwitchLogger { + sLog := new(SchedPolicySwitchLogger) + sLog.Type = logType + sLog.SetLogFile(prefix) + return sLog +} + +func (sLog *SchedPolicySwitchLogger) Log(logType int, level log.Level, logData log.Fields, message string) { + if sLog.Type == logType { + + //logFields := cloneFields(logData) + + log.SetLevel(level) + + if sLog.AllowOnConsole { + log.SetOutput(os.Stdout) + log.WithFields(logData).Println(message) + } + + log.SetOutput(sLog.LogFileName) + log.WithFields(logData).Println(message) + } + if sLog.next != nil { + sLog.next.Log(logType, level, logData, message) + } +} + +func (sLog *SchedPolicySwitchLogger) SetLogFile(prefix string) { + + spsLogPrefix := prefix + config.SPSConfig.FilenameExtension + if logDir != "" { + spsLogPrefix = logDir + "/" + spsLogPrefix + } + if logFile, err := os.Create(spsLogPrefix); err != nil { + log.Fatal("Unable to create logFile: ", err) + } else { + sLog.LogFileName = logFile + sLog.AllowOnConsole = config.SPSConfig.AllowOnConsole + } +} diff --git a/elektronLogging/schedTraceLogger.go b/elektronLogging/schedTraceLogger.go new file mode 100644 index 0000000..e117057 --- /dev/null +++ b/elektronLogging/schedTraceLogger.go @@ -0,0 +1,53 @@ +package elektronLogging + +import ( + //"fmt" + "os" + log "github.com/sirupsen/logrus" + //data "github.com/spdfg/elektron/elektronLogging/data" +) + +type SchedTraceLogger struct { + LoggerImpl +} + +func NewSchedTraceLogger(logType int, prefix string) *SchedTraceLogger { + sLog := new(SchedTraceLogger) + sLog.Type = logType + sLog.SetLogFile(prefix) + return sLog +} + +func (sLog *SchedTraceLogger) Log(logType int, level log.Level, logData log.Fields, message string) { + if sLog.Type == logType { + + //logFields := cloneFields(logData) + + log.SetLevel(level) + + if sLog.AllowOnConsole { + log.SetOutput(os.Stdout) + log.WithFields(logData).Println(message) + } + + log.SetOutput(sLog.LogFileName) + log.WithFields(logData).Println(message) + } + if sLog.next != nil { + sLog.next.Log(logType, level, logData, message) + } +} + +func (sLog *SchedTraceLogger) SetLogFile(prefix string) { + + schedTraceLogPrefix := prefix + config.SchedTraceConfig.FilenameExtension + if logDir != "" { + schedTraceLogPrefix = logDir + "/" + schedTraceLogPrefix + } + if logFile, err := os.Create(schedTraceLogPrefix); err != nil { + log.Fatal("Unable to create logFile: ", err) + } else { + sLog.LogFileName = logFile + sLog.AllowOnConsole = config.SchedTraceConfig.AllowOnConsole + } +} diff --git a/elektronLogging/schedWindowLogger.go b/elektronLogging/schedWindowLogger.go new file mode 100644 index 0000000..e5175e3 --- /dev/null +++ b/elektronLogging/schedWindowLogger.go @@ -0,0 +1,51 @@ +package elektronLogging + +import ( + "os" + log "github.com/sirupsen/logrus" + //data "github.com/spdfg/elektron/elektronLogging/data" +) + +type SchedWindowLogger struct { + LoggerImpl +} + +func NewSchedWindowLogger(logType int, prefix string) *SchedWindowLogger { + sLog := new(SchedWindowLogger) + sLog.Type = logType + sLog.SetLogFile(prefix) + return sLog +} + +func (sLog *SchedWindowLogger) Log(logType int, level log.Level, logData log.Fields, message string) { + if sLog.Type == logType { + + //logFields := cloneFields(logData) + + log.SetLevel(level) + if sLog.AllowOnConsole { + log.SetOutput(os.Stdout) + log.WithFields(logData).Println(message) + } + + log.SetOutput(sLog.LogFileName) + log.WithFields(logData).Println(message) + } + if sLog.next != nil { + sLog.next.Log(logType, level, logData, message) + } +} + +func (sLog *SchedWindowLogger) SetLogFile(prefix string) { + + schedWindowLogPrefix := prefix + config.SchedWindowConfig.FilenameExtension + if logDir != "" { + schedWindowLogPrefix = logDir + "/" + schedWindowLogPrefix + } + if logFile, err := os.Create(schedWindowLogPrefix); err != nil { + log.Fatal("Unable to create logFile: ", err) + } else { + sLog.LogFileName = logFile + sLog.AllowOnConsole = config.SchedWindowConfig.AllowOnConsole + } +} diff --git a/elektronLogging/types/types.go b/elektronLogging/types/types.go new file mode 100644 index 0000000..3ff94e9 --- /dev/null +++ b/elektronLogging/types/types.go @@ -0,0 +1,17 @@ +package elektronLogging + +import "github.com/fatih/color" + +const ( + ERROR = iota + WARNING = iota + GENERAL = iota + SUCCESS = iota + CONSOLE = iota + PCP = iota + SCHED_TRACE = iota + SPS = iota + SCHED_WINDOW = iota + CLSFN_TASKDIST_OVERHEAD = iota +) + -- 2.47.2 From b501054412af1f58aae9deba587903be030544af Mon Sep 17 00:00:00 2001 From: balandi1 Date: Wed, 13 Nov 2019 14:04:21 -0500 Subject: [PATCH 02/48] Changes made everywhere inorder to use elektron logging library for logging --- logConfig.yaml | 38 ++++++++++++++++++++++++++++++++++++++ 1 file changed, 38 insertions(+) create mode 100644 logConfig.yaml diff --git a/logConfig.yaml b/logConfig.yaml new file mode 100644 index 0000000..24be410 --- /dev/null +++ b/logConfig.yaml @@ -0,0 +1,38 @@ +schedTrace: + enabled: true + filenameExtension: _schedTrace.log + enablecolumnheaders: true + allowOnConsole: true +sps: + enabled: false + filenameExtension: _schedPolicySwitch.log + enableColumnHeaders: true + allowOnConsole: true +console: + enabled: true + filenameExtension: _console.log + minLogLevel: debug + enableColumnHeaders: true +pcp: + enabled: true + filenameExtension: .pcplog + enableColumnHeaders: true + allowOnConsole: false +schedWindow: + enabled: true + filenameExtension: _schedWindow.log + enableColumnHeaders: true + allowOnConsole: true +clsfnTaskDistOverhead: + enabled: true + filenameExtension: _classificationOverhead.log + enableColumnHeaders: true + allowOnConsole: true + + +# format. +format: + - level + - timestamp + - message + - fields -- 2.47.2 From c27aba895b3b241f4204338e28791496d9566232 Mon Sep 17 00:00:00 2001 From: balandi1 Date: Wed, 13 Nov 2019 14:08:52 -0500 Subject: [PATCH 03/48] Changes made everywhere inorder to use elektronLogging library for logging --- elektronLogging/ElektronFormatter.go | 6 +- .../clsfnTaskDistOverheadLogger.go | 20 +- elektronLogging/consoleLogger.go | 11 +- elektronLogging/logger.go | 11 +- elektronLogging/loggerConfig.go | 2 +- elektronLogging/pcpLogger.go | 13 +- elektronLogging/schedPolicySwitchLogger.go | 14 +- elektronLogging/schedTraceLogger.go | 14 +- elektronLogging/schedWindowLogger.go | 13 +- elektronLogging/types/types.go | 1 - environment/env.go | 2 + go.mod | 29 +-- go.sum | 44 ++++ pcp/pcp.go | 28 +-- powerCap/extrema.go | 79 ++++--- powerCap/progressiveExtrema.go | 131 +++++++----- scheduler.go | 40 ++-- schedulers/MaxGreedyMins.go | 2 +- schedulers/MaxMin.go | 2 +- schedulers/base.go | 199 +++++++++--------- schedulers/electronScheduler.go | 3 - schedulers/helpers.go | 17 +- schedulers/schedPolicy.go | 9 +- 23 files changed, 382 insertions(+), 308 deletions(-) diff --git a/elektronLogging/ElektronFormatter.go b/elektronLogging/ElektronFormatter.go index a929e56..0293510 100644 --- a/elektronLogging/ElektronFormatter.go +++ b/elektronLogging/ElektronFormatter.go @@ -37,8 +37,10 @@ func (f ElektronFormatter) Format(entry *log.Entry) ([]byte, error) { levelColor := f.getColor(entry) level := levelColor.Sprintf("[%s]:",strings.ToUpper(entry.Level.String())) - message := fmt.Sprintf("%s %s %s ",level,entry.Time.Format(f.TimestampFormat), entry.Message) - + message := fmt.Sprintf("%s %s ",level,entry.Time.Format(f.TimestampFormat)) + if entry.Message != "" { + message = fmt.Sprintf("%s %s %s ",level,entry.Time.Format(f.TimestampFormat), entry.Message) + } var formattedFields []string for key, value := range entry.Data { formattedFields = append(formattedFields, diff --git a/elektronLogging/clsfnTaskDistOverheadLogger.go b/elektronLogging/clsfnTaskDistOverheadLogger.go index 76191e7..c4a5e70 100644 --- a/elektronLogging/clsfnTaskDistOverheadLogger.go +++ b/elektronLogging/clsfnTaskDistOverheadLogger.go @@ -1,10 +1,8 @@ package elektronLogging import ( - //"fmt" "os" - logrus "github.com/sirupsen/logrus" - data "gitlab.com/spdf/elektron/elektronLogging/data" + log "github.com/sirupsen/logrus" ) type ClsfnTaskDistOverheadLogger struct { @@ -18,20 +16,18 @@ func NewClsfnTaskDistOverheadLogger(logType int, prefix string) *ClsfnTaskDistOv return cLog } -func (cLog *ClsfnTaskDistOverheadLogger) Log(logType int, level logrus.Level, logData data.LogData,message string) { +func (cLog *ClsfnTaskDistOverheadLogger) Log(logType int, level log.Level, logData log.Fields,message string) { if cLog.Type == logType { - logFields := cloneFields(logData) - - log.SetLevel(level) + logger.SetLevel(level) if cLog.AllowOnConsole { - log.SetOutput(os.Stdout) - log.WithFields(logFields).Println(message) + logger.SetOutput(os.Stdout) + logger.WithFields(logData).Println(message) } - log.SetOutput(cLog.LogFileName) - log.WithFields(logFields).Println(message) + logger.SetOutput(cLog.LogFileName) + logger.WithFields(logData).Println(message) } if cLog.next != nil { cLog.next.Log(logType, level, logData, message) @@ -45,7 +41,7 @@ func (cLog *ClsfnTaskDistOverheadLogger) SetLogFile(prefix string) { tskDistLogPrefix = logDir + "/" + tskDistLogPrefix } if logFile, err := os.Create(tskDistLogPrefix); err != nil { - logrus.Fatal("Unable to create logFile: ", err) + log.Fatal("Unable to create logFile: ", err) } else { cLog.LogFileName = logFile cLog.AllowOnConsole = config.TaskDistConfig.AllowOnConsole diff --git a/elektronLogging/consoleLogger.go b/elektronLogging/consoleLogger.go index b053e42..36feb15 100644 --- a/elektronLogging/consoleLogger.go +++ b/elektronLogging/consoleLogger.go @@ -3,7 +3,6 @@ package elektronLogging import ( "os" log "github.com/sirupsen/logrus" - //data "github.com/spdfg/elektron/elektronLogging/data" ) type ConsoleLogger struct { @@ -20,13 +19,13 @@ func (cLog *ConsoleLogger) Log(logType int, level log.Level, logData log.Fields, if logType <= cLog.Type { //logFields := cloneFields(logData) - log.SetLevel(level) + logger.SetLevel(level) - log.SetOutput(os.Stdout) - log.WithFields(logData).Println(message) + logger.SetOutput(os.Stdout) + logger.WithFields(logData).Println(message) - log.SetOutput(cLog.LogFileName) - log.WithFields(logData).Println(message) + logger.SetOutput(cLog.LogFileName) + logger.WithFields(logData).Println(message) } if cLog.next != nil { cLog.next.Log(logType, level, logData, message) diff --git a/elektronLogging/logger.go b/elektronLogging/logger.go index 6eef62e..593f217 100644 --- a/elektronLogging/logger.go +++ b/elektronLogging/logger.go @@ -11,21 +11,25 @@ import ( var config LoggerConfig var logger *log.Logger var formatter ElektronFormatter -//var logDir string func BuildLogger() *LoggerImpl { + // read configuration from yaml config.GetConfig() + + // create the log directory startTime := time.Now() formatter.TimestampFormat = "2006-01-02 15:04:05" GetLogDir(startTime, "_") - prefix := fmt.Sprintf("_%s%s%s%s%s",startTime.Month().String(),strconv.Itoa(startTime.Day()), + prefix := fmt.Sprintf("_%d%d%s%s%s%s",startTime.Year(), startTime.Month(),strconv.Itoa(startTime.Day()), strconv.Itoa(startTime.Hour()),strconv.Itoa(startTime.Minute()),strconv.Itoa(startTime.Second())) + //create a single logrus instance and set its formatter to ElektronFormatter logger = log.New() logger.SetFormatter(&formatter) - + + // create a chain of loggers head := new(LoggerImpl) cLog := NewConsoleLogger(CONSOLE,prefix) pLog := NewPcpLogger(PCP,prefix) @@ -38,7 +42,6 @@ func BuildLogger() *LoggerImpl { cLog.SetNext(pLog) pLog.SetNext(schedTraceLog) schedTraceLog.SetNext(spsLog) - spsLog.SetNext(schedWindowLog) schedWindowLog.SetNext(tskDistLog) diff --git a/elektronLogging/loggerConfig.go b/elektronLogging/loggerConfig.go index 8d67a9f..cc9ece5 100644 --- a/elektronLogging/loggerConfig.go +++ b/elektronLogging/loggerConfig.go @@ -3,7 +3,7 @@ import ( "gopkg.in/yaml.v2" "io/ioutil" log "github.com/sirupsen/logrus" - elekEnv "gitlab.com/spdf/elektron/environment" + elekEnv "github.com/spdfg/elektron/environment" ) type LoggerConfig struct { diff --git a/elektronLogging/pcpLogger.go b/elektronLogging/pcpLogger.go index 1e0dad3..3d7c720 100644 --- a/elektronLogging/pcpLogger.go +++ b/elektronLogging/pcpLogger.go @@ -3,7 +3,6 @@ package elektronLogging import ( "os" log "github.com/sirupsen/logrus" - //data "github.com/spdfg/elektron/elektronLogging/data" ) type PcpLogger struct { @@ -20,17 +19,15 @@ func NewPcpLogger(logType int, prefix string) *PcpLogger { func (pLog *PcpLogger) Log(logType int, level log.Level, logData log.Fields, message string) { if pLog.Type == logType { - //logFields := cloneFields(logData) - - log.SetLevel(level) + logger.SetLevel(level) if pLog.AllowOnConsole { - log.SetOutput(os.Stdout) - log.WithFields(logData).Println(message) + logger.SetOutput(os.Stdout) + logger.WithFields(logData).Println(message) } - log.SetOutput(pLog.LogFileName) - log.WithFields(logData).Println(message) + logger.SetOutput(pLog.LogFileName) + logger.WithFields(logData).Println(message) } if pLog.next != nil { pLog.next.Log(logType, level, logData, message) diff --git a/elektronLogging/schedPolicySwitchLogger.go b/elektronLogging/schedPolicySwitchLogger.go index 3f4e8f7..270b5f8 100644 --- a/elektronLogging/schedPolicySwitchLogger.go +++ b/elektronLogging/schedPolicySwitchLogger.go @@ -1,10 +1,8 @@ package elektronLogging import ( - //"fmt" "os" log "github.com/sirupsen/logrus" - //data "github.com/spdfg/elektron/elektronLogging/data" ) type SchedPolicySwitchLogger struct { @@ -21,17 +19,15 @@ func NewSchedPolicySwitchLogger(logType int, prefix string) *SchedPolicySwitchLo func (sLog *SchedPolicySwitchLogger) Log(logType int, level log.Level, logData log.Fields, message string) { if sLog.Type == logType { - //logFields := cloneFields(logData) - - log.SetLevel(level) + logger.SetLevel(level) if sLog.AllowOnConsole { - log.SetOutput(os.Stdout) - log.WithFields(logData).Println(message) + logger.SetOutput(os.Stdout) + logger.WithFields(logData).Println(message) } - log.SetOutput(sLog.LogFileName) - log.WithFields(logData).Println(message) + logger.SetOutput(sLog.LogFileName) + logger.WithFields(logData).Println(message) } if sLog.next != nil { sLog.next.Log(logType, level, logData, message) diff --git a/elektronLogging/schedTraceLogger.go b/elektronLogging/schedTraceLogger.go index e117057..0aade97 100644 --- a/elektronLogging/schedTraceLogger.go +++ b/elektronLogging/schedTraceLogger.go @@ -1,10 +1,8 @@ package elektronLogging import ( - //"fmt" "os" log "github.com/sirupsen/logrus" - //data "github.com/spdfg/elektron/elektronLogging/data" ) type SchedTraceLogger struct { @@ -21,17 +19,15 @@ func NewSchedTraceLogger(logType int, prefix string) *SchedTraceLogger { func (sLog *SchedTraceLogger) Log(logType int, level log.Level, logData log.Fields, message string) { if sLog.Type == logType { - //logFields := cloneFields(logData) - - log.SetLevel(level) + logger.SetLevel(level) if sLog.AllowOnConsole { - log.SetOutput(os.Stdout) - log.WithFields(logData).Println(message) + logger.SetOutput(os.Stdout) + logger.WithFields(logData).Println(message) } - log.SetOutput(sLog.LogFileName) - log.WithFields(logData).Println(message) + logger.SetOutput(sLog.LogFileName) + logger.WithFields(logData).Println(message) } if sLog.next != nil { sLog.next.Log(logType, level, logData, message) diff --git a/elektronLogging/schedWindowLogger.go b/elektronLogging/schedWindowLogger.go index e5175e3..8640883 100644 --- a/elektronLogging/schedWindowLogger.go +++ b/elektronLogging/schedWindowLogger.go @@ -3,7 +3,6 @@ package elektronLogging import ( "os" log "github.com/sirupsen/logrus" - //data "github.com/spdfg/elektron/elektronLogging/data" ) type SchedWindowLogger struct { @@ -20,16 +19,14 @@ func NewSchedWindowLogger(logType int, prefix string) *SchedWindowLogger { func (sLog *SchedWindowLogger) Log(logType int, level log.Level, logData log.Fields, message string) { if sLog.Type == logType { - //logFields := cloneFields(logData) - - log.SetLevel(level) + logger.SetLevel(level) if sLog.AllowOnConsole { - log.SetOutput(os.Stdout) - log.WithFields(logData).Println(message) + logger.SetOutput(os.Stdout) + logger.WithFields(logData).Println(message) } - log.SetOutput(sLog.LogFileName) - log.WithFields(logData).Println(message) + logger.SetOutput(sLog.LogFileName) + logger.WithFields(logData).Println(message) } if sLog.next != nil { sLog.next.Log(logType, level, logData, message) diff --git a/elektronLogging/types/types.go b/elektronLogging/types/types.go index 3ff94e9..e8288c1 100644 --- a/elektronLogging/types/types.go +++ b/elektronLogging/types/types.go @@ -1,6 +1,5 @@ package elektronLogging -import "github.com/fatih/color" const ( ERROR = iota diff --git a/environment/env.go b/environment/env.go index 7283e55..d7c465d 100644 --- a/environment/env.go +++ b/environment/env.go @@ -26,3 +26,5 @@ var RaplPassword = "RAPL_PSSWD" // Location of the script that sets the powercap value for a host. var RaplThrottleScriptLocation = "RAPL_PKG_THROTTLE_SCRIPT_LOCATION" + +var LogConfigYaml = "logConfig.yaml" diff --git a/go.mod b/go.mod index 5c32bee..9a2bc9c 100644 --- a/go.mod +++ b/go.mod @@ -4,20 +4,23 @@ go 1.12 require ( github.com/fatih/color v1.7.0 - github.com/gogo/protobuf v1.1.1 + github.com/gogo/protobuf v1.3.0 github.com/golang/glog v0.0.0-20160126235308-23def4e6c14b - github.com/golang/protobuf v1.2.0 + github.com/golang/protobuf v1.3.2 github.com/google/uuid v1.0.0 - github.com/mash/gokmeans v0.0.0-20140614041449-8bbf08905a7e - github.com/mattn/go-colorable v0.0.9 - github.com/mattn/go-isatty v0.0.4 - github.com/mesos/mesos-go v0.0.8 - github.com/montanaflynn/stats v0.0.0-20171201202039-1bf9dbcd8cbe - github.com/pborman/uuid v0.0.0-20180906182336-adf5a7427709 - github.com/pkg/errors v0.8.0 - github.com/samuel/go-zookeeper v0.0.0-20180130194729-c4fab1ac1bec + github.com/mash/gokmeans v0.0.0-20170215130432-ea22cff45f59 + github.com/mattn/go-colorable v0.1.2 + github.com/mattn/go-isatty v0.0.9 + github.com/mesos/mesos-go v0.0.10 + github.com/montanaflynn/stats v0.5.0 + github.com/pborman/uuid v1.2.0 + github.com/pkg/errors v0.8.1 + github.com/samuel/go-zookeeper v0.0.0-20190923202752-2cc03de413da + github.com/sirupsen/logrus v1.4.2 github.com/stretchr/testify v1.4.0 - golang.org/x/crypto v0.0.0-20180927165925-5295e8364332 - golang.org/x/net v0.0.0-20180926154720-4dfa2610cdf3 - golang.org/x/sys v0.0.0-20180928133829-e4b3c5e90611 + gitlab.com/spdf/elektron v0.0.0-20191024200717-26f96f361f10 + golang.org/x/crypto v0.0.0-20190927123631-a832865fa7ad + golang.org/x/net v0.0.0-20190404232315-eb5bcb51f2a3 + golang.org/x/sys v0.0.0-20190813064441-fde4db37ae7a + gopkg.in/yaml.v2 v2.2.2 ) diff --git a/go.sum b/go.sum index fd72742..f2fecd3 100644 --- a/go.sum +++ b/go.sum @@ -1,41 +1,85 @@ github.com/davecgh/go-spew v1.1.0 h1:ZDRjVQ15GmhC3fiQ8ni8+OwkZQO4DARzQgrnXU1Liz8= github.com/davecgh/go-spew v1.1.0/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38= +github.com/davecgh/go-spew v1.1.1/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38= github.com/fatih/color v1.7.0 h1:DkWD4oS2D8LGGgTQ6IvwJJXSL5Vp2ffcQg58nFV38Ys= github.com/fatih/color v1.7.0/go.mod h1:Zm6kSWBoL9eyXnKyktHP6abPY2pDugNf5KwzbycvMj4= github.com/gogo/protobuf v1.1.1 h1:72R+M5VuhED/KujmZVcIquuo8mBgX4oVda//DQb3PXo= github.com/gogo/protobuf v1.1.1/go.mod h1:r8qH/GZQm5c6nD/R0oafs1akxWv10x8SbQlK7atdtwQ= +github.com/gogo/protobuf v1.3.0 h1:G8O7TerXerS4F6sx9OV7/nRfJdnXgHZu/S/7F2SN+UE= +github.com/gogo/protobuf v1.3.0/go.mod h1:SlYgWuQ5SjCEi6WLHjHCa1yvBfUnHcTbrrZtXPKa29o= github.com/golang/glog v0.0.0-20160126235308-23def4e6c14b h1:VKtxabqXZkF25pY9ekfRL6a582T4P37/31XEstQ5p58= github.com/golang/glog v0.0.0-20160126235308-23def4e6c14b/go.mod h1:SBH7ygxi8pfUlaOkMMuAQtPIUF8ecWP5IEl/CR7VP2Q= github.com/golang/protobuf v1.2.0 h1:P3YflyNX/ehuJFLhxviNdFxQPkGK5cDcApsge1SqnvM= github.com/golang/protobuf v1.2.0/go.mod h1:6lQm79b+lXiMfvg/cZm0SGofjICqVBUtrP5yJMmIC1U= +github.com/golang/protobuf v1.3.2 h1:6nsPYzhq5kReh6QImI3k5qWzO4PEbvbIW2cwSfR/6xs= +github.com/golang/protobuf v1.3.2/go.mod h1:6lQm79b+lXiMfvg/cZm0SGofjICqVBUtrP5yJMmIC1U= github.com/google/uuid v1.0.0 h1:b4Gk+7WdP/d3HZH8EJsZpvV7EtDOgaZLtnaNGIu1adA= github.com/google/uuid v1.0.0/go.mod h1:TIyPZe4MgqvfeYDBFedMoGGpEw/LqOeaOT+nhxU+yHo= +github.com/kisielk/errcheck v1.2.0/go.mod h1:/BMXB+zMLi60iA8Vv6Ksmxu/1UDYcXs4uQLJ+jE2L00= +github.com/kisielk/gotool v1.0.0/go.mod h1:XhKaO+MFFWcvkIS/tQcRk01m1F5IRFswLeQ+oQHNcck= +github.com/konsorten/go-windows-terminal-sequences v1.0.1/go.mod h1:T0+1ngSBFLxvqU3pZ+m/2kptfBszLMUkC4ZK/EgS/cQ= github.com/mash/gokmeans v0.0.0-20140614041449-8bbf08905a7e h1:KrPVKjYg/ocMUbv39AQoIINny7acoDE0jghg+vTvTY4= github.com/mash/gokmeans v0.0.0-20140614041449-8bbf08905a7e/go.mod h1:nxv+mR7KuDZRAmEjsCFBQNtWcIty99qUn2Ycbgcns5c= +github.com/mash/gokmeans v0.0.0-20170215130432-ea22cff45f59 h1:C7rqeTVPDC/0QZFxfsMvS2y66WjMxQogK8/PTy9Jo0A= +github.com/mash/gokmeans v0.0.0-20170215130432-ea22cff45f59/go.mod h1:nxv+mR7KuDZRAmEjsCFBQNtWcIty99qUn2Ycbgcns5c= github.com/mattn/go-colorable v0.0.9 h1:UVL0vNpWh04HeJXV0KLcaT7r06gOH2l4OW6ddYRUIY4= github.com/mattn/go-colorable v0.0.9/go.mod h1:9vuHe8Xs5qXnSaW/c/ABM9alt+Vo+STaOChaDxuIBZU= +github.com/mattn/go-colorable v0.1.2 h1:/bC9yWikZXAL9uJdulbSfyVNIR3n3trXl+v8+1sx8mU= +github.com/mattn/go-colorable v0.1.2/go.mod h1:U0ppj6V5qS13XJ6of8GYAs25YV2eR4EVcfRqFIhoBtE= github.com/mattn/go-isatty v0.0.4 h1:bnP0vzxcAdeI1zdubAl5PjU6zsERjGZb7raWodagDYs= github.com/mattn/go-isatty v0.0.4/go.mod h1:M+lRXTBqGeGNdLjl/ufCoiOlB5xdOkqRJdNxMWT7Zi4= +github.com/mattn/go-isatty v0.0.8/go.mod h1:Iq45c/XA43vh69/j3iqttzPXn0bhXyGjM0Hdxcsrc5s= +github.com/mattn/go-isatty v0.0.9 h1:d5US/mDsogSGW37IV293h//ZFaeajb69h+EHFsv2xGg= +github.com/mattn/go-isatty v0.0.9/go.mod h1:YNRxwqDuOph6SZLI9vUUz6OYw3QyUt7WiY2yME+cCiQ= github.com/mesos/mesos-go v0.0.8 h1:hiAUHba+ycyZLxDiBUqKs91a0LbHZaAca988LzN19xM= github.com/mesos/mesos-go v0.0.8/go.mod h1:kPYCMQ9gsOXVAle1OsoY4I1+9kPu8GHkf88aV59fDr4= +github.com/mesos/mesos-go v0.0.10 h1:+M/7Zlkvw4MolkLvXHfj6hkDsLLHOOU54CmOkOUaNBc= +github.com/mesos/mesos-go v0.0.10/go.mod h1:kPYCMQ9gsOXVAle1OsoY4I1+9kPu8GHkf88aV59fDr4= github.com/montanaflynn/stats v0.0.0-20171201202039-1bf9dbcd8cbe h1:iruDEfMl2E6fbMZ9s0scYfZQ84/6SPL6zC8ACM2oIL0= github.com/montanaflynn/stats v0.0.0-20171201202039-1bf9dbcd8cbe/go.mod h1:wL8QJuTMNUDYhXwkmfOly8iTdp5TEcJFWZD2D7SIkUc= +github.com/montanaflynn/stats v0.5.0 h1:2EkzeTSqBB4V4bJwWrt5gIIrZmpJBcoIRGS2kWLgzmk= +github.com/montanaflynn/stats v0.5.0/go.mod h1:wL8QJuTMNUDYhXwkmfOly8iTdp5TEcJFWZD2D7SIkUc= github.com/pborman/uuid v0.0.0-20180906182336-adf5a7427709 h1:zNBQb37RGLmJybyMcs983HfUfpkw9OTFD9tbBfAViHE= github.com/pborman/uuid v0.0.0-20180906182336-adf5a7427709/go.mod h1:VyrYX9gd7irzKovcSS6BIIEwPRkP2Wm2m9ufcdFSJ34= +github.com/pborman/uuid v1.2.0 h1:J7Q5mO4ysT1dv8hyrUGHb9+ooztCXu1D8MY8DZYsu3g= +github.com/pborman/uuid v1.2.0/go.mod h1:X/NO0urCmaxf9VXbdlT7C2Yzkj2IKimNn4k+gtPdI/k= github.com/pkg/errors v0.8.0 h1:WdK/asTD0HN+q6hsWO3/vpuAkAr+tw6aNJNDFFf0+qw= github.com/pkg/errors v0.8.0/go.mod h1:bwawxfHBFNV+L2hUp1rHADufV3IMtnDRdf1r5NINEl0= +github.com/pkg/errors v0.8.1 h1:iURUrRGxPUNPdy5/HRSm+Yj6okJ6UtLINN0Q9M4+h3I= +github.com/pkg/errors v0.8.1/go.mod h1:bwawxfHBFNV+L2hUp1rHADufV3IMtnDRdf1r5NINEl0= github.com/pmezard/go-difflib v1.0.0 h1:4DBwDE0NGyQoBHbLQYPwSUPoCMWR5BEzIk/f1lZbAQM= github.com/pmezard/go-difflib v1.0.0/go.mod h1:iKH77koFhYxTK1pcRnkKkqfTogsbg7gZNVY4sRDYZ/4= github.com/samuel/go-zookeeper v0.0.0-20180130194729-c4fab1ac1bec h1:6ncX5ko6B9LntYM0YBRXkiSaZMmLYeZ/NWcmeB43mMY= github.com/samuel/go-zookeeper v0.0.0-20180130194729-c4fab1ac1bec/go.mod h1:gi+0XIa01GRL2eRQVjQkKGqKF3SF9vZR/HnPullcV2E= +github.com/samuel/go-zookeeper v0.0.0-20190923202752-2cc03de413da h1:p3Vo3i64TCLY7gIfzeQaUJ+kppEO5WQG3cL8iE8tGHU= +github.com/samuel/go-zookeeper v0.0.0-20190923202752-2cc03de413da/go.mod h1:gi+0XIa01GRL2eRQVjQkKGqKF3SF9vZR/HnPullcV2E= +github.com/sirupsen/logrus v1.4.2 h1:SPIRibHv4MatM3XXNO2BJeFLZwZ2LvZgfQ5+UNI2im4= +github.com/sirupsen/logrus v1.4.2/go.mod h1:tLMulIdttU9McNUspp0xgXVQah82FyeX6MwdIuYE2rE= github.com/stretchr/objx v0.1.0/go.mod h1:HFkY916IF+rwdDfMAkV7OtwuqBVzrE8GR6GFx+wExME= +github.com/stretchr/objx v0.1.1/go.mod h1:HFkY916IF+rwdDfMAkV7OtwuqBVzrE8GR6GFx+wExME= +github.com/stretchr/testify v1.2.2/go.mod h1:a8OnRcib4nhh0OaRAV+Yts87kKdq0PP7pXfy6kDkUVs= github.com/stretchr/testify v1.4.0 h1:2E4SXV/wtOkTonXsotYi4li6zVWxYlZuYNCXe9XRJyk= github.com/stretchr/testify v1.4.0/go.mod h1:j7eGeouHqKxXV5pUuKE4zz7dFj8WfuZ+81PSLYec5m4= +gitlab.com/spdf/elektron v0.0.0-20191024200717-26f96f361f10 h1:8ySmVAfFtX2mY2o7vbJauJBflwlDk1+XA6Xlp2K6bRg= +gitlab.com/spdf/elektron v0.0.0-20191024200717-26f96f361f10/go.mod h1:F6knSIgL9ajNjb0oNAjzV0vpJ51FtNs1UHxw86QQAQ0= golang.org/x/crypto v0.0.0-20180927165925-5295e8364332 h1:hvQVdF6P9DX4OiKA5tpehlG6JsgzmyQiThG7q5Bn3UQ= golang.org/x/crypto v0.0.0-20180927165925-5295e8364332/go.mod h1:6SG95UA2DQfeDnfUPMdvaQW0Q7yPrPDi9nlGo2tz2b4= +golang.org/x/crypto v0.0.0-20190308221718-c2843e01d9a2/go.mod h1:djNgcEr1/C05ACkg1iLfiJU5Ep61QUkGW8qpdssI0+w= +golang.org/x/crypto v0.0.0-20190927123631-a832865fa7ad h1:5E5raQxcv+6CZ11RrBYQe5WRbUIWpScjh0kvHZkZIrQ= +golang.org/x/crypto v0.0.0-20190927123631-a832865fa7ad/go.mod h1:yigFU9vqHzYiE8UmvKecakEJjdnWj3jj499lnFckfCI= golang.org/x/net v0.0.0-20180926154720-4dfa2610cdf3 h1:dgd4x4kJt7G4k4m93AYLzM8Ni6h2qLTfh9n9vXJT3/0= golang.org/x/net v0.0.0-20180926154720-4dfa2610cdf3/go.mod h1:mL1N/T3taQHkDXs73rZJwtUhF3w3ftmwwsq0BUmARs4= +golang.org/x/net v0.0.0-20190404232315-eb5bcb51f2a3 h1:0GoQqolDA55aaLxZyTzK/Y2ePZzZTUrRacwib7cNsYQ= +golang.org/x/net v0.0.0-20190404232315-eb5bcb51f2a3/go.mod h1:t9HGtf8HONx5eT2rtn7q6eTqICYqUVnKs3thJo3Qplg= golang.org/x/sys v0.0.0-20180928133829-e4b3c5e90611/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY= +golang.org/x/sys v0.0.0-20190215142949-d0b11bdaac8a/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY= +golang.org/x/sys v0.0.0-20190222072716-a9d3bda3a223/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY= +golang.org/x/sys v0.0.0-20190412213103-97732733099d/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= +golang.org/x/sys v0.0.0-20190422165155-953cdadca894/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= +golang.org/x/sys v0.0.0-20190813064441-fde4db37ae7a h1:aYOabOQFp6Vj6W1F80affTUvO9UxmJRx8K0gsfABByQ= +golang.org/x/sys v0.0.0-20190813064441-fde4db37ae7a/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= +golang.org/x/text v0.3.0/go.mod h1:NqM8EUOU14njkJ3fqMW+pc6Ldnwhi/IjpwHt7yyuwOQ= +golang.org/x/tools v0.0.0-20181030221726-6c7e314b6563/go.mod h1:n7NCudcB/nEzxVGmLbDWY5pfWTLqBcC2KZ6jyYvM4mQ= gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0= gopkg.in/yaml.v2 v2.2.2 h1:ZCJp+EgiOT7lHqUV2J862kp8Qj64Jo6az82+3Td9dZw= gopkg.in/yaml.v2 v2.2.2/go.mod h1:hI93XBmqTisBFMUTm0b8Fm+jr3Dg1NNxqwp+5A1VGuI= diff --git a/pcp/pcp.go b/pcp/pcp.go index 78a5c18..928d5a3 100644 --- a/pcp/pcp.go +++ b/pcp/pcp.go @@ -20,16 +20,16 @@ package pcp import ( "bufio" - "log" "os/exec" "syscall" "time" - elekLogDef "github.com/spdfg/elektron/logging/def" + "github.com/spdfg/elektron/elektronLogging" + elekLogT "github.com/spdfg/elektron/elektronLogging/types" + log "github.com/sirupsen/logrus" ) -func Start(quit chan struct{}, logging *bool, logMType chan elekLogDef.LogMessageType, - logMsg chan string, pcpConfigFile string) { +func Start(quit chan struct{}, logging *bool,pcpConfigFile string) { var pcpCommand string = "pmdumptext -m -l -f '' -t 1.0 -d , -c " + pcpConfigFile cmd := exec.Command("sh", "-c", pcpCommand) cmd.SysProcAttr = &syscall.SysProcAttr{Setpgid: true} @@ -47,8 +47,9 @@ func Start(quit chan struct{}, logging *bool, logMType chan elekLogDef.LogMessag scanner.Scan() // Write to logfile - logMType <- elekLogDef.PCP - logMsg <- scanner.Text() + elektronLogging.ElektronLog.Log(elekLogT.PCP, + log.InfoLevel, + log.Fields {}, scanner.Text()) // Throw away first set of results scanner.Scan() @@ -59,16 +60,18 @@ func Start(quit chan struct{}, logging *bool, logMType chan elekLogDef.LogMessag text := scanner.Text() if *logging { - logMType <- elekLogDef.PCP - logMsg <- text + elektronLogging.ElektronLog.Log(elekLogT.PCP, + log.InfoLevel, + log.Fields {}, text) } seconds++ } }(logging) - logMType <- elekLogDef.GENERAL - logMsg <- "PCP logging started" + elektronLogging.ElektronLog.Log(elekLogT.GENERAL, + log.InfoLevel, + log.Fields {}, "PCP logging started") if err := cmd.Start(); err != nil { log.Fatal(err) @@ -78,8 +81,9 @@ func Start(quit chan struct{}, logging *bool, logMType chan elekLogDef.LogMessag select { case <-quit: - logMType <- elekLogDef.GENERAL - logMsg <- "Stopping PCP logging in 5 seconds" + elektronLogging.ElektronLog.Log(elekLogT.GENERAL, + log.InfoLevel, + log.Fields {}, "Stopping PCP logging in 5 seconds") time.Sleep(5 * time.Second) // http://stackoverflow.com/questions/22470193/why-wont-go-kill-a-child-process-correctly diff --git a/powerCap/extrema.go b/powerCap/extrema.go index e18c587..e3b683d 100644 --- a/powerCap/extrema.go +++ b/powerCap/extrema.go @@ -22,7 +22,6 @@ import ( "bufio" "container/ring" "fmt" - "log" "os/exec" "sort" "strconv" @@ -30,20 +29,23 @@ import ( "syscall" "time" - elekLogDef "github.com/spdfg/elektron/logging/def" "github.com/spdfg/elektron/pcp" "github.com/spdfg/elektron/rapl" + "github.com/spdfg/elektron/elektronLogging" + elekLogT "github.com/spdfg/elektron/elektronLogging/types" + log "github.com/sirupsen/logrus" ) -func StartPCPLogAndExtremaDynamicCap(quit chan struct{}, logging *bool, hiThreshold, loThreshold float64, - logMType chan elekLogDef.LogMessageType, logMsg chan string, pcpConfigFile string) { +func StartPCPLogAndExtremaDynamicCap(quit chan struct{}, logging *bool, hiThreshold, loThreshold float64,pcpConfigFile string) { var pcpCommand string = "pmdumptext -m -l -f '' -t 1.0 -d , -c " + pcpConfigFile cmd := exec.Command("sh", "-c", pcpCommand, pcpConfigFile) cmd.SysProcAttr = &syscall.SysProcAttr{Setpgid: true} if hiThreshold < loThreshold { - log.Println("High threshold is lower than low threshold!") + elektronLogging.ElektronLog.Log(elekLogT.GENERAL, + log.InfoLevel, + log.Fields {}, "High threshold is lower than low threshold!") } pipe, err := cmd.StdoutPipe() @@ -59,8 +61,9 @@ func StartPCPLogAndExtremaDynamicCap(quit chan struct{}, logging *bool, hiThresh scanner.Scan() // Write to logfile - logMType <- elekLogDef.PCP - logMsg <- scanner.Text() + elektronLogging.ElektronLog.Log(elekLogT.PCP, + log.InfoLevel, + log.Fields {}, scanner.Text()) headers := strings.Split(scanner.Text(), ",") @@ -95,12 +98,17 @@ func StartPCPLogAndExtremaDynamicCap(quit chan struct{}, logging *bool, hiThresh for scanner.Scan() { if *logging { - logMType <- elekLogDef.GENERAL - logMsg <- "Logging PCP..." + + elektronLogging.ElektronLog.Log(elekLogT.GENERAL, + log.InfoLevel, + log.Fields {}, "Logging PCP...") + text := scanner.Text() split := strings.Split(text, ",") - logMType <- elekLogDef.PCP - logMsg <- text + + elektronLogging.ElektronLog.Log(elekLogT.PCP, + log.InfoLevel, + log.Fields {}, text) totalPower := 0.0 for _, powerIndex := range powerIndexes { @@ -111,8 +119,10 @@ func StartPCPLogAndExtremaDynamicCap(quit chan struct{}, logging *bool, hiThresh powerHistories[host].Value = power powerHistories[host] = powerHistories[host].Next() - logMType <- elekLogDef.GENERAL - logMsg <- fmt.Sprintf("Host: %s, Power: %f", indexToHost[powerIndex], (power * pcp.RAPLUnits)) + elektronLogging.ElektronLog.Log(elekLogT.GENERAL, + log.InfoLevel, + log.Fields {"Host" : fmt.Sprintf("%s",indexToHost[powerIndex]), "Power" : fmt.Sprintf("%f",(power * pcp.RAPLUnits))}, + "") totalPower += power } @@ -123,12 +133,16 @@ func StartPCPLogAndExtremaDynamicCap(quit chan struct{}, logging *bool, hiThresh clusterMean := pcp.AverageClusterPowerHistory(clusterPowerHist) - logMType <- elekLogDef.GENERAL - logMsg <- fmt.Sprintf("Total power: %f, %d Sec Avg: %f", clusterPower, clusterPowerHist.Len(), clusterMean) + elektronLogging.ElektronLog.Log(elekLogT.GENERAL, + log.InfoLevel, + log.Fields {"Total power" : fmt.Sprintf("%f %d",clusterPower,clusterPowerHist.Len()), + "Sec Avg" : fmt.Sprintf("%f",clusterMean)}, + "") if clusterMean > hiThreshold { - logMType <- elekLogDef.GENERAL - logMsg <- "Need to cap a node" + elektronLogging.ElektronLog.Log(elekLogT.GENERAL, + log.InfoLevel, + log.Fields {}, "Need to cap a node") // Create statics for all victims and choose one to cap victims := make([]pcp.Victim, 0, 8) @@ -149,11 +163,14 @@ func StartPCPLogAndExtremaDynamicCap(quit chan struct{}, logging *bool, hiThresh if !cappedHosts[victim.Host] { cappedHosts[victim.Host] = true orderCapped = append(orderCapped, victim.Host) - logMType <- elekLogDef.GENERAL - logMsg <- fmt.Sprintf("Capping Victim %s Avg. Wattage: %f", victim.Host, victim.Watts*pcp.RAPLUnits) + elektronLogging.ElektronLog.Log(elekLogT.GENERAL, + log.InfoLevel, + log.Fields {"Capping Victim" : fmt.Sprintf("%s",victim.Host), + "Avg. Wattage" : fmt.Sprintf("%f", victim.Watts*pcp.RAPLUnits)}, "") if err := rapl.Cap(victim.Host, "rapl", 50); err != nil { - logMType <- elekLogDef.ERROR - logMsg <- "Error capping host" + elektronLogging.ElektronLog.Log(elekLogT.ERROR, + log.ErrorLevel, + log.Fields {}, "Error capping host") } break // Only cap one machine at at time. } @@ -167,11 +184,13 @@ func StartPCPLogAndExtremaDynamicCap(quit chan struct{}, logging *bool, hiThresh cappedHosts[host] = false // User RAPL package to send uncap. log.Printf("Uncapping host %s", host) - logMType <- elekLogDef.GENERAL - logMsg <- fmt.Sprintf("Uncapped host %s", host) + elektronLogging.ElektronLog.Log(elekLogT.GENERAL, + log.InfoLevel, + log.Fields {"Uncapped host" : host}, "") if err := rapl.Cap(host, "rapl", 100); err != nil { - logMType <- elekLogDef.ERROR - logMsg <- "Error capping host" + elektronLogging.ElektronLog.Log(elekLogT.ERROR, + log.ErrorLevel, + log.Fields {}, "Error capping host") } } } @@ -181,8 +200,9 @@ func StartPCPLogAndExtremaDynamicCap(quit chan struct{}, logging *bool, hiThresh } }(logging, hiThreshold, loThreshold) - logMType <- elekLogDef.GENERAL - logMsg <- "PCP logging started" + elektronLogging.ElektronLog.Log(elekLogT.GENERAL, + log.InfoLevel, + log.Fields {}, "PCP logging started") if err := cmd.Start(); err != nil { log.Fatal(err) @@ -192,8 +212,9 @@ func StartPCPLogAndExtremaDynamicCap(quit chan struct{}, logging *bool, hiThresh select { case <-quit: - logMType <- elekLogDef.GENERAL - logMsg <- "Stopping PCP logging in 5 seconds" + elektronLogging.ElektronLog.Log(elekLogT.GENERAL, + log.InfoLevel, + log.Fields {}, "Stopping PCP logging in 5 seconds") time.Sleep(5 * time.Second) // http://stackoverflow.com/questions/22470193/why-wont-go-kill-a-child-process-correctly diff --git a/powerCap/progressiveExtrema.go b/powerCap/progressiveExtrema.go index 8e9cd06..b7502ad 100644 --- a/powerCap/progressiveExtrema.go +++ b/powerCap/progressiveExtrema.go @@ -22,7 +22,6 @@ import ( "bufio" "container/ring" "fmt" - "log" "math" "os/exec" "sort" @@ -32,10 +31,12 @@ import ( "time" "github.com/spdfg/elektron/constants" - elekLogDef "github.com/spdfg/elektron/logging/def" "github.com/spdfg/elektron/pcp" "github.com/spdfg/elektron/rapl" "github.com/spdfg/elektron/utilities" + "github.com/spdfg/elektron/elektronLogging" + elekLogT "github.com/spdfg/elektron/elektronLogging/types" + log "github.com/sirupsen/logrus" ) func round(num float64) int { @@ -48,16 +49,16 @@ func getNextCapValue(curCapValue float64, precision int) float64 { return float64(round(curCapValue*output)) / output } -func StartPCPLogAndProgressiveExtremaCap(quit chan struct{}, logging *bool, hiThreshold, loThreshold float64, - logMType chan elekLogDef.LogMessageType, logMsg chan string, pcpConfigFile string) { +func StartPCPLogAndProgressiveExtremaCap(quit chan struct{}, logging *bool, hiThreshold, loThreshold float64,pcpConfigFile string) { var pcpCommand string = "pmdumptext -m -l -f '' -t 1.0 -d , -c " + pcpConfigFile cmd := exec.Command("sh", "-c", pcpCommand, pcpConfigFile) cmd.SysProcAttr = &syscall.SysProcAttr{Setpgid: true} if hiThreshold < loThreshold { - logMType <- elekLogDef.GENERAL - logMsg <- "High threshold is lower than low threshold!" + elektronLogging.ElektronLog.Log(elekLogT.GENERAL, + log.InfoLevel, + log.Fields {}, "High threshold is lower than low threshold!") } pipe, err := cmd.StdoutPipe() @@ -73,8 +74,9 @@ func StartPCPLogAndProgressiveExtremaCap(quit chan struct{}, logging *bool, hiTh scanner.Scan() // Write to logfile - logMType <- elekLogDef.PCP - logMsg <- scanner.Text() + elektronLogging.ElektronLog.Log(elekLogT.PCP, + log.InfoLevel, + log.Fields {}, scanner.Text()) headers := strings.Split(scanner.Text(), ",") @@ -113,13 +115,15 @@ func StartPCPLogAndProgressiveExtremaCap(quit chan struct{}, logging *bool, hiTh for scanner.Scan() { if *logging { - logMType <- elekLogDef.GENERAL - logMsg <- "Logging PCP..." + elektronLogging.ElektronLog.Log(elekLogT.GENERAL, + log.InfoLevel, + log.Fields {}, "Logging PCP...") split := strings.Split(scanner.Text(), ",") text := scanner.Text() - logMType <- elekLogDef.PCP - logMsg <- text + elektronLogging.ElektronLog.Log(elekLogT.PCP, + log.InfoLevel, + log.Fields {}, text) totalPower := 0.0 for _, powerIndex := range powerIndexes { @@ -130,10 +134,10 @@ func StartPCPLogAndProgressiveExtremaCap(quit chan struct{}, logging *bool, hiTh powerHistories[host].Value = power powerHistories[host] = powerHistories[host].Next() - logMType <- elekLogDef.GENERAL - logMsg <- fmt.Sprintf("Host: %s, Power %f", - indexToHost[powerIndex], (power * pcp.RAPLUnits)) - + elektronLogging.ElektronLog.Log(elekLogT.GENERAL, + log.InfoLevel, + log.Fields {"Host" : fmt.Sprintf("%s",indexToHost[powerIndex]), "Power" : fmt.Sprintf("%f",(power * pcp.RAPLUnits))}, + "") totalPower += power } clusterPower := totalPower * pcp.RAPLUnits @@ -143,16 +147,24 @@ func StartPCPLogAndProgressiveExtremaCap(quit chan struct{}, logging *bool, hiTh clusterMean := pcp.AverageClusterPowerHistory(clusterPowerHist) - logMType <- elekLogDef.GENERAL - logMsg <- fmt.Sprintf("Total power: %f, %d Sec Avg: %f", clusterPower, clusterPowerHist.Len(), clusterMean) + elektronLogging.ElektronLog.Log(elekLogT.GENERAL, + log.InfoLevel, + log.Fields {"Total power" : fmt.Sprintf("%f %d",clusterPower,clusterPowerHist.Len()), + "Sec Avg" : fmt.Sprintf("%f",clusterMean)}, + "") if clusterMean >= hiThreshold { - logMType <- elekLogDef.GENERAL - logMsg <- "Need to cap a node" - logMType <- elekLogDef.GENERAL - logMsg <- fmt.Sprintf("Cap values of capped victims: %v", cappedVictims) - logMType <- elekLogDef.GENERAL - logMsg <- fmt.Sprintf("Cap values of victims to uncap: %v", orderCappedVictims) + elektronLogging.ElektronLog.Log(elekLogT.GENERAL, + log.InfoLevel, + log.Fields {}, "Need to cap a node") + + elektronLogging.ElektronLog.Log(elekLogT.GENERAL, + log.InfoLevel, + log.Fields {"Cap values of capped victims" : fmt.Sprintf("%v",cappedVictims)}, "") + + elektronLogging.ElektronLog.Log(elekLogT.GENERAL, + log.InfoLevel, + log.Fields {"Cap values of victims to uncap" : fmt.Sprintf("%v",orderCappedVictims)}, "") // Create statics for all victims and choose one to cap victims := make([]pcp.Victim, 0, 8) @@ -179,11 +191,15 @@ func StartPCPLogAndProgressiveExtremaCap(quit chan struct{}, logging *bool, hiTh } // Need to cap this victim. if err := rapl.Cap(victims[i].Host, "rapl", 50.0); err != nil { - logMType <- elekLogDef.GENERAL - logMsg <- fmt.Sprintf("Error capping host %s", victims[i].Host) + + elektronLogging.ElektronLog.Log(elekLogT.ERROR, + log.ErrorLevel, + log.Fields {"Error capping host" : fmt.Sprintf("%s",victims[i].Host)}, "") } else { - logMType <- elekLogDef.GENERAL - logMsg <- fmt.Sprintf("Capped host[%s] at %f", victims[i].Host, 50.0) + + elektronLogging.ElektronLog.Log(elekLogT.GENERAL, + log.InfoLevel, + log.Fields {}, fmt.Sprintf("Capped host[%s] at %f", victims[i].Host, 50.0)) // Keeping track of this victim and it's cap value cappedVictims[victims[i].Host] = 50.0 newVictimFound = true @@ -206,12 +222,15 @@ func StartPCPLogAndProgressiveExtremaCap(quit chan struct{}, logging *bool, hiTh if capValue > constants.LowerCapLimit { newCapValue := getNextCapValue(capValue, 2) if err := rapl.Cap(alreadyCappedHosts[i], "rapl", newCapValue); err != nil { - logMType <- elekLogDef.ERROR - logMsg <- fmt.Sprintf("Error capping host[%s]", alreadyCappedHosts[i]) + + elektronLogging.ElektronLog.Log(elekLogT.ERROR, + log.ErrorLevel, + log.Fields {"Error capping host" : fmt.Sprintf("%s",alreadyCappedHosts[i])}, "") } else { // Successful cap - logMType <- elekLogDef.GENERAL - logMsg <- fmt.Sprintf("Capped host[%s] at %f", alreadyCappedHosts[i], newCapValue) + elektronLogging.ElektronLog.Log(elekLogT.GENERAL, + log.InfoLevel, + log.Fields {}, fmt.Sprintf("Capped host[%s] at %f", alreadyCappedHosts[i], newCapValue)) // Checking whether this victim can be capped further if newCapValue <= constants.LowerCapLimit { // Deleting victim from cappedVictims. @@ -234,18 +253,23 @@ func StartPCPLogAndProgressiveExtremaCap(quit chan struct{}, logging *bool, hiTh } } if !canCapAlreadyCappedVictim { - logMType <- elekLogDef.GENERAL - logMsg <- "No Victim left to cap." + elektronLogging.ElektronLog.Log(elekLogT.GENERAL, + log.InfoLevel, + log.Fields {}, "No Victim left to cap") } } } else if clusterMean < loThreshold { - logMType <- elekLogDef.GENERAL - logMsg <- "Need to uncap a node" - logMType <- elekLogDef.GENERAL - logMsg <- fmt.Sprintf("Cap values of capped victims: %v", cappedVictims) - logMType <- elekLogDef.GENERAL - logMsg <- fmt.Sprintf("Cap values of victims to uncap: %v", orderCappedVictims) + + elektronLogging.ElektronLog.Log(elekLogT.GENERAL, + log.InfoLevel, + log.Fields {}, "Need to uncap a node") + elektronLogging.ElektronLog.Log(elekLogT.GENERAL, + log.InfoLevel, + log.Fields {"Cap values of capped victims" : fmt.Sprintf("%v",cappedVictims)}, "") + elektronLogging.ElektronLog.Log(elekLogT.GENERAL, + log.InfoLevel, + log.Fields {"Cap values of victims to uncap" : fmt.Sprintf("%v",orderCappedVictims)}, "") if len(orderCapped) > 0 { // We pick the host that is capped the most to uncap. orderCappedToSort := utilities.GetPairList(orderCappedVictims) @@ -255,12 +279,15 @@ func StartPCPLogAndProgressiveExtremaCap(quit chan struct{}, logging *bool, hiTh // This is a floating point operation and might suffer from precision loss. newUncapValue := orderCappedVictims[hostToUncap] * 2.0 if err := rapl.Cap(hostToUncap, "rapl", newUncapValue); err != nil { - logMType <- elekLogDef.ERROR - logMsg <- fmt.Sprintf("Error uncapping host[%s]", hostToUncap) + + elektronLogging.ElektronLog.Log(elekLogT.ERROR, + log.ErrorLevel, + log.Fields {"Error uncapping host" : fmt.Sprintf("%s",hostToUncap)}, "") } else { // Successful uncap - logMType <- elekLogDef.GENERAL - logMsg <- fmt.Sprintf("Uncapped host[%s] to %f", hostToUncap, newUncapValue) + elektronLogging.ElektronLog.Log(elekLogT.GENERAL, + log.InfoLevel, + log.Fields {}, fmt.Sprintf("Uncapped host[%s] to %f", hostToUncap, newUncapValue)) // Can we uncap this host further. If not, then we remove its entry from orderCapped if newUncapValue >= 100.0 { // can compare using == // Deleting entry from orderCapped @@ -281,8 +308,9 @@ func StartPCPLogAndProgressiveExtremaCap(quit chan struct{}, logging *bool, hiTh } } } else { - logMType <- elekLogDef.GENERAL - logMsg <- "No host staged for Uncapped" + elektronLogging.ElektronLog.Log(elekLogT.GENERAL, + log.InfoLevel, + log.Fields {}, "No host staged for Uncapped") } } } @@ -291,9 +319,9 @@ func StartPCPLogAndProgressiveExtremaCap(quit chan struct{}, logging *bool, hiTh }(logging, hiThreshold, loThreshold) - logMType <- elekLogDef.GENERAL - logMsg <- "PCP logging started" - + elektronLogging.ElektronLog.Log(elekLogT.GENERAL, + log.InfoLevel, + log.Fields {}, "PCP logging started") if err := cmd.Start(); err != nil { log.Fatal(err) } @@ -302,8 +330,9 @@ func StartPCPLogAndProgressiveExtremaCap(quit chan struct{}, logging *bool, hiTh select { case <-quit: - logMType <- elekLogDef.GENERAL - logMsg <- "Stopping PCP logging in 5 seconds" + elektronLogging.ElektronLog.Log(elekLogT.GENERAL, + log.InfoLevel, + log.Fields {}, "Stopping PCP logging in 5 seconds") time.Sleep(5 * time.Second) // http://stackoverflow.com/questions/22470193/why-wont-go-kill-a-child-process-correctly diff --git a/scheduler.go b/scheduler.go index 98b62e7..55b420e 100644 --- a/scheduler.go +++ b/scheduler.go @@ -21,20 +21,20 @@ package main // import github.com/spdfg/elektron import ( "flag" "fmt" - "log" "os" "os/signal" - "strings" "time" "github.com/golang/protobuf/proto" mesos "github.com/mesos/mesos-go/api/v0/mesosproto" sched "github.com/mesos/mesos-go/api/v0/scheduler" "github.com/spdfg/elektron/def" - elekLogDef "github.com/spdfg/elektron/logging/def" "github.com/spdfg/elektron/pcp" "github.com/spdfg/elektron/powerCap" "github.com/spdfg/elektron/schedulers" + "github.com/spdfg/elektron/elektronLogging" + elekLogT "github.com/spdfg/elektron/elektronLogging/types" + log "github.com/sirupsen/logrus" ) var master = flag.String("master", "", "Location of leading Mesos master -- :") @@ -95,10 +95,6 @@ func main() { os.Exit(1) } - // Logging channels. - logMType := make(chan elekLogDef.LogMessageType) - logMsg := make(chan string) - // First we need to build the scheduler using scheduler options. var schedOptions []schedulers.SchedulerOptions = make([]schedulers.SchedulerOptions, 0, 10) @@ -123,7 +119,7 @@ func main() { // Logging channels. // These channels are used by the framework to log messages. // The channels are used to send the type of log message and the message string. - schedOptions = append(schedOptions, schedulers.WithLoggingChannels(logMType, logMsg)) + //schedOptions = append(schedOptions, schedulers.WithLoggingChannels(logMType, logMsg)) // Shutdown indicator channels. // These channels are used to notify, @@ -228,28 +224,20 @@ func main() { log.Fatal(fmt.Sprintf("Unable to create scheduler driver: %s", err)) } - // If here, then all command-line arguments validate. - // Creating logger and attaching different logging platforms. - startTime := time.Now() - formattedStartTime := startTime.Format("20060102150405") // Checking if prefix contains any special characters. - if strings.Contains(*pcplogPrefix, "/") { + /*if strings.Contains(*pcplogPrefix, "/") { log.Fatal("log file prefix should not contain '/'.") - } - logPrefix := *pcplogPrefix + "_" + formattedStartTime - logger := elekLogDef.BuildLogger(startTime, logPrefix) - // Starting the logging go-routine. - go logger.Listen(logMType, logMsg) + }*/ // Starting PCP logging. if noPowercap { - go pcp.Start(pcpLog, &recordPCP, logMType, logMsg, *pcpConfigFile) + go pcp.Start(pcpLog, &recordPCP, *pcpConfigFile) } else if extrema { go powerCap.StartPCPLogAndExtremaDynamicCap(pcpLog, &recordPCP, *hiThreshold, - *loThreshold, logMType, logMsg, *pcpConfigFile) + *loThreshold, *pcpConfigFile) } else if progExtrema { go powerCap.StartPCPLogAndProgressiveExtremaCap(pcpLog, &recordPCP, *hiThreshold, - *loThreshold, logMType, logMsg, *pcpConfigFile) + *loThreshold, *pcpConfigFile) } // Take a second between starting PCP log and continuing. @@ -284,8 +272,6 @@ func main() { close(pcpLog) time.Sleep(5 * time.Second) //Wait for PCP to log a few more seconds // Closing logging channels. - close(logMType) - close(logMsg) //case <-time.After(shutdownTimeout): } @@ -296,7 +282,11 @@ func main() { // Starting the scheduler driver. if status, err := driver.Run(); err != nil { - log.Printf("Framework stopped with status %s and error: %s\n", status.String(), err.Error()) + elektronLogging.ElektronLog.Log(elekLogT.ERROR, + log.ErrorLevel, + log.Fields {"status" : status.String(), "error" : err.Error()}, "Framework stopped ") } - log.Println("Exiting...") + elektronLogging.ElektronLog.Log(elekLogT.GENERAL, + log.InfoLevel, + log.Fields {}, "Exiting...") } diff --git a/schedulers/MaxGreedyMins.go b/schedulers/MaxGreedyMins.go index 8314d27..c555409 100644 --- a/schedulers/MaxGreedyMins.go +++ b/schedulers/MaxGreedyMins.go @@ -19,7 +19,7 @@ package schedulers import ( - "log" + log "github.com/sirupsen/logrus" mesos "github.com/mesos/mesos-go/api/v0/mesosproto" sched "github.com/mesos/mesos-go/api/v0/scheduler" diff --git a/schedulers/MaxMin.go b/schedulers/MaxMin.go index 928134e..ef8fb88 100644 --- a/schedulers/MaxMin.go +++ b/schedulers/MaxMin.go @@ -19,7 +19,7 @@ package schedulers import ( - "log" + log "github.com/sirupsen/logrus" mesos "github.com/mesos/mesos-go/api/v0/mesosproto" sched "github.com/mesos/mesos-go/api/v0/scheduler" diff --git a/schedulers/base.go b/schedulers/base.go index 90e0694..ba8a9a2 100644 --- a/schedulers/base.go +++ b/schedulers/base.go @@ -21,7 +21,6 @@ package schedulers import ( "bytes" "fmt" - "log" "sync" "time" @@ -30,9 +29,11 @@ import ( "github.com/mesos/mesos-go/api/v0/mesosutil" sched "github.com/mesos/mesos-go/api/v0/scheduler" "github.com/spdfg/elektron/def" - elekLogDef "github.com/spdfg/elektron/logging/def" "github.com/spdfg/elektron/utilities" "github.com/spdfg/elektron/utilities/schedUtils" + "github.com/spdfg/elektron/elektronLogging" + elekLogT "github.com/spdfg/elektron/elektronLogging/types" + log "github.com/sirupsen/logrus" ) type BaseScheduler struct { @@ -68,11 +69,6 @@ type BaseScheduler struct { schedTrace *log.Logger - // Send the type of the message to be logged - logMsgType chan elekLogDef.LogMessageType - // Send the message to be logged - logMsg chan string - mutex sync.Mutex // Whether switching of scheduling policies at runtime has been enabled @@ -252,179 +248,170 @@ func (s *BaseScheduler) StatusUpdate(driver sched.SchedulerDriver, status *mesos } } -func (s *BaseScheduler) Log(lmt elekLogDef.LogMessageType, msg string) { - s.mutex.Lock() - s.logMsgType <- lmt - s.logMsg <- msg - s.mutex.Unlock() -} - func (s *BaseScheduler) LogTaskStarting(ts *def.Task, offer *mesos.Offer) { - lmt := elekLogDef.GENERAL - msgColor := elekLogDef.LogMessageColors[lmt] - var msg string + lmt := elekLogT.GENERAL if ts == nil { - msg = msgColor.Sprintf("TASKS STARTING... host = [%s]", offer.GetHostname()) + elektronLogging.ElektronLog.Log(lmt, log.InfoLevel, + log.Fields {"host" : fmt.Sprintf("%s",offer.GetHostname())}, "TASKS STARTING...") } else { - msg = msgColor.Sprintf("TASK STARTING... task = [%s], Instance = %d, host = [%s]", - ts.Name, *ts.Instances, offer.GetHostname()) + elektronLogging.ElektronLog.Log(lmt, + log.InfoLevel, + log.Fields {"task" : fmt.Sprintf("%s",ts.Name), + "Instance" : fmt.Sprintf("%d",*ts.Instances), "host" : fmt.Sprintf("%s",offer.GetHostname())}, + "TASK STARTING... ") } - s.Log(lmt, msg) } func (s *BaseScheduler) LogTaskWattsConsideration(ts def.Task, host string, wattsToConsider float64) { - lmt := elekLogDef.GENERAL - msgColor := elekLogDef.LogMessageColors[lmt] - msg := msgColor.Sprintf("Watts considered for task[%s] and host[%s] = %f Watts", - ts.Name, host, wattsToConsider) - s.Log(lmt, msg) + lmt := elekLogT.GENERAL + elektronLogging.ElektronLog.Log(lmt, + log.InfoLevel, + log.Fields {"task" : ts.Name, "host" : host, "Watts" : fmt.Sprintf("%f",wattsToConsider)}, "Watts considered for ") } func (s *BaseScheduler) LogOffersReceived(offers []*mesos.Offer) { - lmt := elekLogDef.GENERAL - msgColor := elekLogDef.LogMessageColors[lmt] - msg := msgColor.Sprintf("Received %d resource offers", len(offers)) - s.Log(lmt, msg) + lmt := elekLogT.GENERAL + elektronLogging.ElektronLog.Log(lmt, + log.InfoLevel, + log.Fields {"Resource offers received" : fmt.Sprintf("%d",len(offers))}, "") } func (s *BaseScheduler) LogNoPendingTasksDeclineOffers(offer *mesos.Offer) { - lmt := elekLogDef.WARNING - msgColor := elekLogDef.LogMessageColors[lmt] - msg := msgColor.Sprintf("DECLINING OFFER for host[%s]... "+ - "No tasks left to schedule", offer.GetHostname()) - s.Log(lmt, msg) + lmt := elekLogT.WARNING + elektronLogging.ElektronLog.Log(lmt, + log.WarnLevel, + log.Fields {"DECLINING OFFER for host" : fmt.Sprintf("%s",offer.GetHostname())}, "No tasks left to schedule ") } func (s *BaseScheduler) LogNumberOfRunningTasks() { - lmt := elekLogDef.GENERAL - msgColor := elekLogDef.LogMessageColors[lmt] - msg := msgColor.Sprintf("Number of tasks still Running = %d", s.tasksRunning) - s.Log(lmt, msg) + lmt := elekLogT.GENERAL + elektronLogging.ElektronLog.Log(lmt, + log.InfoLevel, + log.Fields {"Number of tasks still Running" : fmt.Sprintf("%d",s.tasksRunning)}, "") } func (s *BaseScheduler) LogCoLocatedTasks(slaveID string) { - lmt := elekLogDef.GENERAL - msgColor := elekLogDef.LogMessageColors[lmt] + lmt := elekLogT.GENERAL buffer := bytes.Buffer{} - buffer.WriteString(fmt.Sprintln("Colocated with:")) s.TasksRunningMutex.Lock() for taskName := range s.Running[slaveID] { buffer.WriteString(fmt.Sprintln(taskName)) } s.TasksRunningMutex.Unlock() - msg := msgColor.Sprintf(buffer.String()) - s.Log(lmt, msg) + elektronLogging.ElektronLog.Log(lmt, + log.InfoLevel, + log.Fields {"Colocated with" : fmt.Sprintf("%s",buffer.String())}, "") } func (s *BaseScheduler) LogSchedTrace(taskToSchedule *mesos.TaskInfo, offer *mesos.Offer) { - msg := fmt.Sprint(offer.GetHostname() + ":" + taskToSchedule.GetTaskId().GetValue()) - s.Log(elekLogDef.SCHED_TRACE, msg) + elektronLogging.ElektronLog.Log(elekLogT.SCHED_TRACE, + log.InfoLevel, + log.Fields {offer.GetHostname() : fmt.Sprintf("%s",taskToSchedule.GetTaskId().GetValue())}, "") } func (s *BaseScheduler) LogTerminateScheduler() { - lmt := elekLogDef.GENERAL - msgColor := elekLogDef.LogMessageColors[lmt] - msg := msgColor.Sprint("Done scheduling all tasks!") - s.Log(lmt, msg) + lmt := elekLogT.GENERAL + elektronLogging.ElektronLog.Log(lmt, + log.InfoLevel, + log.Fields {}, "Done scheduling all tasks!") } func (s *BaseScheduler) LogInsufficientResourcesDeclineOffer(offer *mesos.Offer, offerResources ...interface{}) { - lmt := elekLogDef.WARNING - msgColor := elekLogDef.LogMessageColors[lmt] + lmt := elekLogT.WARNING buffer := bytes.Buffer{} - buffer.WriteString(fmt.Sprintln("DECLINING OFFER... Offer has insufficient resources to launch a task")) - buffer.WriteString(fmt.Sprintf("Offer Resources ", offerResources...)) - msg := msgColor.Sprint(buffer.String()) - s.Log(lmt, msg) + buffer.WriteString(fmt.Sprintf("", offerResources...)) + elektronLogging.ElektronLog.Log(lmt, + log.WarnLevel, + log.Fields {"Offer Resources" : fmt.Sprintf("%s",buffer.String())}, "DECLINING OFFER... Offer has insufficient resources to launch a task") } func (s *BaseScheduler) LogOfferRescinded(offerID *mesos.OfferID) { - lmt := elekLogDef.ERROR - msgColor := elekLogDef.LogMessageColors[lmt] - msg := msgColor.Sprintf("OFFER RESCINDED: OfferID = %s", offerID) - s.Log(lmt, msg) + lmt := elekLogT.ERROR + elektronLogging.ElektronLog.Log(lmt, + log.ErrorLevel, + log.Fields {"OfferID" : fmt.Sprintf("%s",offerID)}, "OFFER RESCINDED") } func (s *BaseScheduler) LogSlaveLost(slaveID *mesos.SlaveID) { - lmt := elekLogDef.ERROR - msgColor := elekLogDef.LogMessageColors[lmt] - msg := msgColor.Sprintf("SLAVE LOST: SlaveID = %s", slaveID) - s.Log(lmt, msg) + lmt := elekLogT.ERROR + elektronLogging.ElektronLog.Log(lmt, + log.ErrorLevel, + log.Fields {"SlaveID" : fmt.Sprintf("%s",slaveID)}, "SLAVE LOST") } func (s *BaseScheduler) LogExecutorLost(executorID *mesos.ExecutorID, slaveID *mesos.SlaveID) { - lmt := elekLogDef.ERROR - msgColor := elekLogDef.LogMessageColors[lmt] - msg := msgColor.Sprintf("EXECUTOR LOST: ExecutorID = %s, SlaveID = %s", executorID, slaveID) - s.Log(lmt, msg) + lmt := elekLogT.ERROR + elektronLogging.ElektronLog.Log(lmt, + log.ErrorLevel, + log.Fields {"ExecutorID" : fmt.Sprintf("%s",executorID), "SlaveID" : fmt.Sprintf("%s", slaveID)}, "EXECUTOR LOST") } func (s *BaseScheduler) LogFrameworkMessage(executorID *mesos.ExecutorID, slaveID *mesos.SlaveID, message string) { - lmt := elekLogDef.GENERAL - msgColor := elekLogDef.LogMessageColors[lmt] - msg := msgColor.Sprintf("Received Framework message from executor [%s]: %s", executorID, message) - s.Log(lmt, msg) + lmt := elekLogT.GENERAL + elektronLogging.ElektronLog.Log(lmt, + log.InfoLevel, + log.Fields {"Received Framework message from executor" : executorID}, message) } func (s *BaseScheduler) LogMesosError(err string) { - lmt := elekLogDef.ERROR - msgColor := elekLogDef.LogMessageColors[lmt] - msg := msgColor.Sprintf("MESOS ERROR: %s", err) - s.Log(lmt, msg) + lmt := elekLogT.ERROR + elektronLogging.ElektronLog.Log(lmt, + log.ErrorLevel, + log.Fields {"MESOS ERROR" : fmt.Sprintf("%v", err)}, "") } func (s *BaseScheduler) LogElectronError(err error) { - lmt := elekLogDef.ERROR - msgColor := elekLogDef.LogMessageColors[lmt] - msg := msgColor.Sprintf("ELECTRON ERROR: %v", err) - s.Log(lmt, msg) + lmt := elekLogT.ERROR + elektronLogging.ElektronLog.Log(lmt, + log.ErrorLevel, + log.Fields {"ELECTRON ERROR" : fmt.Sprintf("%v",err)}, "") } func (s *BaseScheduler) LogFrameworkRegistered(frameworkID *mesos.FrameworkID, masterInfo *mesos.MasterInfo) { - lmt := elekLogDef.SUCCESS - msgColor := elekLogDef.LogMessageColors[lmt] - msg := msgColor.Sprintf("FRAMEWORK REGISTERED! frameworkID = %s, master = %s", - frameworkID, masterInfo) - s.Log(lmt, msg) + lmt := elekLogT.SUCCESS + elektronLogging.ElektronLog.Log(lmt, + log.InfoLevel, + log.Fields {"frameworkID" : fmt.Sprintf("%s",frameworkID), "master" : fmt.Sprintf("%s",masterInfo)}, "FRAMEWORK REGISTERED!") } func (s *BaseScheduler) LogFrameworkReregistered(masterInfo *mesos.MasterInfo) { - lmt := elekLogDef.GENERAL - msgColor := elekLogDef.LogMessageColors[lmt] - msg := msgColor.Sprintf("Framework re-registered with master %s", masterInfo) - s.Log(lmt, msg) + lmt := elekLogT.GENERAL + elektronLogging.ElektronLog.Log(lmt, + log.InfoLevel, + log.Fields {"master" : fmt.Sprintf("%s",masterInfo)}, "Framework re-registered") } func (s *BaseScheduler) LogDisconnected() { - lmt := elekLogDef.WARNING - msgColor := elekLogDef.LogMessageColors[lmt] - msg := msgColor.Sprint("Framework disconnected with master") - s.Log(lmt, msg) + lmt := elekLogT.WARNING + elektronLogging.ElektronLog.Log(lmt, + log.WarnLevel, + log.Fields {}, "Framework disconnected with master") } func (s *BaseScheduler) LogTaskStatusUpdate(status *mesos.TaskStatus) { - var lmt elekLogDef.LogMessageType + lmt := elekLogT.GENERAL switch *status.State { case mesos.TaskState_TASK_ERROR, mesos.TaskState_TASK_FAILED, mesos.TaskState_TASK_KILLED, mesos.TaskState_TASK_LOST: - lmt = elekLogDef.ERROR + lmt = elekLogT.ERROR case mesos.TaskState_TASK_FINISHED: - lmt = elekLogDef.SUCCESS + lmt = elekLogT.SUCCESS default: - lmt = elekLogDef.GENERAL + lmt = elekLogT.GENERAL } - msgColor := elekLogDef.LogMessageColors[lmt] - msg := elekLogDef.LogMessageColors[elekLogDef.GENERAL].Sprintf("Task Status received for task [%s] --> %s", - *status.TaskId.Value, msgColor.Sprint(NameFor(status.State))) - s.Log(lmt, msg) + elektronLogging.ElektronLog.Log(lmt, + log.InfoLevel, + log.Fields {"task" : fmt.Sprintf("%s",*status.TaskId.Value), "state" : NameFor(status.State)}, "Task Status received") } func (s *BaseScheduler) LogSchedPolicySwitch(name string, nextPolicy SchedPolicyState) { logSPS := func() { - s.Log(elekLogDef.SPS, name) + elektronLogging.ElektronLog.Log(elekLogT.SPS, + log.InfoLevel, + log.Fields {"Name" : name}, "") } if s.hasReceivedResourceOffers && (s.curSchedPolicy != nextPolicy) { logSPS() @@ -433,10 +420,14 @@ func (s *BaseScheduler) LogSchedPolicySwitch(name string, nextPolicy SchedPolicy } // Logging the size of the scheduling window and the scheduling policy // that is going to schedule the tasks in the scheduling window. - s.Log(elekLogDef.SCHED_WINDOW, fmt.Sprintf("%d %s", s.schedWindowSize, name)) + elektronLogging.ElektronLog.Log(elekLogT.SCHED_WINDOW, + log.InfoLevel, + log.Fields {"Window size" : fmt.Sprintf("%d",s.schedWindowSize), "Name" : name}, "") } func (s *BaseScheduler) LogClsfnAndTaskDistOverhead(overhead time.Duration) { // Logging the overhead in microseconds. - s.Log(elekLogDef.CLSFN_TASKDIST_OVERHEAD, fmt.Sprintf("%f", float64(overhead.Nanoseconds())/1000.0)) + elektronLogging.ElektronLog.Log(elekLogT.CLSFN_TASKDIST_OVERHEAD, + log.InfoLevel, + log.Fields {"Overhead in microseconds" : fmt.Sprintf("%f", float64(overhead.Nanoseconds())/1000.0)}, "") } diff --git a/schedulers/electronScheduler.go b/schedulers/electronScheduler.go index 82601e7..6b7969f 100644 --- a/schedulers/electronScheduler.go +++ b/schedulers/electronScheduler.go @@ -24,7 +24,6 @@ import ( mesos "github.com/mesos/mesos-go/api/v0/mesosproto" sched "github.com/mesos/mesos-go/api/v0/scheduler" "github.com/spdfg/elektron/def" - elekLogDef "github.com/spdfg/elektron/logging/def" ) // Implements mesos scheduler. @@ -38,8 +37,6 @@ type ElectronScheduler interface { // Each of these functions are supposed to call the Log(...) that sends the // log message type, and the log message to the corresponding channels. - // Pass the logMessageType and the logMessage to the loggers for logging. - Log(logMType elekLogDef.LogMessageType, logMsg string) // To be called when about to launch a task. // Log message indicating that a task is about to start executing. // Also, log the host on which the task is going to be launched. diff --git a/schedulers/helpers.go b/schedulers/helpers.go index 904ec51..439e740 100644 --- a/schedulers/helpers.go +++ b/schedulers/helpers.go @@ -25,19 +25,24 @@ import ( "github.com/pkg/errors" "github.com/spdfg/elektron/constants" "github.com/spdfg/elektron/def" - elekLogDef "github.com/spdfg/elektron/logging/def" "github.com/spdfg/elektron/utilities" "github.com/spdfg/elektron/utilities/mesosUtils" - "log" + log "github.com/sirupsen/logrus" + "github.com/spdfg/elektron/elektronLogging" + elekLogT "github.com/spdfg/elektron/elektronLogging/types" ) func coLocated(tasks map[string]bool, s BaseScheduler) { for task := range tasks { - s.Log(elekLogDef.GENERAL, task) + elektronLogging.ElektronLog.Log(elekLogT.GENERAL, + log.InfoLevel, + log.Fields {"Task" : task}, "") } - s.Log(elekLogDef.GENERAL, "---------------------") + elektronLogging.ElektronLog.Log(elekLogT.GENERAL, + log.InfoLevel, + log.Fields {}, "---------------------") } // Get the powerClass of the given hostname. @@ -129,13 +134,13 @@ func WithPCPLog(pcpLog chan struct{}) SchedulerOptions { } } -func WithLoggingChannels(lmt chan elekLogDef.LogMessageType, msg chan string) SchedulerOptions { +/*func WithLoggingChannels(lmt chan elekLogDef.LogMessageType, msg chan string) SchedulerOptions { return func(s ElectronScheduler) error { s.(*BaseScheduler).logMsgType = lmt s.(*BaseScheduler).logMsg = msg return nil } -} +}*/ func WithSchedPolSwitchEnabled(enableSchedPolicySwitch bool, switchingCriteria string) SchedulerOptions { return func(s ElectronScheduler) error { diff --git a/schedulers/schedPolicy.go b/schedulers/schedPolicy.go index ee90741..bd07641 100644 --- a/schedulers/schedPolicy.go +++ b/schedulers/schedPolicy.go @@ -20,13 +20,14 @@ package schedulers import ( "fmt" - "log" "time" mesos "github.com/mesos/mesos-go/api/v0/mesosproto" sched "github.com/mesos/mesos-go/api/v0/scheduler" "github.com/spdfg/elektron/def" - elekLogDef "github.com/spdfg/elektron/logging/def" + "github.com/spdfg/elektron/elektronLogging" + elekLogT "github.com/spdfg/elektron/elektronLogging/types" + log "github.com/sirupsen/logrus" ) type SchedPolicyContext interface { @@ -89,7 +90,9 @@ func switchTaskDistBased(baseSchedRef *BaseScheduler) string { // Determine the distribution of tasks in the new scheduling window. taskDist, err := def.GetTaskDistributionInWindow(baseSchedRef.schedWindowSize, baseSchedRef.tasks) baseSchedRef.LogClsfnAndTaskDistOverhead(time.Now().Sub(startTime)) - baseSchedRef.Log(elekLogDef.GENERAL, fmt.Sprintf("Switching... TaskDistribution[%f]", taskDist)) + elektronLogging.ElektronLog.Log(elekLogT.GENERAL, + log.InfoLevel, + log.Fields {"Task Distribution" : fmt.Sprintf("%s",taskDist)}, "Switching... ") if err != nil { // All the tasks in the window were only classified into 1 cluster. // Max-Min and Max-GreedyMins would work the same way as Bin-Packing for this situation. -- 2.47.2 From 40efeca04bf3277faa614d46a51bc7e131e7e3db Mon Sep 17 00:00:00 2001 From: balandi1 Date: Wed, 13 Nov 2019 15:37:55 -0500 Subject: [PATCH 04/48] Replaced old usage with new library --- def/taskUtils.go | 10 +++++++--- utilities/offerUtils/offerUtils.go | 12 ++++++++---- utilities/schedUtils/schedUtils.go | 11 +++++++---- 3 files changed, 22 insertions(+), 11 deletions(-) diff --git a/def/taskUtils.go b/def/taskUtils.go index 33f19f2..ba019e2 100644 --- a/def/taskUtils.go +++ b/def/taskUtils.go @@ -21,11 +21,13 @@ package def import ( "errors" "fmt" - "log" "sort" "github.com/mash/gokmeans" "github.com/montanaflynn/stats" + "github.com/spdfg/elektron/elektronLogging" + elekLogT "github.com/spdfg/elektron/elektronLogging/types" + log "github.com/sirupsen/logrus" ) // Information about a cluster of tasks. @@ -50,7 +52,8 @@ func (tc TasksToClassify) taskObservationCalculator(task Task) []float64 { } else if task.Watts != 0.0 { return []float64{task.Watts} } else { - log.Fatal("Unable to classify tasks. Missing Watts or ClassToWatts attribute in workload.") + elektronLogging.ElektronLog.Log(elekLogT.ERROR, log.FatalLevel, + log.Fields {}, "Unable to classify tasks. Missing Watts or ClassToWatts attribute in workload") return []float64{0.0} // Won't reach here. } } @@ -105,7 +108,8 @@ func clusterSizeAvgMMMPU(tasks []Task, taskObservation func(task Task) []float64 } else { // skip this value // there is an error in the task config. - log.Println(err) + elektronLogging.ElektronLog.Log(elekLogT.ERROR, log.ErrorLevel, + log.Fields {}, fmt.Sprintf("%s",err)) } } else { // There is only one observation for the task. diff --git a/utilities/offerUtils/offerUtils.go b/utilities/offerUtils/offerUtils.go index 2d67af1..7f05411 100644 --- a/utilities/offerUtils/offerUtils.go +++ b/utilities/offerUtils/offerUtils.go @@ -19,11 +19,13 @@ package offerUtils import ( - "log" "strings" - + "fmt" mesos "github.com/mesos/mesos-go/api/v0/mesosproto" "github.com/spdfg/elektron/constants" + "github.com/spdfg/elektron/elektronLogging" + elekLogT "github.com/spdfg/elektron/elektronLogging/types" + log "github.com/sirupsen/logrus" ) func OfferAgg(offer *mesos.Offer) (float64, float64, float64) { @@ -88,12 +90,14 @@ func UpdateEnvironment(offer *mesos.Offer) { var host = offer.GetHostname() // If this host is not present in the set of hosts. if _, ok := constants.Hosts[host]; !ok { - log.Printf("New host detected. Adding host [%s]", host) + elektronLogging.ElektronLog.Log(elekLogT.GENERAL, log.InfoLevel, + log.Fields {"Adding host" : fmt.Sprintf("%s",host)}, "New host detected") // Add this host. constants.Hosts[host] = struct{}{} // Get the power class of this host. class := PowerClass(offer) - log.Printf("Registering the power class... Host [%s] --> PowerClass [%s]", host, class) + elektronLogging.ElektronLog.Log(elekLogT.GENERAL, log.InfoLevel, + log.Fields {"host" : fmt.Sprintf("%s",host), "PowerClass" : fmt.Sprintf("%s", class)}, "Registering the power class...") // If new power class, register the power class. if _, ok := constants.PowerClasses[class]; !ok { constants.PowerClasses[class] = make(map[string]struct{}) diff --git a/utilities/schedUtils/schedUtils.go b/utilities/schedUtils/schedUtils.go index e25437e..31eff56 100644 --- a/utilities/schedUtils/schedUtils.go +++ b/utilities/schedUtils/schedUtils.go @@ -19,10 +19,12 @@ package schedUtils import ( - "log" - + "fmt" "github.com/spdfg/elektron/def" "github.com/spdfg/elektron/utilities" + "github.com/spdfg/elektron/elektronLogging" + elekLogT "github.com/spdfg/elektron/elektronLogging/types" + log "github.com/sirupsen/logrus" ) // Criteria for resizing the scheduling window. @@ -77,8 +79,9 @@ func (s *fillNextOfferCycle) apply(taskQueue []def.Task) (int, int) { for _, task := range taskQueue { numberOfTasksTraversed++ for i := *task.Instances; i > 0; i-- { - log.Printf("Checking if Instance #%d of Task[%s] can be scheduled "+ - "during the next offer cycle...", i, task.Name) + elektronLogging.ElektronLog.Log(elekLogT.GENERAL, log.InfoLevel, + log.Fields {}, fmt.Sprintf("Checking if Instance #%d of Task[%s] can be scheduled "+ + "during the next offer cycle...", i, task.Name)) if canSchedule(task) { filledCPU += task.CPU filledRAM += task.RAM -- 2.47.2 From cef6efee33408aa977de7662e02f043fe95ef314 Mon Sep 17 00:00:00 2001 From: balandi1 Date: Wed, 13 Nov 2019 16:10:19 -0500 Subject: [PATCH 05/48] Deleted the unused logging library --- logging/def/clsfnTaskDistOverhead.go | 29 ------ logging/def/consoleLogger.go | 36 -------- logging/def/logType.go | 62 ------------- logging/def/logger.go | 77 ---------------- logging/def/loggerFactory.go | 121 ------------------------- logging/def/loggerObservers.go | 120 ------------------------ logging/def/loggerSubject.go | 41 --------- logging/def/pcpLogger.go | 27 ------ logging/def/schedPolicySwitchLogger.go | 27 ------ logging/def/schedTraceLogger.go | 28 ------ logging/def/schedWindowLogger.go | 28 ------ logging/utils/createLogDir.go | 57 ------------ 12 files changed, 653 deletions(-) delete mode 100644 logging/def/clsfnTaskDistOverhead.go delete mode 100644 logging/def/consoleLogger.go delete mode 100644 logging/def/logType.go delete mode 100644 logging/def/logger.go delete mode 100644 logging/def/loggerFactory.go delete mode 100644 logging/def/loggerObservers.go delete mode 100644 logging/def/loggerSubject.go delete mode 100644 logging/def/pcpLogger.go delete mode 100644 logging/def/schedPolicySwitchLogger.go delete mode 100644 logging/def/schedTraceLogger.go delete mode 100644 logging/def/schedWindowLogger.go delete mode 100644 logging/utils/createLogDir.go diff --git a/logging/def/clsfnTaskDistOverhead.go b/logging/def/clsfnTaskDistOverhead.go deleted file mode 100644 index 1189001..0000000 --- a/logging/def/clsfnTaskDistOverhead.go +++ /dev/null @@ -1,29 +0,0 @@ -// Copyright (C) 2018 spdfg -// -// This file is part of Elektron. -// -// Elektron is free software: you can redistribute it and/or modify -// it under the terms of the GNU General Public License as published by -// the Free Software Foundation, either version 3 of the License, or -// (at your option) any later version. -// -// Elektron is distributed in the hope that it will be useful, -// but WITHOUT ANY WARRANTY; without even the implied warranty of -// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the -// GNU General Public License for more details. -// -// You should have received a copy of the GNU General Public License -// along with Elektron. If not, see . -// - -package logging - -type ClsfnTaskDistOverheadLogger struct { - loggerObserverImpl -} - -func (col ClsfnTaskDistOverheadLogger) Log(message string) { - // Logging the overhead of classifying tasks in the scheduling window and determining the distribution - // of light power consuming and heavy power consuming tasks. - col.logObserverSpecifics[clsfnTaskDistOverheadLogger].logFile.Println(message) -} diff --git a/logging/def/consoleLogger.go b/logging/def/consoleLogger.go deleted file mode 100644 index a6bf901..0000000 --- a/logging/def/consoleLogger.go +++ /dev/null @@ -1,36 +0,0 @@ -// Copyright (C) 2018 spdfg -// -// This file is part of Elektron. -// -// Elektron is free software: you can redistribute it and/or modify -// it under the terms of the GNU General Public License as published by -// the Free Software Foundation, either version 3 of the License, or -// (at your option) any later version. -// -// Elektron is distributed in the hope that it will be useful, -// but WITHOUT ANY WARRANTY; without even the implied warranty of -// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the -// GNU General Public License for more details. -// -// You should have received a copy of the GNU General Public License -// along with Elektron. If not, see . -// - -package logging - -import ( - "log" -) - -type ConsoleLogger struct { - loggerObserverImpl -} - -func (cl ConsoleLogger) Log(message string) { - // We need to log to console only if the message is not empty - if message != "" { - log.Println(message) - // Also logging the message to the console log file - cl.logObserverSpecifics[conLogger].logFile.Println(message) - } -} diff --git a/logging/def/logType.go b/logging/def/logType.go deleted file mode 100644 index f495173..0000000 --- a/logging/def/logType.go +++ /dev/null @@ -1,62 +0,0 @@ -// Copyright (C) 2018 spdfg -// -// This file is part of Elektron. -// -// Elektron is free software: you can redistribute it and/or modify -// it under the terms of the GNU General Public License as published by -// the Free Software Foundation, either version 3 of the License, or -// (at your option) any later version. -// -// Elektron is distributed in the hope that it will be useful, -// but WITHOUT ANY WARRANTY; without even the implied warranty of -// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the -// GNU General Public License for more details. -// -// You should have received a copy of the GNU General Public License -// along with Elektron. If not, see . -// - -package logging - -import "github.com/fatih/color" - -// Defining enums of log message types -var logMessageNames []string - -// Possible log message types -var ( - ERROR = messageNametoMessageType("ERROR") - WARNING = messageNametoMessageType("WARNING") - GENERAL = messageNametoMessageType("GENERAL") - SUCCESS = messageNametoMessageType("SUCCESS") - SCHED_TRACE = messageNametoMessageType("SCHED_TRACE") - PCP = messageNametoMessageType("PCP") - SPS = messageNametoMessageType("SPS") - CLSFN_TASKDIST_OVERHEAD = messageNametoMessageType("CLSFN_TASKDIST_OVERHEAD") - SCHED_WINDOW = messageNametoMessageType("SCHED_WINDOW") -) - -// Text colors for the different types of log messages. -var LogMessageColors map[LogMessageType]*color.Color = map[LogMessageType]*color.Color{ - ERROR: color.New(color.FgRed, color.Bold), - WARNING: color.New(color.FgYellow, color.Bold), - GENERAL: color.New(color.FgWhite, color.Bold), - SUCCESS: color.New(color.FgGreen, color.Bold), -} - -type LogMessageType int - -func (lmt LogMessageType) String() string { - return logMessageNames[lmt] -} - -func GetLogMessageTypes() []string { - return logMessageNames -} - -func messageNametoMessageType(messageName string) LogMessageType { - // Appending messageName to LogMessageNames - logMessageNames = append(logMessageNames, messageName) - // Mapping messageName to int - return LogMessageType(len(logMessageNames) - 1) -} diff --git a/logging/def/logger.go b/logging/def/logger.go deleted file mode 100644 index e713691..0000000 --- a/logging/def/logger.go +++ /dev/null @@ -1,77 +0,0 @@ -// Copyright (C) 2018 spdfg -// -// This file is part of Elektron. -// -// Elektron is free software: you can redistribute it and/or modify -// it under the terms of the GNU General Public License as published by -// the Free Software Foundation, either version 3 of the License, or -// (at your option) any later version. -// -// Elektron is distributed in the hope that it will be useful, -// but WITHOUT ANY WARRANTY; without even the implied warranty of -// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the -// GNU General Public License for more details. -// -// You should have received a copy of the GNU General Public License -// along with Elektron. If not, see . -// - -package logging - -import ( - "time" -) - -type LoggerDriver struct { - loggerSubject - allowedMessageTypes map[LogMessageType]bool -} - -func newLogger() *LoggerDriver { - logger := &LoggerDriver{ - allowedMessageTypes: map[LogMessageType]bool{ - ERROR: true, - GENERAL: true, - WARNING: true, - SCHED_TRACE: true, - SUCCESS: true, - PCP: true, - SPS: true, - CLSFN_TASKDIST_OVERHEAD: true, - SCHED_WINDOW: true, - }, - } - return logger -} - -func BuildLogger(startTime time.Time, prefix string) *LoggerDriver { - // building logger - l := newLogger() - attachAllLoggers(l, startTime, prefix) - return l -} - -func (log *LoggerDriver) EnabledLogging(messageType LogMessageType) { - log.allowedMessageTypes[messageType] = true -} - -func (log *LoggerDriver) DisableLogging(messageType LogMessageType) { - log.allowedMessageTypes[messageType] = false -} - -func (log *LoggerDriver) WriteLog(messageType LogMessageType, message string) { - // checking to see if logging for given messageType is disabled - if log.allowedMessageTypes[messageType] { - log.setMessage(message) - // notify registered loggers to log - log.notify(messageType) - } -} - -func (log *LoggerDriver) Listen(logMType <-chan LogMessageType, logMsg <-chan string) { - for { - mType := <-logMType - msg := <-logMsg - log.WriteLog(mType, msg) - } -} diff --git a/logging/def/loggerFactory.go b/logging/def/loggerFactory.go deleted file mode 100644 index a2f8a73..0000000 --- a/logging/def/loggerFactory.go +++ /dev/null @@ -1,121 +0,0 @@ -// Copyright (C) 2018 spdfg -// -// This file is part of Elektron. -// -// Elektron is free software: you can redistribute it and/or modify -// it under the terms of the GNU General Public License as published by -// the Free Software Foundation, either version 3 of the License, or -// (at your option) any later version. -// -// Elektron is distributed in the hope that it will be useful, -// but WITHOUT ANY WARRANTY; without even the implied warranty of -// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the -// GNU General Public License for more details. -// -// You should have received a copy of the GNU General Public License -// along with Elektron. If not, see . -// - -package logging - -import ( - "strings" - "time" - - logUtils "github.com/spdfg/elektron/logging/utils" -) - -// Names of different loggers -const ( - conLogger = "console-logger" - schedTraceLogger = "schedTrace-logger" - pcpLogger = "pcp-logger" - spsLogger = "schedPolicySwitch-logger" - clsfnTaskDistOverheadLogger = "classificationOverhead-logger" - schedWindowLogger = "schedWindow-logger" -) - -// Logger class factory -var Loggers map[string]loggerObserver = map[string]loggerObserver{ - conLogger: nil, - schedTraceLogger: nil, - pcpLogger: nil, - spsLogger: nil, - clsfnTaskDistOverheadLogger: nil, - schedWindowLogger: nil, -} - -// Logger options to help initialize loggers -type loggerOption func(l loggerObserver) error - -func withLogDirectory(startTime time.Time, prefix string) loggerOption { - return func(l loggerObserver) error { - l.(*loggerObserverImpl).setLogDirectory(logUtils.GetLogDir(startTime, prefix)) - return nil - } -} - -// This loggerOption initializes the specifics for each loggerObserver -func withLoggerSpecifics(prefix string) loggerOption { - return func(l loggerObserver) error { - l.(*loggerObserverImpl).logObserverSpecifics = map[string]*specifics{ - conLogger: &specifics{}, - schedTraceLogger: &specifics{}, - pcpLogger: &specifics{}, - spsLogger: &specifics{}, - clsfnTaskDistOverheadLogger: &specifics{}, - schedWindowLogger: &specifics{}, - } - l.(*loggerObserverImpl).setLogFilePrefix(prefix) - l.(*loggerObserverImpl).setLogFile() - return nil - } -} - -// Build and assign all loggers -func attachAllLoggers(lg *LoggerDriver, startTime time.Time, prefix string) { - loi := &loggerObserverImpl{} - loi.init(withLogDirectory(startTime, strings.Split(prefix, startTime.Format("20060102150405"))[0]), - withLoggerSpecifics(prefix)) - Loggers[conLogger] = &ConsoleLogger{ - loggerObserverImpl: *loi, - } - Loggers[schedTraceLogger] = &SchedTraceLogger{ - loggerObserverImpl: *loi, - } - Loggers[pcpLogger] = &PCPLogger{ - loggerObserverImpl: *loi, - } - Loggers[spsLogger] = &SchedPolicySwitchLogger{ - loggerObserverImpl: *loi, - } - Loggers[clsfnTaskDistOverheadLogger] = &ClsfnTaskDistOverheadLogger{ - loggerObserverImpl: *loi, - } - Loggers[schedWindowLogger] = &SchedWindowLogger{ - loggerObserverImpl: *loi, - } - - for _, lmt := range GetLogMessageTypes() { - switch lmt { - case SCHED_TRACE.String(): - lg.attach(SCHED_TRACE, Loggers[schedTraceLogger]) - case GENERAL.String(): - lg.attach(GENERAL, Loggers[conLogger]) - case WARNING.String(): - lg.attach(WARNING, Loggers[conLogger]) - case ERROR.String(): - lg.attach(ERROR, Loggers[conLogger]) - case SUCCESS.String(): - lg.attach(SUCCESS, Loggers[conLogger]) - case PCP.String(): - lg.attach(PCP, Loggers[pcpLogger]) - case SPS.String(): - lg.attach(SPS, Loggers[spsLogger]) - case CLSFN_TASKDIST_OVERHEAD.String(): - lg.attach(CLSFN_TASKDIST_OVERHEAD, Loggers[clsfnTaskDistOverheadLogger]) - case SCHED_WINDOW.String(): - lg.attach(SCHED_WINDOW, Loggers[schedWindowLogger]) - } - } -} diff --git a/logging/def/loggerObservers.go b/logging/def/loggerObservers.go deleted file mode 100644 index f4aa5ca..0000000 --- a/logging/def/loggerObservers.go +++ /dev/null @@ -1,120 +0,0 @@ -// Copyright (C) 2018 spdfg -// -// This file is part of Elektron. -// -// Elektron is free software: you can redistribute it and/or modify -// it under the terms of the GNU General Public License as published by -// the Free Software Foundation, either version 3 of the License, or -// (at your option) any later version. -// -// Elektron is distributed in the hope that it will be useful, -// but WITHOUT ANY WARRANTY; without even the implied warranty of -// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the -// GNU General Public License for more details. -// -// You should have received a copy of the GNU General Public License -// along with Elektron. If not, see . -// - -package logging - -import ( - "fmt" - "log" - "os" -) - -// Logging platform -type loggerObserver interface { - Log(message string) - setLogFile() - setLogFilePrefix(prefix string) - setLogDirectory(dirName string) - init(opts ...loggerOption) -} - -type specifics struct { - logFilePrefix string - logFile *log.Logger -} - -type loggerObserverImpl struct { - logFile *log.Logger - logObserverSpecifics map[string]*specifics - logDirectory string -} - -func (loi *loggerObserverImpl) init(opts ...loggerOption) { - for _, opt := range opts { - // applying logger options - if err := opt(loi); err != nil { - log.Fatal(err) - } - } -} - -func (loi loggerObserverImpl) Log(message string) {} - -// Requires logFilePrefix to have already been set -func (loi *loggerObserverImpl) setLogFile() { - for prefix, ls := range loi.logObserverSpecifics { - if logFile, err := os.Create(ls.logFilePrefix); err != nil { - log.Fatal("Unable to create logFile: ", err) - } else { - fmt.Printf("Creating logFile with pathname: %s, and prefix: %s\n", ls.logFilePrefix, prefix) - ls.logFile = log.New(logFile, "", log.LstdFlags) - } - } -} - -func (loi *loggerObserverImpl) setLogFilePrefix(prefix string) { - // Setting logFilePrefix for pcp logger - pcpLogFilePrefix := prefix + ".pcplog" - if loi.logDirectory != "" { - pcpLogFilePrefix = loi.logDirectory + "/" + pcpLogFilePrefix - } - loi.logObserverSpecifics[pcpLogger].logFilePrefix = pcpLogFilePrefix - - // Setting logFilePrefix for console logger - consoleLogFilePrefix := prefix + "_console.log" - if loi.logDirectory != "" { - consoleLogFilePrefix = loi.logDirectory + "/" + consoleLogFilePrefix - } - loi.logObserverSpecifics[conLogger].logFilePrefix = consoleLogFilePrefix - - // Setting logFilePrefix for schedTrace logger - schedTraceLogFilePrefix := prefix + "_schedTrace.log" - if loi.logDirectory != "" { - schedTraceLogFilePrefix = loi.logDirectory + "/" + schedTraceLogFilePrefix - } - loi.logObserverSpecifics[schedTraceLogger].logFilePrefix = schedTraceLogFilePrefix - - // Setting logFilePrefix for schedulingPolicySwitch logger - schedPolicySwitchLogFilePrefix := prefix + "_schedPolicySwitch.log" - if loi.logDirectory != "" { - schedPolicySwitchLogFilePrefix = loi.logDirectory + "/" + schedPolicySwitchLogFilePrefix - } - loi.logObserverSpecifics[spsLogger].logFilePrefix = schedPolicySwitchLogFilePrefix - - // Setting logFilePrefix for clsfnTaskDist logger. - // Execution time of every call to def.GetTaskDistribution(...) would be recorded and logged in this file. - // The overhead would be logged in microseconds. - clsfnTaskDistOverheadLogFilePrefix := prefix + "_classificationOverhead.log" - if loi.logDirectory != "" { - clsfnTaskDistOverheadLogFilePrefix = loi.logDirectory + "/" + clsfnTaskDistOverheadLogFilePrefix - } - loi.logObserverSpecifics[clsfnTaskDistOverheadLogger].logFilePrefix = clsfnTaskDistOverheadLogFilePrefix - - // Setting logFilePrefix for schedWindow logger. - // Going to log the time stamp when the scheduling window was determined - // and the size of the scheduling window. - schedWindowLogFilePrefix := prefix + "_schedWindow.log" - if loi.logDirectory != "" { - schedWindowLogFilePrefix = loi.logDirectory + "/" + schedWindowLogFilePrefix - } - loi.logObserverSpecifics[schedWindowLogger].logFilePrefix = schedWindowLogFilePrefix -} - -func (loi *loggerObserverImpl) setLogDirectory(dirName string) { - loi.logDirectory = dirName -} diff --git a/logging/def/loggerSubject.go b/logging/def/loggerSubject.go deleted file mode 100644 index db1f72b..0000000 --- a/logging/def/loggerSubject.go +++ /dev/null @@ -1,41 +0,0 @@ -// Copyright (C) 2018 spdfg -// -// This file is part of Elektron. -// -// Elektron is free software: you can redistribute it and/or modify -// it under the terms of the GNU General Public License as published by -// the Free Software Foundation, either version 3 of the License, or -// (at your option) any later version. -// -// Elektron is distributed in the hope that it will be useful, -// but WITHOUT ANY WARRANTY; without even the implied warranty of -// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the -// GNU General Public License for more details. -// -// You should have received a copy of the GNU General Public License -// along with Elektron. If not, see . -// - -package logging - -type loggerSubject struct { - Registry map[LogMessageType][]loggerObserver - message string -} - -func (ls *loggerSubject) setMessage(message string) { - ls.message = message -} - -func (ls *loggerSubject) attach(messageType LogMessageType, lo loggerObserver) { - if ls.Registry == nil { - ls.Registry = make(map[LogMessageType][]loggerObserver) - } - ls.Registry[messageType] = append(ls.Registry[messageType], lo) -} - -func (ls *loggerSubject) notify(messageType LogMessageType) { - for _, logObserver := range ls.Registry[messageType] { - logObserver.Log(ls.message) - } -} diff --git a/logging/def/pcpLogger.go b/logging/def/pcpLogger.go deleted file mode 100644 index e75b788..0000000 --- a/logging/def/pcpLogger.go +++ /dev/null @@ -1,27 +0,0 @@ -// Copyright (C) 2018 spdfg -// -// This file is part of Elektron. -// -// Elektron is free software: you can redistribute it and/or modify -// it under the terms of the GNU General Public License as published by -// the Free Software Foundation, either version 3 of the License, or -// (at your option) any later version. -// -// Elektron is distributed in the hope that it will be useful, -// but WITHOUT ANY WARRANTY; without even the implied warranty of -// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the -// GNU General Public License for more details. -// -// You should have received a copy of the GNU General Public License -// along with Elektron. If not, see . -// - -package logging - -type PCPLogger struct { - loggerObserverImpl -} - -func (pl *PCPLogger) Log(message string) { - pl.logObserverSpecifics[pcpLogger].logFile.Println(message) -} diff --git a/logging/def/schedPolicySwitchLogger.go b/logging/def/schedPolicySwitchLogger.go deleted file mode 100644 index 70ecc9d..0000000 --- a/logging/def/schedPolicySwitchLogger.go +++ /dev/null @@ -1,27 +0,0 @@ -// Copyright (C) 2018 spdfg -// -// This file is part of Elektron. -// -// Elektron is free software: you can redistribute it and/or modify -// it under the terms of the GNU General Public License as published by -// the Free Software Foundation, either version 3 of the License, or -// (at your option) any later version. -// -// Elektron is distributed in the hope that it will be useful, -// but WITHOUT ANY WARRANTY; without even the implied warranty of -// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the -// GNU General Public License for more details. -// -// You should have received a copy of the GNU General Public License -// along with Elektron. If not, see . -// - -package logging - -type SchedPolicySwitchLogger struct { - loggerObserverImpl -} - -func (pl *SchedPolicySwitchLogger) Log(message string) { - pl.logObserverSpecifics[spsLogger].logFile.Println(message) -} diff --git a/logging/def/schedTraceLogger.go b/logging/def/schedTraceLogger.go deleted file mode 100644 index 5b55e4f..0000000 --- a/logging/def/schedTraceLogger.go +++ /dev/null @@ -1,28 +0,0 @@ -// Copyright (C) 2018 spdfg -// -// This file is part of Elektron. -// -// Elektron is free software: you can redistribute it and/or modify -// it under the terms of the GNU General Public License as published by -// the Free Software Foundation, either version 3 of the License, or -// (at your option) any later version. -// -// Elektron is distributed in the hope that it will be useful, -// but WITHOUT ANY WARRANTY; without even the implied warranty of -// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the -// GNU General Public License for more details. -// -// You should have received a copy of the GNU General Public License -// along with Elektron. If not, see . -// - -package logging - -type SchedTraceLogger struct { - loggerObserverImpl -} - -func (stl SchedTraceLogger) Log(message string) { - // Logging schedule trace to mentioned file - stl.logObserverSpecifics[schedTraceLogger].logFile.Println(message) -} diff --git a/logging/def/schedWindowLogger.go b/logging/def/schedWindowLogger.go deleted file mode 100644 index d0f4d06..0000000 --- a/logging/def/schedWindowLogger.go +++ /dev/null @@ -1,28 +0,0 @@ -// Copyright (C) 2018 spdfg -// -// This file is part of Elektron. -// -// Elektron is free software: you can redistribute it and/or modify -// it under the terms of the GNU General Public License as published by -// the Free Software Foundation, either version 3 of the License, or -// (at your option) any later version. -// -// Elektron is distributed in the hope that it will be useful, -// but WITHOUT ANY WARRANTY; without even the implied warranty of -// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the -// GNU General Public License for more details. -// -// You should have received a copy of the GNU General Public License -// along with Elektron. If not, see . -// - -package logging - -type SchedWindowLogger struct { - loggerObserverImpl -} - -func (swl SchedWindowLogger) Log(message string) { - // Logging schedule trace to mentioned file - swl.logObserverSpecifics[schedWindowLogger].logFile.Println(message) -} diff --git a/logging/utils/createLogDir.go b/logging/utils/createLogDir.go deleted file mode 100644 index d701252..0000000 --- a/logging/utils/createLogDir.go +++ /dev/null @@ -1,57 +0,0 @@ -// Copyright (C) 2018 spdfg -// -// This file is part of Elektron. -// -// Elektron is free software: you can redistribute it and/or modify -// it under the terms of the GNU General Public License as published by -// the Free Software Foundation, either version 3 of the License, or -// (at your option) any later version. -// -// Elektron is distributed in the hope that it will be useful, -// but WITHOUT ANY WARRANTY; without even the implied warranty of -// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the -// GNU General Public License for more details. -// -// You should have received a copy of the GNU General Public License -// along with Elektron. If not, see . -// - -package logging - -import ( - "log" - "os" - "strconv" - "time" -) - -var LogDir string - -func GetLogDir(startTime time.Time, prefix string) string { - if LogDir == "" { - LogDir = createLogDir(prefix, startTime) - } - return LogDir -} - -func createLogDir(prefix string, startTime time.Time) string { - // Creating directory to store all logs for this run - logDirName := "./" + prefix + strconv.Itoa(startTime.Year()) - logDirName += "-" - logDirName += startTime.Month().String() - logDirName += "-" - logDirName += strconv.Itoa(startTime.Day()) - logDirName += "_" - logDirName += strconv.Itoa(startTime.Hour()) - logDirName += "-" - logDirName += strconv.Itoa(startTime.Minute()) - logDirName += "-" - logDirName += strconv.Itoa(startTime.Second()) - if _, err := os.Stat(logDirName); os.IsNotExist(err) { - os.Mkdir(logDirName, 0755) - } else { - log.Println("Unable to create log directory: ", err) - logDirName = "" - } - return logDirName -} -- 2.47.2 From ef8bd6ac1f0e5b075fd1a39d661dce04ba83284d Mon Sep 17 00:00:00 2001 From: balandi1 Date: Wed, 13 Nov 2019 16:16:58 -0500 Subject: [PATCH 06/48] Fixed minor bug --- schedulers/schedPolicy.go | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/schedulers/schedPolicy.go b/schedulers/schedPolicy.go index bd07641..1ae1b72 100644 --- a/schedulers/schedPolicy.go +++ b/schedulers/schedPolicy.go @@ -92,7 +92,7 @@ func switchTaskDistBased(baseSchedRef *BaseScheduler) string { baseSchedRef.LogClsfnAndTaskDistOverhead(time.Now().Sub(startTime)) elektronLogging.ElektronLog.Log(elekLogT.GENERAL, log.InfoLevel, - log.Fields {"Task Distribution" : fmt.Sprintf("%s",taskDist)}, "Switching... ") + log.Fields {"Task Distribution" : fmt.Sprintf("%f",taskDist)}, "Switching... ") if err != nil { // All the tasks in the window were only classified into 1 cluster. // Max-Min and Max-GreedyMins would work the same way as Bin-Packing for this situation. -- 2.47.2 From 4d15e59d4cc8b14448c10aa88320a0d8bab11d50 Mon Sep 17 00:00:00 2001 From: balandi1 Date: Wed, 20 Nov 2019 13:33:46 -0500 Subject: [PATCH 07/48] Code formatting --- constants/constants.go | 10 +- def/metric.go | 10 +- def/sortingCriteria.go | 10 +- def/task.go | 10 +- def/taskUtils.go | 22 +-- elektronLogging/ElektronFormatter.go | 47 +++--- .../clsfnTaskDistOverheadLogger.go | 18 +- elektronLogging/consoleLogger.go | 8 +- elektronLogging/createLogDir.go | 2 +- elektronLogging/logger.go | 28 ++-- elektronLogging/loggerChain.go | 8 +- elektronLogging/loggerConfig.go | 82 ++++----- elektronLogging/pcpLogger.go | 14 +- elektronLogging/schedPolicySwitchLogger.go | 14 +- elektronLogging/schedTraceLogger.go | 16 +- elektronLogging/schedWindowLogger.go | 12 +- elektronLogging/types/types.go | 22 ++- environment/env.go | 10 +- pcp/pcp.go | 38 ++--- pcp/utils.go | 10 +- pcp/victim.go | 10 +- powerCap/extrema.go | 90 +++++----- powerCap/progressiveExtrema.go | 156 +++++++++--------- rapl/cap.go | 10 +- scheduler.go | 12 +- schedulers/MaxGreedyMins.go | 10 +- schedulers/MaxMin.go | 10 +- schedulers/base.go | 92 +++++------ schedulers/bin-packing.go | 10 +- schedulers/electronScheduler.go | 10 +- schedulers/first-fit.go | 10 +- schedulers/helpers.go | 12 +- schedulers/schedPolicy.go | 14 +- schedulers/states.go | 10 +- schedulers/store.go | 10 +- utilities/mesosUtils/mesosUtils.go | 10 +- utilities/offerUtils/offerUtils.go | 26 +-- utilities/runAvg/runAvg.go | 10 +- utilities/schedUtils/schedUtils.go | 24 +-- utilities/trackResourceUsage.go | 10 +- utilities/utils.go | 10 +- 41 files changed, 472 insertions(+), 475 deletions(-) diff --git a/constants/constants.go b/constants/constants.go index 6eb7f11..fb85d21 100644 --- a/constants/constants.go +++ b/constants/constants.go @@ -1,20 +1,20 @@ // Copyright (C) 2018 spdfg -// +// // This file is part of Elektron. -// +// // Elektron is free software: you can redistribute it and/or modify // it under the terms of the GNU General Public License as published by // the Free Software Foundation, either version 3 of the License, or // any later version. -// +// // Elektron is distributed in the hope that it will be useful, // but WITHOUT ANY WARRANTY; without even the implied warranty of // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the // GNU General Public License for more details. -// +// // You should have received a copy of the GNU General Public License // along with Elektron. If not, see . -// +// // TODO: Clean this up and use Mesos Attributes instead. package constants diff --git a/def/metric.go b/def/metric.go index e0c61c1..2bde309 100644 --- a/def/metric.go +++ b/def/metric.go @@ -1,20 +1,20 @@ // Copyright (C) 2018 spdfg -// +// // This file is part of Elektron. -// +// // Elektron is free software: you can redistribute it and/or modify // it under the terms of the GNU General Public License as published by // the Free Software Foundation, either version 3 of the License, or // (at your option) any later version. -// +// // Elektron is distributed in the hope that it will be useful, // but WITHOUT ANY WARRANTY; without even the implied warranty of // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the // GNU General Public License for more details. -// +// // You should have received a copy of the GNU General Public License // along with Elektron. If not, see . -// +// package def diff --git a/def/sortingCriteria.go b/def/sortingCriteria.go index 60e9ac6..427b912 100644 --- a/def/sortingCriteria.go +++ b/def/sortingCriteria.go @@ -1,20 +1,20 @@ // Copyright (C) 2018 spdfg -// +// // This file is part of Elektron. -// +// // Elektron is free software: you can redistribute it and/or modify // it under the terms of the GNU General Public License as published by // the Free Software Foundation, either version 3 of the License, or // (at your option) any later version. -// +// // Elektron is distributed in the hope that it will be useful, // but WITHOUT ANY WARRANTY; without even the implied warranty of // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the // GNU General Public License for more details. -// +// // You should have received a copy of the GNU General Public License // along with Elektron. If not, see . -// +// package def diff --git a/def/task.go b/def/task.go index 015171e..af579d9 100644 --- a/def/task.go +++ b/def/task.go @@ -1,20 +1,20 @@ // Copyright (C) 2018 spdfg -// +// // This file is part of Elektron. -// +// // Elektron is free software: you can redistribute it and/or modify // it under the terms of the GNU General Public License as published by // the Free Software Foundation, either version 3 of the License, or // (at your option) any later version. -// +// // Elektron is distributed in the hope that it will be useful, // but WITHOUT ANY WARRANTY; without even the implied warranty of // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the // GNU General Public License for more details. -// +// // You should have received a copy of the GNU General Public License // along with Elektron. If not, see . -// +// package def diff --git a/def/taskUtils.go b/def/taskUtils.go index ba019e2..734814a 100644 --- a/def/taskUtils.go +++ b/def/taskUtils.go @@ -1,20 +1,20 @@ // Copyright (C) 2018 spdfg -// +// // This file is part of Elektron. -// +// // Elektron is free software: you can redistribute it and/or modify // it under the terms of the GNU General Public License as published by // the Free Software Foundation, either version 3 of the License, or // (at your option) any later version. -// +// // Elektron is distributed in the hope that it will be useful, // but WITHOUT ANY WARRANTY; without even the implied warranty of // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the // GNU General Public License for more details. -// +// // You should have received a copy of the GNU General Public License // along with Elektron. If not, see . -// +// package def @@ -25,9 +25,9 @@ import ( "github.com/mash/gokmeans" "github.com/montanaflynn/stats" - "github.com/spdfg/elektron/elektronLogging" + log "github.com/sirupsen/logrus" + "github.com/spdfg/elektron/elektronLogging" elekLogT "github.com/spdfg/elektron/elektronLogging/types" - log "github.com/sirupsen/logrus" ) // Information about a cluster of tasks. @@ -52,8 +52,8 @@ func (tc TasksToClassify) taskObservationCalculator(task Task) []float64 { } else if task.Watts != 0.0 { return []float64{task.Watts} } else { - elektronLogging.ElektronLog.Log(elekLogT.ERROR, log.FatalLevel, - log.Fields {}, "Unable to classify tasks. Missing Watts or ClassToWatts attribute in workload") + elektronLogging.ElektronLog.Log(elekLogT.ERROR, log.FatalLevel, + log.Fields{}, "Unable to classify tasks. Missing Watts or ClassToWatts attribute in workload") return []float64{0.0} // Won't reach here. } } @@ -108,8 +108,8 @@ func clusterSizeAvgMMMPU(tasks []Task, taskObservation func(task Task) []float64 } else { // skip this value // there is an error in the task config. - elektronLogging.ElektronLog.Log(elekLogT.ERROR, log.ErrorLevel, - log.Fields {}, fmt.Sprintf("%s",err)) + elektronLogging.ElektronLog.Log(elekLogT.ERROR, log.ErrorLevel, + log.Fields{}, fmt.Sprintf("%s", err)) } } else { // There is only one observation for the task. diff --git a/elektronLogging/ElektronFormatter.go b/elektronLogging/ElektronFormatter.go index 0293510..265d73b 100644 --- a/elektronLogging/ElektronFormatter.go +++ b/elektronLogging/ElektronFormatter.go @@ -3,9 +3,9 @@ package elektronLogging import ( "bytes" "fmt" + "github.com/fatih/color" + log "github.com/sirupsen/logrus" "strings" - "github.com/fatih/color" - log "github.com/sirupsen/logrus" ) type ElektronFormatter struct { @@ -13,18 +13,18 @@ type ElektronFormatter struct { } func (f ElektronFormatter) getColor(entry *log.Entry) *color.Color { - switch entry.Level { - case log.InfoLevel: - return color.New(color.FgGreen, color.Bold) - case log.WarnLevel: - return color.New(color.FgYellow, color.Bold) - case log.ErrorLevel: - return color.New(color.FgRed, color.Bold) - case log.FatalLevel: - return color.New(color.FgRed, color.Bold) - default: - return color.New(color.FgWhite, color.Bold) - } + switch entry.Level { + case log.InfoLevel: + return color.New(color.FgGreen, color.Bold) + case log.WarnLevel: + return color.New(color.FgYellow, color.Bold) + case log.ErrorLevel: + return color.New(color.FgRed, color.Bold) + case log.FatalLevel: + return color.New(color.FgRed, color.Bold) + default: + return color.New(color.FgWhite, color.Bold) + } } func (f ElektronFormatter) Format(entry *log.Entry) ([]byte, error) { var b *bytes.Buffer @@ -35,19 +35,18 @@ func (f ElektronFormatter) Format(entry *log.Entry) ([]byte, error) { b = &bytes.Buffer{} } - levelColor := f.getColor(entry) - level := levelColor.Sprintf("[%s]:",strings.ToUpper(entry.Level.String())) - message := fmt.Sprintf("%s %s ",level,entry.Time.Format(f.TimestampFormat)) - if entry.Message != "" { - message = fmt.Sprintf("%s %s %s ",level,entry.Time.Format(f.TimestampFormat), entry.Message) - } + levelColor := f.getColor(entry) + level := levelColor.Sprintf("[%s]:", strings.ToUpper(entry.Level.String())) + message := fmt.Sprintf("%s %s ", level, entry.Time.Format(f.TimestampFormat)) + if entry.Message != "" { + message = fmt.Sprintf("%s %s %s ", level, entry.Time.Format(f.TimestampFormat), entry.Message) + } var formattedFields []string for key, value := range entry.Data { - formattedFields = append(formattedFields, - strings.Join([]string{key, fmt.Sprintf("%s", value)}, "=")) + formattedFields = append(formattedFields, + strings.Join([]string{key, fmt.Sprintf("%s", value)}, "=")) } - - + b.WriteString(message) b.WriteString(strings.Join(formattedFields, ", ")) b.WriteByte('\n') diff --git a/elektronLogging/clsfnTaskDistOverheadLogger.go b/elektronLogging/clsfnTaskDistOverheadLogger.go index c4a5e70..749c776 100644 --- a/elektronLogging/clsfnTaskDistOverheadLogger.go +++ b/elektronLogging/clsfnTaskDistOverheadLogger.go @@ -1,8 +1,8 @@ package elektronLogging import ( - "os" log "github.com/sirupsen/logrus" + "os" ) type ClsfnTaskDistOverheadLogger struct { @@ -16,16 +16,16 @@ func NewClsfnTaskDistOverheadLogger(logType int, prefix string) *ClsfnTaskDistOv return cLog } -func (cLog *ClsfnTaskDistOverheadLogger) Log(logType int, level log.Level, logData log.Fields,message string) { +func (cLog *ClsfnTaskDistOverheadLogger) Log(logType int, level log.Level, logData log.Fields, message string) { if cLog.Type == logType { logger.SetLevel(level) - - if cLog.AllowOnConsole { - logger.SetOutput(os.Stdout) - logger.WithFields(logData).Println(message) - } - + + if cLog.AllowOnConsole { + logger.SetOutput(os.Stdout) + logger.WithFields(logData).Println(message) + } + logger.SetOutput(cLog.LogFileName) logger.WithFields(logData).Println(message) } @@ -44,6 +44,6 @@ func (cLog *ClsfnTaskDistOverheadLogger) SetLogFile(prefix string) { log.Fatal("Unable to create logFile: ", err) } else { cLog.LogFileName = logFile - cLog.AllowOnConsole = config.TaskDistConfig.AllowOnConsole + cLog.AllowOnConsole = config.TaskDistConfig.AllowOnConsole } } diff --git a/elektronLogging/consoleLogger.go b/elektronLogging/consoleLogger.go index 36feb15..0801295 100644 --- a/elektronLogging/consoleLogger.go +++ b/elektronLogging/consoleLogger.go @@ -1,8 +1,8 @@ package elektronLogging import ( - "os" log "github.com/sirupsen/logrus" + "os" ) type ConsoleLogger struct { @@ -20,10 +20,10 @@ func (cLog *ConsoleLogger) Log(logType int, level log.Level, logData log.Fields, //logFields := cloneFields(logData) logger.SetLevel(level) - + logger.SetOutput(os.Stdout) logger.WithFields(logData).Println(message) - + logger.SetOutput(cLog.LogFileName) logger.WithFields(logData).Println(message) } @@ -42,6 +42,6 @@ func (cLog *ConsoleLogger) SetLogFile(prefix string) { log.Fatal("Unable to create logFile: ", err) } else { cLog.LogFileName = logFile - cLog.AllowOnConsole = true + cLog.AllowOnConsole = true } } diff --git a/elektronLogging/createLogDir.go b/elektronLogging/createLogDir.go index b365396..397a2a7 100644 --- a/elektronLogging/createLogDir.go +++ b/elektronLogging/createLogDir.go @@ -1,10 +1,10 @@ package elektronLogging import ( + logrus "github.com/sirupsen/logrus" "os" "strconv" "time" - logrus "github.com/sirupsen/logrus" ) var logDir string diff --git a/elektronLogging/logger.go b/elektronLogging/logger.go index 593f217..94e4b62 100644 --- a/elektronLogging/logger.go +++ b/elektronLogging/logger.go @@ -1,11 +1,11 @@ package elektronLogging import ( - "time" - "fmt" - "strconv" - . "github.com/spdfg/elektron/elektronLogging/types" + "fmt" log "github.com/sirupsen/logrus" + . "github.com/spdfg/elektron/elektronLogging/types" + "strconv" + "time" ) var config LoggerConfig @@ -14,25 +14,25 @@ var formatter ElektronFormatter func BuildLogger() *LoggerImpl { - // read configuration from yaml + // read configuration from yaml config.GetConfig() - - // create the log directory + + // create the log directory startTime := time.Now() formatter.TimestampFormat = "2006-01-02 15:04:05" GetLogDir(startTime, "_") - prefix := fmt.Sprintf("_%d%d%s%s%s%s",startTime.Year(), startTime.Month(),strconv.Itoa(startTime.Day()), - strconv.Itoa(startTime.Hour()),strconv.Itoa(startTime.Minute()),strconv.Itoa(startTime.Second())) - - //create a single logrus instance and set its formatter to ElektronFormatter + prefix := fmt.Sprintf("_%d%d%s%s%s%s", startTime.Year(), startTime.Month(), strconv.Itoa(startTime.Day()), + strconv.Itoa(startTime.Hour()), strconv.Itoa(startTime.Minute()), strconv.Itoa(startTime.Second())) + + //create a single logrus instance and set its formatter to ElektronFormatter logger = log.New() logger.SetFormatter(&formatter) - // create a chain of loggers + // create a chain of loggers head := new(LoggerImpl) - cLog := NewConsoleLogger(CONSOLE,prefix) - pLog := NewPcpLogger(PCP,prefix) + cLog := NewConsoleLogger(CONSOLE, prefix) + pLog := NewPcpLogger(PCP, prefix) schedTraceLog := NewSchedTraceLogger(SCHED_TRACE, prefix) spsLog := NewSchedPolicySwitchLogger(SPS, prefix) schedWindowLog := NewSchedWindowLogger(SCHED_WINDOW, prefix) diff --git a/elektronLogging/loggerChain.go b/elektronLogging/loggerChain.go index baac3d5..236f2fa 100644 --- a/elektronLogging/loggerChain.go +++ b/elektronLogging/loggerChain.go @@ -12,10 +12,10 @@ type Logger interface { SetLogFile(prefix string) } type LoggerImpl struct { - Type int - AllowOnConsole bool - LogFileName *os.File - next Logger + Type int + AllowOnConsole bool + LogFileName *os.File + next Logger } func (l *LoggerImpl) SetNext(logType Logger) { diff --git a/elektronLogging/loggerConfig.go b/elektronLogging/loggerConfig.go index cc9ece5..790669e 100644 --- a/elektronLogging/loggerConfig.go +++ b/elektronLogging/loggerConfig.go @@ -1,68 +1,68 @@ package elektronLogging + import ( - "gopkg.in/yaml.v2" - "io/ioutil" - log "github.com/sirupsen/logrus" - elekEnv "github.com/spdfg/elektron/environment" + log "github.com/sirupsen/logrus" + elekEnv "github.com/spdfg/elektron/environment" + "gopkg.in/yaml.v2" + "io/ioutil" ) type LoggerConfig struct { - SchedTraceConfig struct { - Enabled bool `yaml:"enabled"` - FilenameExtension string `yaml:"filenameExtension"` - EnableColumnHeaders bool `yaml:"enableColumnHeaders"` - AllowOnConsole bool `yaml:"allowOnConsole"` + Enabled bool `yaml:"enabled"` + FilenameExtension string `yaml:"filenameExtension"` + EnableColumnHeaders bool `yaml:"enableColumnHeaders"` + AllowOnConsole bool `yaml:"allowOnConsole"` } `yaml:"schedTrace"` PCPConfig struct { - Enabled bool `yaml:"enabled"` - FilenameExtension string `yaml:"filenameExtension"` - EnableColumnHeaders bool `yaml:"enableColumnHeaders"` - AllowOnConsole bool `yaml:"allowOnConsole"` + Enabled bool `yaml:"enabled"` + FilenameExtension string `yaml:"filenameExtension"` + EnableColumnHeaders bool `yaml:"enableColumnHeaders"` + AllowOnConsole bool `yaml:"allowOnConsole"` } `yaml:"pcp"` ConsoleConfig struct { - Enabled bool `yaml:"enabled"` - FilenameExtension string `yaml:"filenameExtension"` - EnableColumnHeaders bool `yaml:"enableColumnHeaders"` - MinLogLevel string `yaml:"minLogLevel"` + Enabled bool `yaml:"enabled"` + FilenameExtension string `yaml:"filenameExtension"` + EnableColumnHeaders bool `yaml:"enableColumnHeaders"` + MinLogLevel string `yaml:"minLogLevel"` } `yaml:"console"` SPSConfig struct { - Enabled bool `yaml:"enabled"` - FilenameExtension string `yaml:"filenameExtension"` - EnableColumnHeaders bool `yaml:"enableColumnHeaders"` - AllowOnConsole bool `yaml:"allowOnConsole"` + Enabled bool `yaml:"enabled"` + FilenameExtension string `yaml:"filenameExtension"` + EnableColumnHeaders bool `yaml:"enableColumnHeaders"` + AllowOnConsole bool `yaml:"allowOnConsole"` } `yaml:"sps"` TaskDistConfig struct { - Enabled bool `yaml:"enabled"` - FilenameExtension string `yaml:"filenameExtension"` - EnableColumnHeaders bool `yaml:"enableColumnHeaders"` - AllowOnConsole bool `yaml:"allowOnConsole"` + Enabled bool `yaml:"enabled"` + FilenameExtension string `yaml:"filenameExtension"` + EnableColumnHeaders bool `yaml:"enableColumnHeaders"` + AllowOnConsole bool `yaml:"allowOnConsole"` } `yaml:"clsfnTaskDistOverhead"` - + SchedWindowConfig struct { - Enabled bool `yaml:"enabled"` - FilenameExtension string `yaml:"filenameExtension"` - EnableColumnHeaders bool `yaml:"enableColumnHeaders"` - AllowOnConsole bool `yaml:"allowOnConsole"` + Enabled bool `yaml:"enabled"` + FilenameExtension string `yaml:"filenameExtension"` + EnableColumnHeaders bool `yaml:"enableColumnHeaders"` + AllowOnConsole bool `yaml:"allowOnConsole"` } `yaml:"schedWindow"` - - Format[] string `yaml:"format"` + + Format []string `yaml:"format"` } func (c *LoggerConfig) GetConfig() *LoggerConfig { - yamlFile, err := ioutil.ReadFile(elekEnv.LogConfigYaml) - if err != nil { - log.Printf("yamlFile.Get err #%v ", err) - } - err = yaml.Unmarshal(yamlFile, c) - if err != nil { - log.Fatalf("Unmarshal: %v", err) - } + yamlFile, err := ioutil.ReadFile(elekEnv.LogConfigYaml) + if err != nil { + log.Printf("yamlFile.Get err #%v ", err) + } + err = yaml.Unmarshal(yamlFile, c) + if err != nil { + log.Fatalf("Unmarshal: %v", err) + } - return c + return c } diff --git a/elektronLogging/pcpLogger.go b/elektronLogging/pcpLogger.go index 3d7c720..4969054 100644 --- a/elektronLogging/pcpLogger.go +++ b/elektronLogging/pcpLogger.go @@ -1,8 +1,8 @@ package elektronLogging import ( - "os" log "github.com/sirupsen/logrus" + "os" ) type PcpLogger struct { @@ -20,11 +20,11 @@ func (pLog *PcpLogger) Log(logType int, level log.Level, logData log.Fields, mes if pLog.Type == logType { logger.SetLevel(level) - - if pLog.AllowOnConsole { - logger.SetOutput(os.Stdout) - logger.WithFields(logData).Println(message) - } + + if pLog.AllowOnConsole { + logger.SetOutput(os.Stdout) + logger.WithFields(logData).Println(message) + } logger.SetOutput(pLog.LogFileName) logger.WithFields(logData).Println(message) @@ -44,6 +44,6 @@ func (plog *PcpLogger) SetLogFile(prefix string) { log.Fatal("Unable to create logFile: ", err) } else { plog.LogFileName = logFile - plog.AllowOnConsole = config.PCPConfig.AllowOnConsole + plog.AllowOnConsole = config.PCPConfig.AllowOnConsole } } diff --git a/elektronLogging/schedPolicySwitchLogger.go b/elektronLogging/schedPolicySwitchLogger.go index 270b5f8..d2d41a0 100644 --- a/elektronLogging/schedPolicySwitchLogger.go +++ b/elektronLogging/schedPolicySwitchLogger.go @@ -1,8 +1,8 @@ package elektronLogging import ( - "os" log "github.com/sirupsen/logrus" + "os" ) type SchedPolicySwitchLogger struct { @@ -20,11 +20,11 @@ func (sLog *SchedPolicySwitchLogger) Log(logType int, level log.Level, logData l if sLog.Type == logType { logger.SetLevel(level) - - if sLog.AllowOnConsole { - logger.SetOutput(os.Stdout) - logger.WithFields(logData).Println(message) - } + + if sLog.AllowOnConsole { + logger.SetOutput(os.Stdout) + logger.WithFields(logData).Println(message) + } logger.SetOutput(sLog.LogFileName) logger.WithFields(logData).Println(message) @@ -44,6 +44,6 @@ func (sLog *SchedPolicySwitchLogger) SetLogFile(prefix string) { log.Fatal("Unable to create logFile: ", err) } else { sLog.LogFileName = logFile - sLog.AllowOnConsole = config.SPSConfig.AllowOnConsole + sLog.AllowOnConsole = config.SPSConfig.AllowOnConsole } } diff --git a/elektronLogging/schedTraceLogger.go b/elektronLogging/schedTraceLogger.go index 0aade97..238c8e6 100644 --- a/elektronLogging/schedTraceLogger.go +++ b/elektronLogging/schedTraceLogger.go @@ -1,8 +1,8 @@ package elektronLogging import ( - "os" log "github.com/sirupsen/logrus" + "os" ) type SchedTraceLogger struct { @@ -20,12 +20,12 @@ func (sLog *SchedTraceLogger) Log(logType int, level log.Level, logData log.Fiel if sLog.Type == logType { logger.SetLevel(level) - - if sLog.AllowOnConsole { - logger.SetOutput(os.Stdout) - logger.WithFields(logData).Println(message) - } - + + if sLog.AllowOnConsole { + logger.SetOutput(os.Stdout) + logger.WithFields(logData).Println(message) + } + logger.SetOutput(sLog.LogFileName) logger.WithFields(logData).Println(message) } @@ -44,6 +44,6 @@ func (sLog *SchedTraceLogger) SetLogFile(prefix string) { log.Fatal("Unable to create logFile: ", err) } else { sLog.LogFileName = logFile - sLog.AllowOnConsole = config.SchedTraceConfig.AllowOnConsole + sLog.AllowOnConsole = config.SchedTraceConfig.AllowOnConsole } } diff --git a/elektronLogging/schedWindowLogger.go b/elektronLogging/schedWindowLogger.go index 8640883..9439698 100644 --- a/elektronLogging/schedWindowLogger.go +++ b/elektronLogging/schedWindowLogger.go @@ -1,8 +1,8 @@ package elektronLogging import ( - "os" log "github.com/sirupsen/logrus" + "os" ) type SchedWindowLogger struct { @@ -21,10 +21,10 @@ func (sLog *SchedWindowLogger) Log(logType int, level log.Level, logData log.Fie logger.SetLevel(level) if sLog.AllowOnConsole { - logger.SetOutput(os.Stdout) - logger.WithFields(logData).Println(message) - } - + logger.SetOutput(os.Stdout) + logger.WithFields(logData).Println(message) + } + logger.SetOutput(sLog.LogFileName) logger.WithFields(logData).Println(message) } @@ -43,6 +43,6 @@ func (sLog *SchedWindowLogger) SetLogFile(prefix string) { log.Fatal("Unable to create logFile: ", err) } else { sLog.LogFileName = logFile - sLog.AllowOnConsole = config.SchedWindowConfig.AllowOnConsole + sLog.AllowOnConsole = config.SchedWindowConfig.AllowOnConsole } } diff --git a/elektronLogging/types/types.go b/elektronLogging/types/types.go index e8288c1..0dd7fec 100644 --- a/elektronLogging/types/types.go +++ b/elektronLogging/types/types.go @@ -1,16 +1,14 @@ package elektronLogging - const ( - ERROR = iota - WARNING = iota - GENERAL = iota - SUCCESS = iota - CONSOLE = iota - PCP = iota - SCHED_TRACE = iota - SPS = iota - SCHED_WINDOW = iota - CLSFN_TASKDIST_OVERHEAD = iota + ERROR = iota + WARNING = iota + GENERAL = iota + SUCCESS = iota + CONSOLE = iota + PCP = iota + SCHED_TRACE = iota + SPS = iota + SCHED_WINDOW = iota + CLSFN_TASKDIST_OVERHEAD = iota ) - diff --git a/environment/env.go b/environment/env.go index d7c465d..c1abed1 100644 --- a/environment/env.go +++ b/environment/env.go @@ -1,20 +1,20 @@ // Copyright (C) 2018 spdfg -// +// // This file is part of Elektron. -// +// // Elektron is free software: you can redistribute it and/or modify // it under the terms of the GNU General Public License as published by // the Free Software Foundation, either version 3 of the License, or // (at your option) any later version. -// +// // Elektron is distributed in the hope that it will be useful, // but WITHOUT ANY WARRANTY; without even the implied warranty of // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the // GNU General Public License for more details. -// +// // You should have received a copy of the GNU General Public License // along with Elektron. If not, see . -// +// package environment diff --git a/pcp/pcp.go b/pcp/pcp.go index 928d5a3..f1ff505 100644 --- a/pcp/pcp.go +++ b/pcp/pcp.go @@ -1,20 +1,20 @@ // Copyright (C) 2018 spdfg -// +// // This file is part of Elektron. -// +// // Elektron is free software: you can redistribute it and/or modify // it under the terms of the GNU General Public License as published by // the Free Software Foundation, either version 3 of the License, or // (at your option) any later version. -// +// // Elektron is distributed in the hope that it will be useful, // but WITHOUT ANY WARRANTY; without even the implied warranty of // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the // GNU General Public License for more details. -// +// // You should have received a copy of the GNU General Public License // along with Elektron. If not, see . -// +// package pcp @@ -24,12 +24,12 @@ import ( "syscall" "time" - "github.com/spdfg/elektron/elektronLogging" + log "github.com/sirupsen/logrus" + "github.com/spdfg/elektron/elektronLogging" elekLogT "github.com/spdfg/elektron/elektronLogging/types" - log "github.com/sirupsen/logrus" ) -func Start(quit chan struct{}, logging *bool,pcpConfigFile string) { +func Start(quit chan struct{}, logging *bool, pcpConfigFile string) { var pcpCommand string = "pmdumptext -m -l -f '' -t 1.0 -d , -c " + pcpConfigFile cmd := exec.Command("sh", "-c", pcpCommand) cmd.SysProcAttr = &syscall.SysProcAttr{Setpgid: true} @@ -47,9 +47,9 @@ func Start(quit chan struct{}, logging *bool,pcpConfigFile string) { scanner.Scan() // Write to logfile - elektronLogging.ElektronLog.Log(elekLogT.PCP, - log.InfoLevel, - log.Fields {}, scanner.Text()) + elektronLogging.ElektronLog.Log(elekLogT.PCP, + log.InfoLevel, + log.Fields{}, scanner.Text()) // Throw away first set of results scanner.Scan() @@ -60,18 +60,18 @@ func Start(quit chan struct{}, logging *bool,pcpConfigFile string) { text := scanner.Text() if *logging { - elektronLogging.ElektronLog.Log(elekLogT.PCP, - log.InfoLevel, - log.Fields {}, text) + elektronLogging.ElektronLog.Log(elekLogT.PCP, + log.InfoLevel, + log.Fields{}, text) } seconds++ } }(logging) - elektronLogging.ElektronLog.Log(elekLogT.GENERAL, + elektronLogging.ElektronLog.Log(elekLogT.GENERAL, log.InfoLevel, - log.Fields {}, "PCP logging started") + log.Fields{}, "PCP logging started") if err := cmd.Start(); err != nil { log.Fatal(err) @@ -81,9 +81,9 @@ func Start(quit chan struct{}, logging *bool,pcpConfigFile string) { select { case <-quit: - elektronLogging.ElektronLog.Log(elekLogT.GENERAL, - log.InfoLevel, - log.Fields {}, "Stopping PCP logging in 5 seconds") + elektronLogging.ElektronLog.Log(elekLogT.GENERAL, + log.InfoLevel, + log.Fields{}, "Stopping PCP logging in 5 seconds") time.Sleep(5 * time.Second) // http://stackoverflow.com/questions/22470193/why-wont-go-kill-a-child-process-correctly diff --git a/pcp/utils.go b/pcp/utils.go index 3db92b6..bb52027 100644 --- a/pcp/utils.go +++ b/pcp/utils.go @@ -1,20 +1,20 @@ // Copyright (C) 2018 spdfg -// +// // This file is part of Elektron. -// +// // Elektron is free software: you can redistribute it and/or modify // it under the terms of the GNU General Public License as published by // the Free Software Foundation, either version 3 of the License, or // (at your option) any later version. -// +// // Elektron is distributed in the hope that it will be useful, // but WITHOUT ANY WARRANTY; without even the implied warranty of // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the // GNU General Public License for more details. -// +// // You should have received a copy of the GNU General Public License // along with Elektron. If not, see . -// +// package pcp diff --git a/pcp/victim.go b/pcp/victim.go index e18ec48..a5f59fe 100644 --- a/pcp/victim.go +++ b/pcp/victim.go @@ -1,20 +1,20 @@ // Copyright (C) 2018 spdfg -// +// // This file is part of Elektron. -// +// // Elektron is free software: you can redistribute it and/or modify // it under the terms of the GNU General Public License as published by // the Free Software Foundation, either version 3 of the License, or // (at your option) any later version. -// +// // Elektron is distributed in the hope that it will be useful, // but WITHOUT ANY WARRANTY; without even the implied warranty of // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the // GNU General Public License for more details. -// +// // You should have received a copy of the GNU General Public License // along with Elektron. If not, see . -// +// package pcp diff --git a/powerCap/extrema.go b/powerCap/extrema.go index e3b683d..0978249 100644 --- a/powerCap/extrema.go +++ b/powerCap/extrema.go @@ -1,20 +1,20 @@ // Copyright (C) 2018 spdfg -// +// // This file is part of Elektron. -// +// // Elektron is free software: you can redistribute it and/or modify // it under the terms of the GNU General Public License as published by // the Free Software Foundation, either version 3 of the License, or // (at your option) any later version. -// +// // Elektron is distributed in the hope that it will be useful, // but WITHOUT ANY WARRANTY; without even the implied warranty of // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the // GNU General Public License for more details. -// +// // You should have received a copy of the GNU General Public License // along with Elektron. If not, see . -// +// package powerCap @@ -29,14 +29,14 @@ import ( "syscall" "time" + log "github.com/sirupsen/logrus" + "github.com/spdfg/elektron/elektronLogging" + elekLogT "github.com/spdfg/elektron/elektronLogging/types" "github.com/spdfg/elektron/pcp" "github.com/spdfg/elektron/rapl" - "github.com/spdfg/elektron/elektronLogging" - elekLogT "github.com/spdfg/elektron/elektronLogging/types" - log "github.com/sirupsen/logrus" ) -func StartPCPLogAndExtremaDynamicCap(quit chan struct{}, logging *bool, hiThreshold, loThreshold float64,pcpConfigFile string) { +func StartPCPLogAndExtremaDynamicCap(quit chan struct{}, logging *bool, hiThreshold, loThreshold float64, pcpConfigFile string) { var pcpCommand string = "pmdumptext -m -l -f '' -t 1.0 -d , -c " + pcpConfigFile cmd := exec.Command("sh", "-c", pcpCommand, pcpConfigFile) @@ -44,8 +44,8 @@ func StartPCPLogAndExtremaDynamicCap(quit chan struct{}, logging *bool, hiThresh if hiThreshold < loThreshold { elektronLogging.ElektronLog.Log(elekLogT.GENERAL, - log.InfoLevel, - log.Fields {}, "High threshold is lower than low threshold!") + log.InfoLevel, + log.Fields{}, "High threshold is lower than low threshold!") } pipe, err := cmd.StdoutPipe() @@ -61,9 +61,9 @@ func StartPCPLogAndExtremaDynamicCap(quit chan struct{}, logging *bool, hiThresh scanner.Scan() // Write to logfile - elektronLogging.ElektronLog.Log(elekLogT.PCP, - log.InfoLevel, - log.Fields {}, scanner.Text()) + elektronLogging.ElektronLog.Log(elekLogT.PCP, + log.InfoLevel, + log.Fields{}, scanner.Text()) headers := strings.Split(scanner.Text(), ",") @@ -98,17 +98,17 @@ func StartPCPLogAndExtremaDynamicCap(quit chan struct{}, logging *bool, hiThresh for scanner.Scan() { if *logging { - - elektronLogging.ElektronLog.Log(elekLogT.GENERAL, - log.InfoLevel, - log.Fields {}, "Logging PCP...") + + elektronLogging.ElektronLog.Log(elekLogT.GENERAL, + log.InfoLevel, + log.Fields{}, "Logging PCP...") text := scanner.Text() split := strings.Split(text, ",") - - elektronLogging.ElektronLog.Log(elekLogT.PCP, - log.InfoLevel, - log.Fields {}, text) + + elektronLogging.ElektronLog.Log(elekLogT.PCP, + log.InfoLevel, + log.Fields{}, text) totalPower := 0.0 for _, powerIndex := range powerIndexes { @@ -119,10 +119,10 @@ func StartPCPLogAndExtremaDynamicCap(quit chan struct{}, logging *bool, hiThresh powerHistories[host].Value = power powerHistories[host] = powerHistories[host].Next() - elektronLogging.ElektronLog.Log(elekLogT.GENERAL, - log.InfoLevel, - log.Fields {"Host" : fmt.Sprintf("%s",indexToHost[powerIndex]), "Power" : fmt.Sprintf("%f",(power * pcp.RAPLUnits))}, - "") + elektronLogging.ElektronLog.Log(elekLogT.GENERAL, + log.InfoLevel, + log.Fields{"Host": fmt.Sprintf("%s", indexToHost[powerIndex]), "Power": fmt.Sprintf("%f", (power * pcp.RAPLUnits))}, + "") totalPower += power } @@ -134,15 +134,15 @@ func StartPCPLogAndExtremaDynamicCap(quit chan struct{}, logging *bool, hiThresh clusterMean := pcp.AverageClusterPowerHistory(clusterPowerHist) elektronLogging.ElektronLog.Log(elekLogT.GENERAL, - log.InfoLevel, - log.Fields {"Total power" : fmt.Sprintf("%f %d",clusterPower,clusterPowerHist.Len()), - "Sec Avg" : fmt.Sprintf("%f",clusterMean)}, - "") + log.InfoLevel, + log.Fields{"Total power": fmt.Sprintf("%f %d", clusterPower, clusterPowerHist.Len()), + "Sec Avg": fmt.Sprintf("%f", clusterMean)}, + "") if clusterMean > hiThreshold { elektronLogging.ElektronLog.Log(elekLogT.GENERAL, - log.InfoLevel, - log.Fields {}, "Need to cap a node") + log.InfoLevel, + log.Fields{}, "Need to cap a node") // Create statics for all victims and choose one to cap victims := make([]pcp.Victim, 0, 8) @@ -164,13 +164,13 @@ func StartPCPLogAndExtremaDynamicCap(quit chan struct{}, logging *bool, hiThresh cappedHosts[victim.Host] = true orderCapped = append(orderCapped, victim.Host) elektronLogging.ElektronLog.Log(elekLogT.GENERAL, - log.InfoLevel, - log.Fields {"Capping Victim" : fmt.Sprintf("%s",victim.Host), - "Avg. Wattage" : fmt.Sprintf("%f", victim.Watts*pcp.RAPLUnits)}, "") + log.InfoLevel, + log.Fields{"Capping Victim": fmt.Sprintf("%s", victim.Host), + "Avg. Wattage": fmt.Sprintf("%f", victim.Watts*pcp.RAPLUnits)}, "") if err := rapl.Cap(victim.Host, "rapl", 50); err != nil { elektronLogging.ElektronLog.Log(elekLogT.ERROR, - log.ErrorLevel, - log.Fields {}, "Error capping host") + log.ErrorLevel, + log.Fields{}, "Error capping host") } break // Only cap one machine at at time. } @@ -185,12 +185,12 @@ func StartPCPLogAndExtremaDynamicCap(quit chan struct{}, logging *bool, hiThresh // User RAPL package to send uncap. log.Printf("Uncapping host %s", host) elektronLogging.ElektronLog.Log(elekLogT.GENERAL, - log.InfoLevel, - log.Fields {"Uncapped host" : host}, "") + log.InfoLevel, + log.Fields{"Uncapped host": host}, "") if err := rapl.Cap(host, "rapl", 100); err != nil { elektronLogging.ElektronLog.Log(elekLogT.ERROR, - log.ErrorLevel, - log.Fields {}, "Error capping host") + log.ErrorLevel, + log.Fields{}, "Error capping host") } } } @@ -201,8 +201,8 @@ func StartPCPLogAndExtremaDynamicCap(quit chan struct{}, logging *bool, hiThresh }(logging, hiThreshold, loThreshold) elektronLogging.ElektronLog.Log(elekLogT.GENERAL, - log.InfoLevel, - log.Fields {}, "PCP logging started") + log.InfoLevel, + log.Fields{}, "PCP logging started") if err := cmd.Start(); err != nil { log.Fatal(err) @@ -213,8 +213,8 @@ func StartPCPLogAndExtremaDynamicCap(quit chan struct{}, logging *bool, hiThresh select { case <-quit: elektronLogging.ElektronLog.Log(elekLogT.GENERAL, - log.InfoLevel, - log.Fields {}, "Stopping PCP logging in 5 seconds") + log.InfoLevel, + log.Fields{}, "Stopping PCP logging in 5 seconds") time.Sleep(5 * time.Second) // http://stackoverflow.com/questions/22470193/why-wont-go-kill-a-child-process-correctly diff --git a/powerCap/progressiveExtrema.go b/powerCap/progressiveExtrema.go index b7502ad..807449a 100644 --- a/powerCap/progressiveExtrema.go +++ b/powerCap/progressiveExtrema.go @@ -1,20 +1,20 @@ // Copyright (C) 2018 spdfg -// +// // This file is part of Elektron. -// +// // Elektron is free software: you can redistribute it and/or modify // it under the terms of the GNU General Public License as published by // the Free Software Foundation, either version 3 of the License, or // (at your option) any later version. -// +// // Elektron is distributed in the hope that it will be useful, // but WITHOUT ANY WARRANTY; without even the implied warranty of // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the // GNU General Public License for more details. -// +// // You should have received a copy of the GNU General Public License // along with Elektron. If not, see . -// +// package powerCap @@ -30,13 +30,13 @@ import ( "syscall" "time" + log "github.com/sirupsen/logrus" "github.com/spdfg/elektron/constants" + "github.com/spdfg/elektron/elektronLogging" + elekLogT "github.com/spdfg/elektron/elektronLogging/types" "github.com/spdfg/elektron/pcp" "github.com/spdfg/elektron/rapl" "github.com/spdfg/elektron/utilities" - "github.com/spdfg/elektron/elektronLogging" - elekLogT "github.com/spdfg/elektron/elektronLogging/types" - log "github.com/sirupsen/logrus" ) func round(num float64) int { @@ -49,7 +49,7 @@ func getNextCapValue(curCapValue float64, precision int) float64 { return float64(round(curCapValue*output)) / output } -func StartPCPLogAndProgressiveExtremaCap(quit chan struct{}, logging *bool, hiThreshold, loThreshold float64,pcpConfigFile string) { +func StartPCPLogAndProgressiveExtremaCap(quit chan struct{}, logging *bool, hiThreshold, loThreshold float64, pcpConfigFile string) { var pcpCommand string = "pmdumptext -m -l -f '' -t 1.0 -d , -c " + pcpConfigFile cmd := exec.Command("sh", "-c", pcpCommand, pcpConfigFile) @@ -57,8 +57,8 @@ func StartPCPLogAndProgressiveExtremaCap(quit chan struct{}, logging *bool, hiTh if hiThreshold < loThreshold { elektronLogging.ElektronLog.Log(elekLogT.GENERAL, - log.InfoLevel, - log.Fields {}, "High threshold is lower than low threshold!") + log.InfoLevel, + log.Fields{}, "High threshold is lower than low threshold!") } pipe, err := cmd.StdoutPipe() @@ -75,8 +75,8 @@ func StartPCPLogAndProgressiveExtremaCap(quit chan struct{}, logging *bool, hiTh // Write to logfile elektronLogging.ElektronLog.Log(elekLogT.PCP, - log.InfoLevel, - log.Fields {}, scanner.Text()) + log.InfoLevel, + log.Fields{}, scanner.Text()) headers := strings.Split(scanner.Text(), ",") @@ -116,14 +116,14 @@ func StartPCPLogAndProgressiveExtremaCap(quit chan struct{}, logging *bool, hiTh for scanner.Scan() { if *logging { elektronLogging.ElektronLog.Log(elekLogT.GENERAL, - log.InfoLevel, - log.Fields {}, "Logging PCP...") + log.InfoLevel, + log.Fields{}, "Logging PCP...") split := strings.Split(scanner.Text(), ",") text := scanner.Text() elektronLogging.ElektronLog.Log(elekLogT.PCP, - log.InfoLevel, - log.Fields {}, text) + log.InfoLevel, + log.Fields{}, text) totalPower := 0.0 for _, powerIndex := range powerIndexes { @@ -135,9 +135,9 @@ func StartPCPLogAndProgressiveExtremaCap(quit chan struct{}, logging *bool, hiTh powerHistories[host] = powerHistories[host].Next() elektronLogging.ElektronLog.Log(elekLogT.GENERAL, - log.InfoLevel, - log.Fields {"Host" : fmt.Sprintf("%s",indexToHost[powerIndex]), "Power" : fmt.Sprintf("%f",(power * pcp.RAPLUnits))}, - "") + log.InfoLevel, + log.Fields{"Host": fmt.Sprintf("%s", indexToHost[powerIndex]), "Power": fmt.Sprintf("%f", (power * pcp.RAPLUnits))}, + "") totalPower += power } clusterPower := totalPower * pcp.RAPLUnits @@ -148,23 +148,23 @@ func StartPCPLogAndProgressiveExtremaCap(quit chan struct{}, logging *bool, hiTh clusterMean := pcp.AverageClusterPowerHistory(clusterPowerHist) elektronLogging.ElektronLog.Log(elekLogT.GENERAL, - log.InfoLevel, - log.Fields {"Total power" : fmt.Sprintf("%f %d",clusterPower,clusterPowerHist.Len()), - "Sec Avg" : fmt.Sprintf("%f",clusterMean)}, - "") + log.InfoLevel, + log.Fields{"Total power": fmt.Sprintf("%f %d", clusterPower, clusterPowerHist.Len()), + "Sec Avg": fmt.Sprintf("%f", clusterMean)}, + "") if clusterMean >= hiThreshold { elektronLogging.ElektronLog.Log(elekLogT.GENERAL, - log.InfoLevel, - log.Fields {}, "Need to cap a node") - - elektronLogging.ElektronLog.Log(elekLogT.GENERAL, - log.InfoLevel, - log.Fields {"Cap values of capped victims" : fmt.Sprintf("%v",cappedVictims)}, "") - - elektronLogging.ElektronLog.Log(elekLogT.GENERAL, - log.InfoLevel, - log.Fields {"Cap values of victims to uncap" : fmt.Sprintf("%v",orderCappedVictims)}, "") + log.InfoLevel, + log.Fields{}, "Need to cap a node") + + elektronLogging.ElektronLog.Log(elekLogT.GENERAL, + log.InfoLevel, + log.Fields{"Cap values of capped victims": fmt.Sprintf("%v", cappedVictims)}, "") + + elektronLogging.ElektronLog.Log(elekLogT.GENERAL, + log.InfoLevel, + log.Fields{"Cap values of victims to uncap": fmt.Sprintf("%v", orderCappedVictims)}, "") // Create statics for all victims and choose one to cap victims := make([]pcp.Victim, 0, 8) @@ -191,15 +191,15 @@ func StartPCPLogAndProgressiveExtremaCap(quit chan struct{}, logging *bool, hiTh } // Need to cap this victim. if err := rapl.Cap(victims[i].Host, "rapl", 50.0); err != nil { - - elektronLogging.ElektronLog.Log(elekLogT.ERROR, - log.ErrorLevel, - log.Fields {"Error capping host" : fmt.Sprintf("%s",victims[i].Host)}, "") + + elektronLogging.ElektronLog.Log(elekLogT.ERROR, + log.ErrorLevel, + log.Fields{"Error capping host": fmt.Sprintf("%s", victims[i].Host)}, "") } else { - - elektronLogging.ElektronLog.Log(elekLogT.GENERAL, - log.InfoLevel, - log.Fields {}, fmt.Sprintf("Capped host[%s] at %f", victims[i].Host, 50.0)) + + elektronLogging.ElektronLog.Log(elekLogT.GENERAL, + log.InfoLevel, + log.Fields{}, fmt.Sprintf("Capped host[%s] at %f", victims[i].Host, 50.0)) // Keeping track of this victim and it's cap value cappedVictims[victims[i].Host] = 50.0 newVictimFound = true @@ -222,15 +222,15 @@ func StartPCPLogAndProgressiveExtremaCap(quit chan struct{}, logging *bool, hiTh if capValue > constants.LowerCapLimit { newCapValue := getNextCapValue(capValue, 2) if err := rapl.Cap(alreadyCappedHosts[i], "rapl", newCapValue); err != nil { - - elektronLogging.ElektronLog.Log(elekLogT.ERROR, - log.ErrorLevel, - log.Fields {"Error capping host" : fmt.Sprintf("%s",alreadyCappedHosts[i])}, "") + + elektronLogging.ElektronLog.Log(elekLogT.ERROR, + log.ErrorLevel, + log.Fields{"Error capping host": fmt.Sprintf("%s", alreadyCappedHosts[i])}, "") } else { // Successful cap - elektronLogging.ElektronLog.Log(elekLogT.GENERAL, - log.InfoLevel, - log.Fields {}, fmt.Sprintf("Capped host[%s] at %f", alreadyCappedHosts[i], newCapValue)) + elektronLogging.ElektronLog.Log(elekLogT.GENERAL, + log.InfoLevel, + log.Fields{}, fmt.Sprintf("Capped host[%s] at %f", alreadyCappedHosts[i], newCapValue)) // Checking whether this victim can be capped further if newCapValue <= constants.LowerCapLimit { // Deleting victim from cappedVictims. @@ -253,23 +253,23 @@ func StartPCPLogAndProgressiveExtremaCap(quit chan struct{}, logging *bool, hiTh } } if !canCapAlreadyCappedVictim { - elektronLogging.ElektronLog.Log(elekLogT.GENERAL, - log.InfoLevel, - log.Fields {}, "No Victim left to cap") + elektronLogging.ElektronLog.Log(elekLogT.GENERAL, + log.InfoLevel, + log.Fields{}, "No Victim left to cap") } } } else if clusterMean < loThreshold { - - elektronLogging.ElektronLog.Log(elekLogT.GENERAL, - log.InfoLevel, - log.Fields {}, "Need to uncap a node") - elektronLogging.ElektronLog.Log(elekLogT.GENERAL, - log.InfoLevel, - log.Fields {"Cap values of capped victims" : fmt.Sprintf("%v",cappedVictims)}, "") - elektronLogging.ElektronLog.Log(elekLogT.GENERAL, - log.InfoLevel, - log.Fields {"Cap values of victims to uncap" : fmt.Sprintf("%v",orderCappedVictims)}, "") + + elektronLogging.ElektronLog.Log(elekLogT.GENERAL, + log.InfoLevel, + log.Fields{}, "Need to uncap a node") + elektronLogging.ElektronLog.Log(elekLogT.GENERAL, + log.InfoLevel, + log.Fields{"Cap values of capped victims": fmt.Sprintf("%v", cappedVictims)}, "") + elektronLogging.ElektronLog.Log(elekLogT.GENERAL, + log.InfoLevel, + log.Fields{"Cap values of victims to uncap": fmt.Sprintf("%v", orderCappedVictims)}, "") if len(orderCapped) > 0 { // We pick the host that is capped the most to uncap. orderCappedToSort := utilities.GetPairList(orderCappedVictims) @@ -279,15 +279,15 @@ func StartPCPLogAndProgressiveExtremaCap(quit chan struct{}, logging *bool, hiTh // This is a floating point operation and might suffer from precision loss. newUncapValue := orderCappedVictims[hostToUncap] * 2.0 if err := rapl.Cap(hostToUncap, "rapl", newUncapValue); err != nil { - - elektronLogging.ElektronLog.Log(elekLogT.ERROR, - log.ErrorLevel, - log.Fields {"Error uncapping host" : fmt.Sprintf("%s",hostToUncap)}, "") + + elektronLogging.ElektronLog.Log(elekLogT.ERROR, + log.ErrorLevel, + log.Fields{"Error uncapping host": fmt.Sprintf("%s", hostToUncap)}, "") } else { // Successful uncap - elektronLogging.ElektronLog.Log(elekLogT.GENERAL, - log.InfoLevel, - log.Fields {}, fmt.Sprintf("Uncapped host[%s] to %f", hostToUncap, newUncapValue)) + elektronLogging.ElektronLog.Log(elekLogT.GENERAL, + log.InfoLevel, + log.Fields{}, fmt.Sprintf("Uncapped host[%s] to %f", hostToUncap, newUncapValue)) // Can we uncap this host further. If not, then we remove its entry from orderCapped if newUncapValue >= 100.0 { // can compare using == // Deleting entry from orderCapped @@ -308,9 +308,9 @@ func StartPCPLogAndProgressiveExtremaCap(quit chan struct{}, logging *bool, hiTh } } } else { - elektronLogging.ElektronLog.Log(elekLogT.GENERAL, - log.InfoLevel, - log.Fields {}, "No host staged for Uncapped") + elektronLogging.ElektronLog.Log(elekLogT.GENERAL, + log.InfoLevel, + log.Fields{}, "No host staged for Uncapped") } } } @@ -319,9 +319,9 @@ func StartPCPLogAndProgressiveExtremaCap(quit chan struct{}, logging *bool, hiTh }(logging, hiThreshold, loThreshold) - elektronLogging.ElektronLog.Log(elekLogT.GENERAL, - log.InfoLevel, - log.Fields {}, "PCP logging started") + elektronLogging.ElektronLog.Log(elekLogT.GENERAL, + log.InfoLevel, + log.Fields{}, "PCP logging started") if err := cmd.Start(); err != nil { log.Fatal(err) } @@ -330,9 +330,9 @@ func StartPCPLogAndProgressiveExtremaCap(quit chan struct{}, logging *bool, hiTh select { case <-quit: - elektronLogging.ElektronLog.Log(elekLogT.GENERAL, - log.InfoLevel, - log.Fields {}, "Stopping PCP logging in 5 seconds") + elektronLogging.ElektronLog.Log(elekLogT.GENERAL, + log.InfoLevel, + log.Fields{}, "Stopping PCP logging in 5 seconds") time.Sleep(5 * time.Second) // http://stackoverflow.com/questions/22470193/why-wont-go-kill-a-child-process-correctly diff --git a/rapl/cap.go b/rapl/cap.go index 2445045..42f94f6 100644 --- a/rapl/cap.go +++ b/rapl/cap.go @@ -1,20 +1,20 @@ // Copyright (C) 2018 spdfg -// +// // This file is part of Elektron. -// +// // Elektron is free software: you can redistribute it and/or modify // it under the terms of the GNU General Public License as published by // the Free Software Foundation, either version 3 of the License, or // (at your option) any later version. -// +// // Elektron is distributed in the hope that it will be useful, // but WITHOUT ANY WARRANTY; without even the implied warranty of // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the // GNU General Public License for more details. -// +// // You should have received a copy of the GNU General Public License // along with Elektron. If not, see . -// +// package rapl diff --git a/scheduler.go b/scheduler.go index 55b420e..63cd2f1 100644 --- a/scheduler.go +++ b/scheduler.go @@ -28,13 +28,13 @@ import ( "github.com/golang/protobuf/proto" mesos "github.com/mesos/mesos-go/api/v0/mesosproto" sched "github.com/mesos/mesos-go/api/v0/scheduler" + log "github.com/sirupsen/logrus" "github.com/spdfg/elektron/def" + "github.com/spdfg/elektron/elektronLogging" + elekLogT "github.com/spdfg/elektron/elektronLogging/types" "github.com/spdfg/elektron/pcp" "github.com/spdfg/elektron/powerCap" "github.com/spdfg/elektron/schedulers" - "github.com/spdfg/elektron/elektronLogging" - elekLogT "github.com/spdfg/elektron/elektronLogging/types" - log "github.com/sirupsen/logrus" ) var master = flag.String("master", "", "Location of leading Mesos master -- :") @@ -283,10 +283,10 @@ func main() { // Starting the scheduler driver. if status, err := driver.Run(); err != nil { elektronLogging.ElektronLog.Log(elekLogT.ERROR, - log.ErrorLevel, - log.Fields {"status" : status.String(), "error" : err.Error()}, "Framework stopped ") + log.ErrorLevel, + log.Fields{"status": status.String(), "error": err.Error()}, "Framework stopped ") } elektronLogging.ElektronLog.Log(elekLogT.GENERAL, log.InfoLevel, - log.Fields {}, "Exiting...") + log.Fields{}, "Exiting...") } diff --git a/schedulers/MaxGreedyMins.go b/schedulers/MaxGreedyMins.go index c555409..b4b250d 100644 --- a/schedulers/MaxGreedyMins.go +++ b/schedulers/MaxGreedyMins.go @@ -1,20 +1,20 @@ // Copyright (C) 2018 spdfg -// +// // This file is part of Elektron. -// +// // Elektron is free software: you can redistribute it and/or modify // it under the terms of the GNU General Public License as published by // the Free Software Foundation, either version 3 of the License, or // (at your option) any later version. -// +// // Elektron is distributed in the hope that it will be useful, // but WITHOUT ANY WARRANTY; without even the implied warranty of // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the // GNU General Public License for more details. -// +// // You should have received a copy of the GNU General Public License // along with Elektron. If not, see . -// +// package schedulers diff --git a/schedulers/MaxMin.go b/schedulers/MaxMin.go index ef8fb88..a7ba29e 100644 --- a/schedulers/MaxMin.go +++ b/schedulers/MaxMin.go @@ -1,20 +1,20 @@ // Copyright (C) 2018 spdfg -// +// // This file is part of Elektron. -// +// // Elektron is free software: you can redistribute it and/or modify // it under the terms of the GNU General Public License as published by // the Free Software Foundation, either version 3 of the License, or // (at your option) any later version. -// +// // Elektron is distributed in the hope that it will be useful, // but WITHOUT ANY WARRANTY; without even the implied warranty of // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the // GNU General Public License for more details. -// +// // You should have received a copy of the GNU General Public License // along with Elektron. If not, see . -// +// package schedulers diff --git a/schedulers/base.go b/schedulers/base.go index ba8a9a2..677ed81 100644 --- a/schedulers/base.go +++ b/schedulers/base.go @@ -1,20 +1,20 @@ // Copyright (C) 2018 spdfg -// +// // This file is part of Elektron. -// +// // Elektron is free software: you can redistribute it and/or modify // it under the terms of the GNU General Public License as published by // the Free Software Foundation, either version 3 of the License, or // (at your option) any later version. -// +// // Elektron is distributed in the hope that it will be useful, // but WITHOUT ANY WARRANTY; without even the implied warranty of // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the // GNU General Public License for more details. -// +// // You should have received a copy of the GNU General Public License // along with Elektron. If not, see . -// +// package schedulers @@ -28,12 +28,12 @@ import ( mesos "github.com/mesos/mesos-go/api/v0/mesosproto" "github.com/mesos/mesos-go/api/v0/mesosutil" sched "github.com/mesos/mesos-go/api/v0/scheduler" + log "github.com/sirupsen/logrus" "github.com/spdfg/elektron/def" + "github.com/spdfg/elektron/elektronLogging" + elekLogT "github.com/spdfg/elektron/elektronLogging/types" "github.com/spdfg/elektron/utilities" "github.com/spdfg/elektron/utilities/schedUtils" - "github.com/spdfg/elektron/elektronLogging" - elekLogT "github.com/spdfg/elektron/elektronLogging/types" - log "github.com/sirupsen/logrus" ) type BaseScheduler struct { @@ -251,14 +251,14 @@ func (s *BaseScheduler) StatusUpdate(driver sched.SchedulerDriver, status *mesos func (s *BaseScheduler) LogTaskStarting(ts *def.Task, offer *mesos.Offer) { lmt := elekLogT.GENERAL if ts == nil { - elektronLogging.ElektronLog.Log(lmt, log.InfoLevel, - log.Fields {"host" : fmt.Sprintf("%s",offer.GetHostname())}, "TASKS STARTING...") + elektronLogging.ElektronLog.Log(lmt, log.InfoLevel, + log.Fields{"host": fmt.Sprintf("%s", offer.GetHostname())}, "TASKS STARTING...") } else { elektronLogging.ElektronLog.Log(lmt, - log.InfoLevel, - log.Fields {"task" : fmt.Sprintf("%s",ts.Name), - "Instance" : fmt.Sprintf("%d",*ts.Instances), "host" : fmt.Sprintf("%s",offer.GetHostname())}, - "TASK STARTING... ") + log.InfoLevel, + log.Fields{"task": fmt.Sprintf("%s", ts.Name), + "Instance": fmt.Sprintf("%d", *ts.Instances), "host": fmt.Sprintf("%s", offer.GetHostname())}, + "TASK STARTING... ") } } @@ -266,28 +266,28 @@ func (s *BaseScheduler) LogTaskWattsConsideration(ts def.Task, host string, watt lmt := elekLogT.GENERAL elektronLogging.ElektronLog.Log(lmt, log.InfoLevel, - log.Fields {"task" : ts.Name, "host" : host, "Watts" : fmt.Sprintf("%f",wattsToConsider)}, "Watts considered for ") + log.Fields{"task": ts.Name, "host": host, "Watts": fmt.Sprintf("%f", wattsToConsider)}, "Watts considered for ") } func (s *BaseScheduler) LogOffersReceived(offers []*mesos.Offer) { lmt := elekLogT.GENERAL elektronLogging.ElektronLog.Log(lmt, log.InfoLevel, - log.Fields {"Resource offers received" : fmt.Sprintf("%d",len(offers))}, "") + log.Fields{"Resource offers received": fmt.Sprintf("%d", len(offers))}, "") } func (s *BaseScheduler) LogNoPendingTasksDeclineOffers(offer *mesos.Offer) { lmt := elekLogT.WARNING elektronLogging.ElektronLog.Log(lmt, log.WarnLevel, - log.Fields {"DECLINING OFFER for host" : fmt.Sprintf("%s",offer.GetHostname())}, "No tasks left to schedule ") + log.Fields{"DECLINING OFFER for host": fmt.Sprintf("%s", offer.GetHostname())}, "No tasks left to schedule ") } func (s *BaseScheduler) LogNumberOfRunningTasks() { lmt := elekLogT.GENERAL elektronLogging.ElektronLog.Log(lmt, log.InfoLevel, - log.Fields {"Number of tasks still Running" : fmt.Sprintf("%d",s.tasksRunning)}, "") + log.Fields{"Number of tasks still Running": fmt.Sprintf("%d", s.tasksRunning)}, "") } func (s *BaseScheduler) LogCoLocatedTasks(slaveID string) { @@ -300,20 +300,20 @@ func (s *BaseScheduler) LogCoLocatedTasks(slaveID string) { s.TasksRunningMutex.Unlock() elektronLogging.ElektronLog.Log(lmt, log.InfoLevel, - log.Fields {"Colocated with" : fmt.Sprintf("%s",buffer.String())}, "") + log.Fields{"Colocated with": fmt.Sprintf("%s", buffer.String())}, "") } func (s *BaseScheduler) LogSchedTrace(taskToSchedule *mesos.TaskInfo, offer *mesos.Offer) { elektronLogging.ElektronLog.Log(elekLogT.SCHED_TRACE, log.InfoLevel, - log.Fields {offer.GetHostname() : fmt.Sprintf("%s",taskToSchedule.GetTaskId().GetValue())}, "") + log.Fields{offer.GetHostname(): fmt.Sprintf("%s", taskToSchedule.GetTaskId().GetValue())}, "") } func (s *BaseScheduler) LogTerminateScheduler() { lmt := elekLogT.GENERAL elektronLogging.ElektronLog.Log(lmt, log.InfoLevel, - log.Fields {}, "Done scheduling all tasks!") + log.Fields{}, "Done scheduling all tasks!") } func (s *BaseScheduler) LogInsufficientResourcesDeclineOffer(offer *mesos.Offer, @@ -323,72 +323,72 @@ func (s *BaseScheduler) LogInsufficientResourcesDeclineOffer(offer *mesos.Offer, buffer.WriteString(fmt.Sprintf("", offerResources...)) elektronLogging.ElektronLog.Log(lmt, log.WarnLevel, - log.Fields {"Offer Resources" : fmt.Sprintf("%s",buffer.String())}, "DECLINING OFFER... Offer has insufficient resources to launch a task") + log.Fields{"Offer Resources": fmt.Sprintf("%s", buffer.String())}, "DECLINING OFFER... Offer has insufficient resources to launch a task") } func (s *BaseScheduler) LogOfferRescinded(offerID *mesos.OfferID) { lmt := elekLogT.ERROR elektronLogging.ElektronLog.Log(lmt, log.ErrorLevel, - log.Fields {"OfferID" : fmt.Sprintf("%s",offerID)}, "OFFER RESCINDED") + log.Fields{"OfferID": fmt.Sprintf("%s", offerID)}, "OFFER RESCINDED") } func (s *BaseScheduler) LogSlaveLost(slaveID *mesos.SlaveID) { lmt := elekLogT.ERROR elektronLogging.ElektronLog.Log(lmt, log.ErrorLevel, - log.Fields {"SlaveID" : fmt.Sprintf("%s",slaveID)}, "SLAVE LOST") + log.Fields{"SlaveID": fmt.Sprintf("%s", slaveID)}, "SLAVE LOST") } func (s *BaseScheduler) LogExecutorLost(executorID *mesos.ExecutorID, slaveID *mesos.SlaveID) { lmt := elekLogT.ERROR - elektronLogging.ElektronLog.Log(lmt, + elektronLogging.ElektronLog.Log(lmt, log.ErrorLevel, - log.Fields {"ExecutorID" : fmt.Sprintf("%s",executorID), "SlaveID" : fmt.Sprintf("%s", slaveID)}, "EXECUTOR LOST") + log.Fields{"ExecutorID": fmt.Sprintf("%s", executorID), "SlaveID": fmt.Sprintf("%s", slaveID)}, "EXECUTOR LOST") } func (s *BaseScheduler) LogFrameworkMessage(executorID *mesos.ExecutorID, slaveID *mesos.SlaveID, message string) { lmt := elekLogT.GENERAL - elektronLogging.ElektronLog.Log(lmt, + elektronLogging.ElektronLog.Log(lmt, log.InfoLevel, - log.Fields {"Received Framework message from executor" : executorID}, message) + log.Fields{"Received Framework message from executor": executorID}, message) } func (s *BaseScheduler) LogMesosError(err string) { lmt := elekLogT.ERROR - elektronLogging.ElektronLog.Log(lmt, + elektronLogging.ElektronLog.Log(lmt, log.ErrorLevel, - log.Fields {"MESOS ERROR" : fmt.Sprintf("%v", err)}, "") + log.Fields{"MESOS ERROR": fmt.Sprintf("%v", err)}, "") } func (s *BaseScheduler) LogElectronError(err error) { lmt := elekLogT.ERROR - elektronLogging.ElektronLog.Log(lmt, + elektronLogging.ElektronLog.Log(lmt, log.ErrorLevel, - log.Fields {"ELECTRON ERROR" : fmt.Sprintf("%v",err)}, "") + log.Fields{"ELECTRON ERROR": fmt.Sprintf("%v", err)}, "") } func (s *BaseScheduler) LogFrameworkRegistered(frameworkID *mesos.FrameworkID, masterInfo *mesos.MasterInfo) { lmt := elekLogT.SUCCESS - elektronLogging.ElektronLog.Log(lmt, + elektronLogging.ElektronLog.Log(lmt, log.InfoLevel, - log.Fields {"frameworkID" : fmt.Sprintf("%s",frameworkID), "master" : fmt.Sprintf("%s",masterInfo)}, "FRAMEWORK REGISTERED!") + log.Fields{"frameworkID": fmt.Sprintf("%s", frameworkID), "master": fmt.Sprintf("%s", masterInfo)}, "FRAMEWORK REGISTERED!") } func (s *BaseScheduler) LogFrameworkReregistered(masterInfo *mesos.MasterInfo) { lmt := elekLogT.GENERAL - elektronLogging.ElektronLog.Log(lmt, + elektronLogging.ElektronLog.Log(lmt, log.InfoLevel, - log.Fields {"master" : fmt.Sprintf("%s",masterInfo)}, "Framework re-registered") + log.Fields{"master": fmt.Sprintf("%s", masterInfo)}, "Framework re-registered") } func (s *BaseScheduler) LogDisconnected() { lmt := elekLogT.WARNING - elektronLogging.ElektronLog.Log(lmt, + elektronLogging.ElektronLog.Log(lmt, log.WarnLevel, - log.Fields {}, "Framework disconnected with master") + log.Fields{}, "Framework disconnected with master") } func (s *BaseScheduler) LogTaskStatusUpdate(status *mesos.TaskStatus) { @@ -402,16 +402,16 @@ func (s *BaseScheduler) LogTaskStatusUpdate(status *mesos.TaskStatus) { default: lmt = elekLogT.GENERAL } - elektronLogging.ElektronLog.Log(lmt, + elektronLogging.ElektronLog.Log(lmt, log.InfoLevel, - log.Fields {"task" : fmt.Sprintf("%s",*status.TaskId.Value), "state" : NameFor(status.State)}, "Task Status received") + log.Fields{"task": fmt.Sprintf("%s", *status.TaskId.Value), "state": NameFor(status.State)}, "Task Status received") } func (s *BaseScheduler) LogSchedPolicySwitch(name string, nextPolicy SchedPolicyState) { logSPS := func() { - elektronLogging.ElektronLog.Log(elekLogT.SPS, - log.InfoLevel, - log.Fields {"Name" : name}, "") + elektronLogging.ElektronLog.Log(elekLogT.SPS, + log.InfoLevel, + log.Fields{"Name": name}, "") } if s.hasReceivedResourceOffers && (s.curSchedPolicy != nextPolicy) { logSPS() @@ -420,14 +420,14 @@ func (s *BaseScheduler) LogSchedPolicySwitch(name string, nextPolicy SchedPolicy } // Logging the size of the scheduling window and the scheduling policy // that is going to schedule the tasks in the scheduling window. - elektronLogging.ElektronLog.Log(elekLogT.SCHED_WINDOW, + elektronLogging.ElektronLog.Log(elekLogT.SCHED_WINDOW, log.InfoLevel, - log.Fields {"Window size" : fmt.Sprintf("%d",s.schedWindowSize), "Name" : name}, "") + log.Fields{"Window size": fmt.Sprintf("%d", s.schedWindowSize), "Name": name}, "") } func (s *BaseScheduler) LogClsfnAndTaskDistOverhead(overhead time.Duration) { // Logging the overhead in microseconds. elektronLogging.ElektronLog.Log(elekLogT.CLSFN_TASKDIST_OVERHEAD, log.InfoLevel, - log.Fields {"Overhead in microseconds" : fmt.Sprintf("%f", float64(overhead.Nanoseconds())/1000.0)}, "") + log.Fields{"Overhead in microseconds": fmt.Sprintf("%f", float64(overhead.Nanoseconds())/1000.0)}, "") } diff --git a/schedulers/bin-packing.go b/schedulers/bin-packing.go index 894bcba..aba4fbb 100644 --- a/schedulers/bin-packing.go +++ b/schedulers/bin-packing.go @@ -1,20 +1,20 @@ // Copyright (C) 2018 spdfg -// +// // This file is part of Elektron. -// +// // Elektron is free software: you can redistribute it and/or modify // it under the terms of the GNU General Public License as published by // the Free Software Foundation, either version 3 of the License, or // (at your option) any later version. -// +// // Elektron is distributed in the hope that it will be useful, // but WITHOUT ANY WARRANTY; without even the implied warranty of // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the // GNU General Public License for more details. -// +// // You should have received a copy of the GNU General Public License // along with Elektron. If not, see . -// +// package schedulers diff --git a/schedulers/electronScheduler.go b/schedulers/electronScheduler.go index 6b7969f..21bb14a 100644 --- a/schedulers/electronScheduler.go +++ b/schedulers/electronScheduler.go @@ -1,20 +1,20 @@ // Copyright (C) 2018 spdfg -// +// // This file is part of Elektron. -// +// // Elektron is free software: you can redistribute it and/or modify // it under the terms of the GNU General Public License as published by // the Free Software Foundation, either version 3 of the License, or // (at your option) any later version. -// +// // Elektron is distributed in the hope that it will be useful, // but WITHOUT ANY WARRANTY; without even the implied warranty of // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the // GNU General Public License for more details. -// +// // You should have received a copy of the GNU General Public License // along with Elektron. If not, see . -// +// package schedulers diff --git a/schedulers/first-fit.go b/schedulers/first-fit.go index 121fc0f..2e1a9c3 100644 --- a/schedulers/first-fit.go +++ b/schedulers/first-fit.go @@ -1,20 +1,20 @@ // Copyright (C) 2018 spdfg -// +// // This file is part of Elektron. -// +// // Elektron is free software: you can redistribute it and/or modify // it under the terms of the GNU General Public License as published by // the Free Software Foundation, either version 3 of the License, or // (at your option) any later version. -// +// // Elektron is distributed in the hope that it will be useful, // but WITHOUT ANY WARRANTY; without even the implied warranty of // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the // GNU General Public License for more details. -// +// // You should have received a copy of the GNU General Public License // along with Elektron. If not, see . -// +// package schedulers diff --git a/schedulers/helpers.go b/schedulers/helpers.go index 439e740..59ada5d 100644 --- a/schedulers/helpers.go +++ b/schedulers/helpers.go @@ -23,26 +23,26 @@ import ( mesos "github.com/mesos/mesos-go/api/v0/mesosproto" sched "github.com/mesos/mesos-go/api/v0/scheduler" "github.com/pkg/errors" + log "github.com/sirupsen/logrus" "github.com/spdfg/elektron/constants" "github.com/spdfg/elektron/def" + "github.com/spdfg/elektron/elektronLogging" + elekLogT "github.com/spdfg/elektron/elektronLogging/types" "github.com/spdfg/elektron/utilities" "github.com/spdfg/elektron/utilities/mesosUtils" - log "github.com/sirupsen/logrus" - "github.com/spdfg/elektron/elektronLogging" - elekLogT "github.com/spdfg/elektron/elektronLogging/types" ) func coLocated(tasks map[string]bool, s BaseScheduler) { for task := range tasks { elektronLogging.ElektronLog.Log(elekLogT.GENERAL, - log.InfoLevel, - log.Fields {"Task" : task}, "") + log.InfoLevel, + log.Fields{"Task": task}, "") } elektronLogging.ElektronLog.Log(elekLogT.GENERAL, log.InfoLevel, - log.Fields {}, "---------------------") + log.Fields{}, "---------------------") } // Get the powerClass of the given hostname. diff --git a/schedulers/schedPolicy.go b/schedulers/schedPolicy.go index 1ae1b72..36521b3 100644 --- a/schedulers/schedPolicy.go +++ b/schedulers/schedPolicy.go @@ -1,20 +1,20 @@ // Copyright (C) 2018 spdfg -// +// // This file is part of Elektron. -// +// // Elektron is free software: you can redistribute it and/or modify // it under the terms of the GNU General Public License as published by // the Free Software Foundation, either version 3 of the License, or // (at your option) any later version. -// +// // Elektron is distributed in the hope that it will be useful, // but WITHOUT ANY WARRANTY; without even the implied warranty of // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the // GNU General Public License for more details. -// +// // You should have received a copy of the GNU General Public License // along with Elektron. If not, see . -// +// package schedulers @@ -24,10 +24,10 @@ import ( mesos "github.com/mesos/mesos-go/api/v0/mesosproto" sched "github.com/mesos/mesos-go/api/v0/scheduler" + log "github.com/sirupsen/logrus" "github.com/spdfg/elektron/def" "github.com/spdfg/elektron/elektronLogging" elekLogT "github.com/spdfg/elektron/elektronLogging/types" - log "github.com/sirupsen/logrus" ) type SchedPolicyContext interface { @@ -92,7 +92,7 @@ func switchTaskDistBased(baseSchedRef *BaseScheduler) string { baseSchedRef.LogClsfnAndTaskDistOverhead(time.Now().Sub(startTime)) elektronLogging.ElektronLog.Log(elekLogT.GENERAL, log.InfoLevel, - log.Fields {"Task Distribution" : fmt.Sprintf("%f",taskDist)}, "Switching... ") + log.Fields{"Task Distribution": fmt.Sprintf("%f", taskDist)}, "Switching... ") if err != nil { // All the tasks in the window were only classified into 1 cluster. // Max-Min and Max-GreedyMins would work the same way as Bin-Packing for this situation. diff --git a/schedulers/states.go b/schedulers/states.go index 30b41b2..d0bcfb7 100644 --- a/schedulers/states.go +++ b/schedulers/states.go @@ -1,20 +1,20 @@ // Copyright (C) 2018 spdfg -// +// // This file is part of Elektron. -// +// // Elektron is free software: you can redistribute it and/or modify // it under the terms of the GNU General Public License as published by // the Free Software Foundation, either version 3 of the License, or // (at your option) any later version. -// +// // Elektron is distributed in the hope that it will be useful, // but WITHOUT ANY WARRANTY; without even the implied warranty of // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the // GNU General Public License for more details. -// +// // You should have received a copy of the GNU General Public License // along with Elektron. If not, see . -// +// package schedulers diff --git a/schedulers/store.go b/schedulers/store.go index f2ef41f..f2191db 100644 --- a/schedulers/store.go +++ b/schedulers/store.go @@ -1,20 +1,20 @@ // Copyright (C) 2018 spdfg -// +// // This file is part of Elektron. -// +// // Elektron is free software: you can redistribute it and/or modify // it under the terms of the GNU General Public License as published by // the Free Software Foundation, either version 3 of the License, or // (at your option) any later version. -// +// // Elektron is distributed in the hope that it will be useful, // but WITHOUT ANY WARRANTY; without even the implied warranty of // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the // GNU General Public License for more details. -// +// // You should have received a copy of the GNU General Public License // along with Elektron. If not, see . -// +// package schedulers diff --git a/utilities/mesosUtils/mesosUtils.go b/utilities/mesosUtils/mesosUtils.go index 2778592..92fc046 100644 --- a/utilities/mesosUtils/mesosUtils.go +++ b/utilities/mesosUtils/mesosUtils.go @@ -1,20 +1,20 @@ // Copyright (C) 2018 spdfg -// +// // This file is part of Elektron. -// +// // Elektron is free software: you can redistribute it and/or modify // it under the terms of the GNU General Public License as published by // the Free Software Foundation, either version 3 of the License, or // (at your option) any later version. -// +// // Elektron is distributed in the hope that it will be useful, // but WITHOUT ANY WARRANTY; without even the implied warranty of // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the // GNU General Public License for more details. -// +// // You should have received a copy of the GNU General Public License // along with Elektron. If not, see . -// +// package mesosUtils diff --git a/utilities/offerUtils/offerUtils.go b/utilities/offerUtils/offerUtils.go index 7f05411..06a594c 100644 --- a/utilities/offerUtils/offerUtils.go +++ b/utilities/offerUtils/offerUtils.go @@ -1,31 +1,31 @@ // Copyright (C) 2018 spdfg -// +// // This file is part of Elektron. -// +// // Elektron is free software: you can redistribute it and/or modify // it under the terms of the GNU General Public License as published by // the Free Software Foundation, either version 3 of the License, or // (at your option) any later version. -// +// // Elektron is distributed in the hope that it will be useful, // but WITHOUT ANY WARRANTY; without even the implied warranty of // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the // GNU General Public License for more details. -// +// // You should have received a copy of the GNU General Public License // along with Elektron. If not, see . -// +// package offerUtils import ( - "strings" - "fmt" + "fmt" mesos "github.com/mesos/mesos-go/api/v0/mesosproto" + log "github.com/sirupsen/logrus" "github.com/spdfg/elektron/constants" - "github.com/spdfg/elektron/elektronLogging" + "github.com/spdfg/elektron/elektronLogging" elekLogT "github.com/spdfg/elektron/elektronLogging/types" - log "github.com/sirupsen/logrus" + "strings" ) func OfferAgg(offer *mesos.Offer) (float64, float64, float64) { @@ -90,14 +90,14 @@ func UpdateEnvironment(offer *mesos.Offer) { var host = offer.GetHostname() // If this host is not present in the set of hosts. if _, ok := constants.Hosts[host]; !ok { - elektronLogging.ElektronLog.Log(elekLogT.GENERAL, log.InfoLevel, - log.Fields {"Adding host" : fmt.Sprintf("%s",host)}, "New host detected") + elektronLogging.ElektronLog.Log(elekLogT.GENERAL, log.InfoLevel, + log.Fields{"Adding host": fmt.Sprintf("%s", host)}, "New host detected") // Add this host. constants.Hosts[host] = struct{}{} // Get the power class of this host. class := PowerClass(offer) - elektronLogging.ElektronLog.Log(elekLogT.GENERAL, log.InfoLevel, - log.Fields {"host" : fmt.Sprintf("%s",host), "PowerClass" : fmt.Sprintf("%s", class)}, "Registering the power class...") + elektronLogging.ElektronLog.Log(elekLogT.GENERAL, log.InfoLevel, + log.Fields{"host": fmt.Sprintf("%s", host), "PowerClass": fmt.Sprintf("%s", class)}, "Registering the power class...") // If new power class, register the power class. if _, ok := constants.PowerClasses[class]; !ok { constants.PowerClasses[class] = make(map[string]struct{}) diff --git a/utilities/runAvg/runAvg.go b/utilities/runAvg/runAvg.go index 5fb2389..557564c 100644 --- a/utilities/runAvg/runAvg.go +++ b/utilities/runAvg/runAvg.go @@ -1,20 +1,20 @@ // Copyright (C) 2018 spdfg -// +// // This file is part of Elektron. -// +// // Elektron is free software: you can redistribute it and/or modify // it under the terms of the GNU General Public License as published by // the Free Software Foundation, either version 3 of the License, or // (at your option) any later version. -// +// // Elektron is distributed in the hope that it will be useful, // but WITHOUT ANY WARRANTY; without even the implied warranty of // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the // GNU General Public License for more details. -// +// // You should have received a copy of the GNU General Public License // along with Elektron. If not, see . -// +// /* A utility to calculate the running average. diff --git a/utilities/schedUtils/schedUtils.go b/utilities/schedUtils/schedUtils.go index 31eff56..f90e9de 100644 --- a/utilities/schedUtils/schedUtils.go +++ b/utilities/schedUtils/schedUtils.go @@ -1,30 +1,30 @@ // Copyright (C) 2018 spdfg -// +// // This file is part of Elektron. -// +// // Elektron is free software: you can redistribute it and/or modify // it under the terms of the GNU General Public License as published by // the Free Software Foundation, either version 3 of the License, or // (at your option) any later version. -// +// // Elektron is distributed in the hope that it will be useful, // but WITHOUT ANY WARRANTY; without even the implied warranty of // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the // GNU General Public License for more details. -// +// // You should have received a copy of the GNU General Public License // along with Elektron. If not, see . -// +// package schedUtils import ( - "fmt" + "fmt" + log "github.com/sirupsen/logrus" "github.com/spdfg/elektron/def" - "github.com/spdfg/elektron/utilities" - "github.com/spdfg/elektron/elektronLogging" + "github.com/spdfg/elektron/elektronLogging" elekLogT "github.com/spdfg/elektron/elektronLogging/types" - log "github.com/sirupsen/logrus" + "github.com/spdfg/elektron/utilities" ) // Criteria for resizing the scheduling window. @@ -79,9 +79,9 @@ func (s *fillNextOfferCycle) apply(taskQueue []def.Task) (int, int) { for _, task := range taskQueue { numberOfTasksTraversed++ for i := *task.Instances; i > 0; i-- { - elektronLogging.ElektronLog.Log(elekLogT.GENERAL, log.InfoLevel, - log.Fields {}, fmt.Sprintf("Checking if Instance #%d of Task[%s] can be scheduled "+ - "during the next offer cycle...", i, task.Name)) + elektronLogging.ElektronLog.Log(elekLogT.GENERAL, log.InfoLevel, + log.Fields{}, fmt.Sprintf("Checking if Instance #%d of Task[%s] can be scheduled "+ + "during the next offer cycle...", i, task.Name)) if canSchedule(task) { filledCPU += task.CPU filledRAM += task.RAM diff --git a/utilities/trackResourceUsage.go b/utilities/trackResourceUsage.go index 2279adf..601ee85 100644 --- a/utilities/trackResourceUsage.go +++ b/utilities/trackResourceUsage.go @@ -1,20 +1,20 @@ // Copyright (C) 2018 spdfg -// +// // This file is part of Elektron. -// +// // Elektron is free software: you can redistribute it and/or modify // it under the terms of the GNU General Public License as published by // the Free Software Foundation, either version 3 of the License, or // (at your option) any later version. -// +// // Elektron is distributed in the hope that it will be useful, // but WITHOUT ANY WARRANTY; without even the implied warranty of // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the // GNU General Public License for more details. -// +// // You should have received a copy of the GNU General Public License // along with Elektron. If not, see . -// +// package utilities diff --git a/utilities/utils.go b/utilities/utils.go index 2e1af2e..a93a8a7 100644 --- a/utilities/utils.go +++ b/utilities/utils.go @@ -1,20 +1,20 @@ // Copyright (C) 2018 spdfg -// +// // This file is part of Elektron. -// +// // Elektron is free software: you can redistribute it and/or modify // it under the terms of the GNU General Public License as published by // the Free Software Foundation, either version 3 of the License, or // (at your option) any later version. -// +// // Elektron is distributed in the hope that it will be useful, // but WITHOUT ANY WARRANTY; without even the implied warranty of // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the // GNU General Public License for more details. -// +// // You should have received a copy of the GNU General Public License // along with Elektron. If not, see . -// +// package utilities -- 2.47.2 From 20f2f1e8c5fa1f03e69be10afa861563c87f9ba1 Mon Sep 17 00:00:00 2001 From: balandi1 Date: Wed, 20 Nov 2019 16:11:33 -0500 Subject: [PATCH 08/48] Used string join at neccesary places. Removed unused code --- elektronLogging/ElektronFormatter.go | 9 +++------ .../clsfnTaskDistOverheadLogger.go | 7 ++++--- elektronLogging/consoleLogger.go | 8 ++++---- elektronLogging/createLogDir.go | 18 +++++++---------- elektronLogging/logger.go | 16 +++++++-------- elektronLogging/loggerChain.go | 11 +--------- elektronLogging/pcpLogger.go | 7 ++++--- elektronLogging/schedPolicySwitchLogger.go | 7 ++++--- elektronLogging/schedTraceLogger.go | 7 ++++--- elektronLogging/schedWindowLogger.go | 8 +++++--- elektronLogging/types/types.go | 20 +++++++++---------- scheduler.go | 18 +++++++---------- 12 files changed, 60 insertions(+), 76 deletions(-) diff --git a/elektronLogging/ElektronFormatter.go b/elektronLogging/ElektronFormatter.go index 265d73b..c54fc6a 100644 --- a/elektronLogging/ElektronFormatter.go +++ b/elektronLogging/ElektronFormatter.go @@ -2,7 +2,6 @@ package elektronLogging import ( "bytes" - "fmt" "github.com/fatih/color" log "github.com/sirupsen/logrus" "strings" @@ -37,14 +36,12 @@ func (f ElektronFormatter) Format(entry *log.Entry) ([]byte, error) { levelColor := f.getColor(entry) level := levelColor.Sprintf("[%s]:", strings.ToUpper(entry.Level.String())) - message := fmt.Sprintf("%s %s ", level, entry.Time.Format(f.TimestampFormat)) - if entry.Message != "" { - message = fmt.Sprintf("%s %s %s ", level, entry.Time.Format(f.TimestampFormat), entry.Message) - } + message := strings.Join([]string{level, entry.Time.Format(f.TimestampFormat), entry.Message, " "}, " ") + var formattedFields []string for key, value := range entry.Data { formattedFields = append(formattedFields, - strings.Join([]string{key, fmt.Sprintf("%s", value)}, "=")) + strings.Join([]string{key, value.(string)}, "=")) } b.WriteString(message) diff --git a/elektronLogging/clsfnTaskDistOverheadLogger.go b/elektronLogging/clsfnTaskDistOverheadLogger.go index 749c776..9bae203 100644 --- a/elektronLogging/clsfnTaskDistOverheadLogger.go +++ b/elektronLogging/clsfnTaskDistOverheadLogger.go @@ -3,6 +3,7 @@ package elektronLogging import ( log "github.com/sirupsen/logrus" "os" + "strings" ) type ClsfnTaskDistOverheadLogger struct { @@ -10,7 +11,7 @@ type ClsfnTaskDistOverheadLogger struct { } func NewClsfnTaskDistOverheadLogger(logType int, prefix string) *ClsfnTaskDistOverheadLogger { - cLog := new(ClsfnTaskDistOverheadLogger) + cLog := &ClsfnTaskDistOverheadLogger{} cLog.Type = logType cLog.SetLogFile(prefix) return cLog @@ -36,9 +37,9 @@ func (cLog *ClsfnTaskDistOverheadLogger) Log(logType int, level log.Level, logDa func (cLog *ClsfnTaskDistOverheadLogger) SetLogFile(prefix string) { - tskDistLogPrefix := prefix + config.TaskDistConfig.FilenameExtension + tskDistLogPrefix := strings.Join([]string{prefix, config.TaskDistConfig.FilenameExtension}, "") if logDir != "" { - tskDistLogPrefix = logDir + "/" + tskDistLogPrefix + tskDistLogPrefix = strings.Join([]string{logDir, tskDistLogPrefix}, "/") } if logFile, err := os.Create(tskDistLogPrefix); err != nil { log.Fatal("Unable to create logFile: ", err) diff --git a/elektronLogging/consoleLogger.go b/elektronLogging/consoleLogger.go index 0801295..1c6b379 100644 --- a/elektronLogging/consoleLogger.go +++ b/elektronLogging/consoleLogger.go @@ -3,6 +3,7 @@ package elektronLogging import ( log "github.com/sirupsen/logrus" "os" + "strings" ) type ConsoleLogger struct { @@ -10,7 +11,7 @@ type ConsoleLogger struct { } func NewConsoleLogger(logType int, prefix string) *ConsoleLogger { - cLog := new(ConsoleLogger) + cLog := &ConsoleLogger{} cLog.Type = logType cLog.SetLogFile(prefix) return cLog @@ -18,7 +19,6 @@ func NewConsoleLogger(logType int, prefix string) *ConsoleLogger { func (cLog *ConsoleLogger) Log(logType int, level log.Level, logData log.Fields, message string) { if logType <= cLog.Type { - //logFields := cloneFields(logData) logger.SetLevel(level) logger.SetOutput(os.Stdout) @@ -34,9 +34,9 @@ func (cLog *ConsoleLogger) Log(logType int, level log.Level, logData log.Fields, func (cLog *ConsoleLogger) SetLogFile(prefix string) { - consoleLogPrefix := prefix + config.ConsoleConfig.FilenameExtension + consoleLogPrefix := strings.Join([]string{prefix, config.ConsoleConfig.FilenameExtension}, "") if logDir != "" { - consoleLogPrefix = logDir + "/" + consoleLogPrefix + consoleLogPrefix = strings.Join([]string{logDir, consoleLogPrefix}, "/") } if logFile, err := os.Create(consoleLogPrefix); err != nil { log.Fatal("Unable to create logFile: ", err) diff --git a/elektronLogging/createLogDir.go b/elektronLogging/createLogDir.go index 397a2a7..8de5faa 100644 --- a/elektronLogging/createLogDir.go +++ b/elektronLogging/createLogDir.go @@ -4,6 +4,7 @@ import ( logrus "github.com/sirupsen/logrus" "os" "strconv" + "strings" "time" ) @@ -16,18 +17,13 @@ func GetLogDir(startTime time.Time, prefix string) { } func createLogDir(prefix string, startTime time.Time) string { + // Creating directory to store all logs for this run - logDirName := "./" + prefix + strconv.Itoa(startTime.Year()) - logDirName += "-" - logDirName += startTime.Month().String() - logDirName += "-" - logDirName += strconv.Itoa(startTime.Day()) - logDirName += "_" - logDirName += strconv.Itoa(startTime.Hour()) - logDirName += "-" - logDirName += strconv.Itoa(startTime.Minute()) - logDirName += "-" - logDirName += strconv.Itoa(startTime.Second()) + logDirName := strings.Join([]string{"./", prefix, strconv.Itoa(startTime.Year())}, "") + logDirName = strings.Join([]string{logDirName, startTime.Month().String(), strconv.Itoa(startTime.Day())}, "-") + logDirName = strings.Join([]string{logDirName, strconv.Itoa(startTime.Hour())}, "_") + logDirName = strings.Join([]string{logDirName, strconv.Itoa(startTime.Minute()), strconv.Itoa(startTime.Second())}, "-") + if _, err := os.Stat(logDirName); os.IsNotExist(err) { os.Mkdir(logDirName, 0755) } else { diff --git a/elektronLogging/logger.go b/elektronLogging/logger.go index 94e4b62..08bab12 100644 --- a/elektronLogging/logger.go +++ b/elektronLogging/logger.go @@ -1,18 +1,18 @@ package elektronLogging import ( - "fmt" log "github.com/sirupsen/logrus" . "github.com/spdfg/elektron/elektronLogging/types" - "strconv" + "strings" "time" ) var config LoggerConfig var logger *log.Logger var formatter ElektronFormatter +var ElektronLog *LoggerImpl -func BuildLogger() *LoggerImpl { +func BuildLogger(prefix string) { // read configuration from yaml config.GetConfig() @@ -20,17 +20,17 @@ func BuildLogger() *LoggerImpl { // create the log directory startTime := time.Now() formatter.TimestampFormat = "2006-01-02 15:04:05" + formattedStartTime := startTime.Format("20060102150405") GetLogDir(startTime, "_") - prefix := fmt.Sprintf("_%d%d%s%s%s%s", startTime.Year(), startTime.Month(), strconv.Itoa(startTime.Day()), - strconv.Itoa(startTime.Hour()), strconv.Itoa(startTime.Minute()), strconv.Itoa(startTime.Second())) + prefix = strings.Join([]string{prefix, formattedStartTime}, "_") //create a single logrus instance and set its formatter to ElektronFormatter logger = log.New() logger.SetFormatter(&formatter) // create a chain of loggers - head := new(LoggerImpl) + head := &LoggerImpl{} cLog := NewConsoleLogger(CONSOLE, prefix) pLog := NewPcpLogger(PCP, prefix) schedTraceLog := NewSchedTraceLogger(SCHED_TRACE, prefix) @@ -45,7 +45,5 @@ func BuildLogger() *LoggerImpl { spsLog.SetNext(schedWindowLog) schedWindowLog.SetNext(tskDistLog) - return head + ElektronLog = head } - -var ElektronLog = BuildLogger() diff --git a/elektronLogging/loggerChain.go b/elektronLogging/loggerChain.go index 236f2fa..8a8207a 100644 --- a/elektronLogging/loggerChain.go +++ b/elektronLogging/loggerChain.go @@ -1,9 +1,8 @@ package elektronLogging import ( - "os" - //data "github.com/spdfg/elektron/elektronLogging/data" log "github.com/sirupsen/logrus" + "os" ) type Logger interface { @@ -27,11 +26,3 @@ func (l *LoggerImpl) Log(logType int, level log.Level, logData log.Fields, messa l.next.Log(logType, level, logData, message) } } - -/*func cloneFields(logData data.LogData) log.Fields { - var newMap = make(log.Fields) - for k,v := range logData { - newMap[k] = v - } - return newMap -}*/ diff --git a/elektronLogging/pcpLogger.go b/elektronLogging/pcpLogger.go index 4969054..d7d12ae 100644 --- a/elektronLogging/pcpLogger.go +++ b/elektronLogging/pcpLogger.go @@ -3,6 +3,7 @@ package elektronLogging import ( log "github.com/sirupsen/logrus" "os" + "strings" ) type PcpLogger struct { @@ -10,7 +11,7 @@ type PcpLogger struct { } func NewPcpLogger(logType int, prefix string) *PcpLogger { - pLog := new(PcpLogger) + pLog := &PcpLogger{} pLog.Type = logType pLog.SetLogFile(prefix) return pLog @@ -36,9 +37,9 @@ func (pLog *PcpLogger) Log(logType int, level log.Level, logData log.Fields, mes func (plog *PcpLogger) SetLogFile(prefix string) { - pcpLogPrefix := prefix + config.PCPConfig.FilenameExtension + pcpLogPrefix := strings.Join([]string{prefix, config.PCPConfig.FilenameExtension}, "") if logDir != "" { - pcpLogPrefix = logDir + "/" + pcpLogPrefix + pcpLogPrefix = strings.Join([]string{logDir, pcpLogPrefix}, "/") } if logFile, err := os.Create(pcpLogPrefix); err != nil { log.Fatal("Unable to create logFile: ", err) diff --git a/elektronLogging/schedPolicySwitchLogger.go b/elektronLogging/schedPolicySwitchLogger.go index d2d41a0..6417bd3 100644 --- a/elektronLogging/schedPolicySwitchLogger.go +++ b/elektronLogging/schedPolicySwitchLogger.go @@ -3,6 +3,7 @@ package elektronLogging import ( log "github.com/sirupsen/logrus" "os" + "strings" ) type SchedPolicySwitchLogger struct { @@ -10,7 +11,7 @@ type SchedPolicySwitchLogger struct { } func NewSchedPolicySwitchLogger(logType int, prefix string) *SchedPolicySwitchLogger { - sLog := new(SchedPolicySwitchLogger) + sLog := &SchedPolicySwitchLogger{} sLog.Type = logType sLog.SetLogFile(prefix) return sLog @@ -36,9 +37,9 @@ func (sLog *SchedPolicySwitchLogger) Log(logType int, level log.Level, logData l func (sLog *SchedPolicySwitchLogger) SetLogFile(prefix string) { - spsLogPrefix := prefix + config.SPSConfig.FilenameExtension + spsLogPrefix := strings.Join([]string{prefix, config.SPSConfig.FilenameExtension}, "") if logDir != "" { - spsLogPrefix = logDir + "/" + spsLogPrefix + spsLogPrefix = strings.Join([]string{logDir, spsLogPrefix}, "/") } if logFile, err := os.Create(spsLogPrefix); err != nil { log.Fatal("Unable to create logFile: ", err) diff --git a/elektronLogging/schedTraceLogger.go b/elektronLogging/schedTraceLogger.go index 238c8e6..59b65bf 100644 --- a/elektronLogging/schedTraceLogger.go +++ b/elektronLogging/schedTraceLogger.go @@ -3,6 +3,7 @@ package elektronLogging import ( log "github.com/sirupsen/logrus" "os" + "strings" ) type SchedTraceLogger struct { @@ -10,7 +11,7 @@ type SchedTraceLogger struct { } func NewSchedTraceLogger(logType int, prefix string) *SchedTraceLogger { - sLog := new(SchedTraceLogger) + sLog := &SchedTraceLogger{} sLog.Type = logType sLog.SetLogFile(prefix) return sLog @@ -36,9 +37,9 @@ func (sLog *SchedTraceLogger) Log(logType int, level log.Level, logData log.Fiel func (sLog *SchedTraceLogger) SetLogFile(prefix string) { - schedTraceLogPrefix := prefix + config.SchedTraceConfig.FilenameExtension + schedTraceLogPrefix := strings.Join([]string{prefix, config.SchedTraceConfig.FilenameExtension}, "") if logDir != "" { - schedTraceLogPrefix = logDir + "/" + schedTraceLogPrefix + schedTraceLogPrefix = strings.Join([]string{logDir, schedTraceLogPrefix}, "/") } if logFile, err := os.Create(schedTraceLogPrefix); err != nil { log.Fatal("Unable to create logFile: ", err) diff --git a/elektronLogging/schedWindowLogger.go b/elektronLogging/schedWindowLogger.go index 9439698..e9e83ad 100644 --- a/elektronLogging/schedWindowLogger.go +++ b/elektronLogging/schedWindowLogger.go @@ -3,6 +3,7 @@ package elektronLogging import ( log "github.com/sirupsen/logrus" "os" + "strings" ) type SchedWindowLogger struct { @@ -10,7 +11,7 @@ type SchedWindowLogger struct { } func NewSchedWindowLogger(logType int, prefix string) *SchedWindowLogger { - sLog := new(SchedWindowLogger) + sLog := &SchedWindowLogger{} sLog.Type = logType sLog.SetLogFile(prefix) return sLog @@ -20,6 +21,7 @@ func (sLog *SchedWindowLogger) Log(logType int, level log.Level, logData log.Fie if sLog.Type == logType { logger.SetLevel(level) + if sLog.AllowOnConsole { logger.SetOutput(os.Stdout) logger.WithFields(logData).Println(message) @@ -35,9 +37,9 @@ func (sLog *SchedWindowLogger) Log(logType int, level log.Level, logData log.Fie func (sLog *SchedWindowLogger) SetLogFile(prefix string) { - schedWindowLogPrefix := prefix + config.SchedWindowConfig.FilenameExtension + schedWindowLogPrefix := strings.Join([]string{prefix, config.SchedWindowConfig.FilenameExtension}, "") if logDir != "" { - schedWindowLogPrefix = logDir + "/" + schedWindowLogPrefix + schedWindowLogPrefix = strings.Join([]string{logDir, schedWindowLogPrefix}, "/") } if logFile, err := os.Create(schedWindowLogPrefix); err != nil { log.Fatal("Unable to create logFile: ", err) diff --git a/elektronLogging/types/types.go b/elektronLogging/types/types.go index 0dd7fec..db6b624 100644 --- a/elektronLogging/types/types.go +++ b/elektronLogging/types/types.go @@ -1,14 +1,14 @@ package elektronLogging const ( - ERROR = iota - WARNING = iota - GENERAL = iota - SUCCESS = iota - CONSOLE = iota - PCP = iota - SCHED_TRACE = iota - SPS = iota - SCHED_WINDOW = iota - CLSFN_TASKDIST_OVERHEAD = iota + ERROR = iota + WARNING + GENERAL + SUCCESS + CONSOLE + PCP + SCHED_TRACE + SPS + SCHED_WINDOW + CLSFN_TASKDIST_OVERHEAD ) diff --git a/scheduler.go b/scheduler.go index 63cd2f1..d6c28a2 100644 --- a/scheduler.go +++ b/scheduler.go @@ -21,10 +21,6 @@ package main // import github.com/spdfg/elektron import ( "flag" "fmt" - "os" - "os/signal" - "time" - "github.com/golang/protobuf/proto" mesos "github.com/mesos/mesos-go/api/v0/mesosproto" sched "github.com/mesos/mesos-go/api/v0/scheduler" @@ -35,6 +31,10 @@ import ( "github.com/spdfg/elektron/pcp" "github.com/spdfg/elektron/powerCap" "github.com/spdfg/elektron/schedulers" + "os" + "os/signal" + "strings" + "time" ) var master = flag.String("master", "", "Location of leading Mesos master -- :") @@ -116,11 +116,6 @@ func main() { pcpLog := make(chan struct{}) recordPCP := false - // Logging channels. - // These channels are used by the framework to log messages. - // The channels are used to send the type of log message and the message string. - //schedOptions = append(schedOptions, schedulers.WithLoggingChannels(logMType, logMsg)) - // Shutdown indicator channels. // These channels are used to notify, // 1. scheduling is complete. @@ -225,9 +220,10 @@ func main() { } // Checking if prefix contains any special characters. - /*if strings.Contains(*pcplogPrefix, "/") { + if strings.Contains(*pcplogPrefix, "/") { log.Fatal("log file prefix should not contain '/'.") - }*/ + } + elektronLogging.BuildLogger(*pcplogPrefix) // Starting PCP logging. if noPowercap { -- 2.47.2 From 13c3de44be395328eaafd29f258d983bc413c174 Mon Sep 17 00:00:00 2001 From: balandi1 Date: Thu, 21 Nov 2019 13:05:52 -0500 Subject: [PATCH 09/48] Changed alias elekLogT to elekLogTypes --- def/taskUtils.go | 6 ++-- elektronLogging/logger.go | 9 ++++-- powerCap/extrema.go | 28 ++++++++-------- powerCap/progressiveExtrema.go | 46 +++++++++++++------------- scheduler.go | 6 ++-- schedulers/base.go | 52 +++++++++++++++--------------- schedulers/helpers.go | 6 ++-- schedulers/schedPolicy.go | 4 +-- utilities/offerUtils/offerUtils.go | 6 ++-- utilities/schedUtils/schedUtils.go | 4 +-- 10 files changed, 85 insertions(+), 82 deletions(-) diff --git a/def/taskUtils.go b/def/taskUtils.go index 734814a..cb93afa 100644 --- a/def/taskUtils.go +++ b/def/taskUtils.go @@ -27,7 +27,7 @@ import ( "github.com/montanaflynn/stats" log "github.com/sirupsen/logrus" "github.com/spdfg/elektron/elektronLogging" - elekLogT "github.com/spdfg/elektron/elektronLogging/types" + elekLogTypes "github.com/spdfg/elektron/elektronLogging/types" ) // Information about a cluster of tasks. @@ -52,7 +52,7 @@ func (tc TasksToClassify) taskObservationCalculator(task Task) []float64 { } else if task.Watts != 0.0 { return []float64{task.Watts} } else { - elektronLogging.ElektronLog.Log(elekLogT.ERROR, log.FatalLevel, + elektronLogging.ElektronLog.Log(elekLogTypes.ERROR, log.FatalLevel, log.Fields{}, "Unable to classify tasks. Missing Watts or ClassToWatts attribute in workload") return []float64{0.0} // Won't reach here. } @@ -108,7 +108,7 @@ func clusterSizeAvgMMMPU(tasks []Task, taskObservation func(task Task) []float64 } else { // skip this value // there is an error in the task config. - elektronLogging.ElektronLog.Log(elekLogT.ERROR, log.ErrorLevel, + elektronLogging.ElektronLog.Log(elekLogTypes.ERROR, log.ErrorLevel, log.Fields{}, fmt.Sprintf("%s", err)) } } else { diff --git a/elektronLogging/logger.go b/elektronLogging/logger.go index 08bab12..1a275f5 100644 --- a/elektronLogging/logger.go +++ b/elektronLogging/logger.go @@ -3,6 +3,7 @@ package elektronLogging import ( log "github.com/sirupsen/logrus" . "github.com/spdfg/elektron/elektronLogging/types" + "os" "strings" "time" ) @@ -25,9 +26,11 @@ func BuildLogger(prefix string) { prefix = strings.Join([]string{prefix, formattedStartTime}, "_") - //create a single logrus instance and set its formatter to ElektronFormatter - logger = log.New() - logger.SetFormatter(&formatter) + logger = &log.Logger{ + Out: os.Stderr, + Level: log.DebugLevel, + Formatter: &formatter, + } // create a chain of loggers head := &LoggerImpl{} diff --git a/powerCap/extrema.go b/powerCap/extrema.go index 0978249..83e76b4 100644 --- a/powerCap/extrema.go +++ b/powerCap/extrema.go @@ -31,7 +31,7 @@ import ( log "github.com/sirupsen/logrus" "github.com/spdfg/elektron/elektronLogging" - elekLogT "github.com/spdfg/elektron/elektronLogging/types" + elekLogTypes "github.com/spdfg/elektron/elektronLogging/types" "github.com/spdfg/elektron/pcp" "github.com/spdfg/elektron/rapl" ) @@ -43,7 +43,7 @@ func StartPCPLogAndExtremaDynamicCap(quit chan struct{}, logging *bool, hiThresh cmd.SysProcAttr = &syscall.SysProcAttr{Setpgid: true} if hiThreshold < loThreshold { - elektronLogging.ElektronLog.Log(elekLogT.GENERAL, + elektronLogging.ElektronLog.Log(elekLogTypes.GENERAL, log.InfoLevel, log.Fields{}, "High threshold is lower than low threshold!") } @@ -61,7 +61,7 @@ func StartPCPLogAndExtremaDynamicCap(quit chan struct{}, logging *bool, hiThresh scanner.Scan() // Write to logfile - elektronLogging.ElektronLog.Log(elekLogT.PCP, + elektronLogging.ElektronLog.Log(elekLogTypes.PCP, log.InfoLevel, log.Fields{}, scanner.Text()) @@ -99,14 +99,14 @@ func StartPCPLogAndExtremaDynamicCap(quit chan struct{}, logging *bool, hiThresh if *logging { - elektronLogging.ElektronLog.Log(elekLogT.GENERAL, + elektronLogging.ElektronLog.Log(elekLogTypes.GENERAL, log.InfoLevel, log.Fields{}, "Logging PCP...") text := scanner.Text() split := strings.Split(text, ",") - elektronLogging.ElektronLog.Log(elekLogT.PCP, + elektronLogging.ElektronLog.Log(elekLogTypes.PCP, log.InfoLevel, log.Fields{}, text) @@ -119,7 +119,7 @@ func StartPCPLogAndExtremaDynamicCap(quit chan struct{}, logging *bool, hiThresh powerHistories[host].Value = power powerHistories[host] = powerHistories[host].Next() - elektronLogging.ElektronLog.Log(elekLogT.GENERAL, + elektronLogging.ElektronLog.Log(elekLogTypes.GENERAL, log.InfoLevel, log.Fields{"Host": fmt.Sprintf("%s", indexToHost[powerIndex]), "Power": fmt.Sprintf("%f", (power * pcp.RAPLUnits))}, "") @@ -133,14 +133,14 @@ func StartPCPLogAndExtremaDynamicCap(quit chan struct{}, logging *bool, hiThresh clusterMean := pcp.AverageClusterPowerHistory(clusterPowerHist) - elektronLogging.ElektronLog.Log(elekLogT.GENERAL, + elektronLogging.ElektronLog.Log(elekLogTypes.GENERAL, log.InfoLevel, log.Fields{"Total power": fmt.Sprintf("%f %d", clusterPower, clusterPowerHist.Len()), "Sec Avg": fmt.Sprintf("%f", clusterMean)}, "") if clusterMean > hiThreshold { - elektronLogging.ElektronLog.Log(elekLogT.GENERAL, + elektronLogging.ElektronLog.Log(elekLogTypes.GENERAL, log.InfoLevel, log.Fields{}, "Need to cap a node") // Create statics for all victims and choose one to cap @@ -163,12 +163,12 @@ func StartPCPLogAndExtremaDynamicCap(quit chan struct{}, logging *bool, hiThresh if !cappedHosts[victim.Host] { cappedHosts[victim.Host] = true orderCapped = append(orderCapped, victim.Host) - elektronLogging.ElektronLog.Log(elekLogT.GENERAL, + elektronLogging.ElektronLog.Log(elekLogTypes.GENERAL, log.InfoLevel, log.Fields{"Capping Victim": fmt.Sprintf("%s", victim.Host), "Avg. Wattage": fmt.Sprintf("%f", victim.Watts*pcp.RAPLUnits)}, "") if err := rapl.Cap(victim.Host, "rapl", 50); err != nil { - elektronLogging.ElektronLog.Log(elekLogT.ERROR, + elektronLogging.ElektronLog.Log(elekLogTypes.ERROR, log.ErrorLevel, log.Fields{}, "Error capping host") } @@ -184,11 +184,11 @@ func StartPCPLogAndExtremaDynamicCap(quit chan struct{}, logging *bool, hiThresh cappedHosts[host] = false // User RAPL package to send uncap. log.Printf("Uncapping host %s", host) - elektronLogging.ElektronLog.Log(elekLogT.GENERAL, + elektronLogging.ElektronLog.Log(elekLogTypes.GENERAL, log.InfoLevel, log.Fields{"Uncapped host": host}, "") if err := rapl.Cap(host, "rapl", 100); err != nil { - elektronLogging.ElektronLog.Log(elekLogT.ERROR, + elektronLogging.ElektronLog.Log(elekLogTypes.ERROR, log.ErrorLevel, log.Fields{}, "Error capping host") } @@ -200,7 +200,7 @@ func StartPCPLogAndExtremaDynamicCap(quit chan struct{}, logging *bool, hiThresh } }(logging, hiThreshold, loThreshold) - elektronLogging.ElektronLog.Log(elekLogT.GENERAL, + elektronLogging.ElektronLog.Log(elekLogTypes.GENERAL, log.InfoLevel, log.Fields{}, "PCP logging started") @@ -212,7 +212,7 @@ func StartPCPLogAndExtremaDynamicCap(quit chan struct{}, logging *bool, hiThresh select { case <-quit: - elektronLogging.ElektronLog.Log(elekLogT.GENERAL, + elektronLogging.ElektronLog.Log(elekLogTypes.GENERAL, log.InfoLevel, log.Fields{}, "Stopping PCP logging in 5 seconds") time.Sleep(5 * time.Second) diff --git a/powerCap/progressiveExtrema.go b/powerCap/progressiveExtrema.go index 807449a..034376f 100644 --- a/powerCap/progressiveExtrema.go +++ b/powerCap/progressiveExtrema.go @@ -33,7 +33,7 @@ import ( log "github.com/sirupsen/logrus" "github.com/spdfg/elektron/constants" "github.com/spdfg/elektron/elektronLogging" - elekLogT "github.com/spdfg/elektron/elektronLogging/types" + elekLogTypes "github.com/spdfg/elektron/elektronLogging/types" "github.com/spdfg/elektron/pcp" "github.com/spdfg/elektron/rapl" "github.com/spdfg/elektron/utilities" @@ -56,7 +56,7 @@ func StartPCPLogAndProgressiveExtremaCap(quit chan struct{}, logging *bool, hiTh cmd.SysProcAttr = &syscall.SysProcAttr{Setpgid: true} if hiThreshold < loThreshold { - elektronLogging.ElektronLog.Log(elekLogT.GENERAL, + elektronLogging.ElektronLog.Log(elekLogTypes.GENERAL, log.InfoLevel, log.Fields{}, "High threshold is lower than low threshold!") } @@ -74,7 +74,7 @@ func StartPCPLogAndProgressiveExtremaCap(quit chan struct{}, logging *bool, hiTh scanner.Scan() // Write to logfile - elektronLogging.ElektronLog.Log(elekLogT.PCP, + elektronLogging.ElektronLog.Log(elekLogTypes.PCP, log.InfoLevel, log.Fields{}, scanner.Text()) @@ -115,13 +115,13 @@ func StartPCPLogAndProgressiveExtremaCap(quit chan struct{}, logging *bool, hiTh for scanner.Scan() { if *logging { - elektronLogging.ElektronLog.Log(elekLogT.GENERAL, + elektronLogging.ElektronLog.Log(elekLogTypes.GENERAL, log.InfoLevel, log.Fields{}, "Logging PCP...") split := strings.Split(scanner.Text(), ",") text := scanner.Text() - elektronLogging.ElektronLog.Log(elekLogT.PCP, + elektronLogging.ElektronLog.Log(elekLogTypes.PCP, log.InfoLevel, log.Fields{}, text) @@ -134,7 +134,7 @@ func StartPCPLogAndProgressiveExtremaCap(quit chan struct{}, logging *bool, hiTh powerHistories[host].Value = power powerHistories[host] = powerHistories[host].Next() - elektronLogging.ElektronLog.Log(elekLogT.GENERAL, + elektronLogging.ElektronLog.Log(elekLogTypes.GENERAL, log.InfoLevel, log.Fields{"Host": fmt.Sprintf("%s", indexToHost[powerIndex]), "Power": fmt.Sprintf("%f", (power * pcp.RAPLUnits))}, "") @@ -147,22 +147,22 @@ func StartPCPLogAndProgressiveExtremaCap(quit chan struct{}, logging *bool, hiTh clusterMean := pcp.AverageClusterPowerHistory(clusterPowerHist) - elektronLogging.ElektronLog.Log(elekLogT.GENERAL, + elektronLogging.ElektronLog.Log(elekLogTypes.GENERAL, log.InfoLevel, log.Fields{"Total power": fmt.Sprintf("%f %d", clusterPower, clusterPowerHist.Len()), "Sec Avg": fmt.Sprintf("%f", clusterMean)}, "") if clusterMean >= hiThreshold { - elektronLogging.ElektronLog.Log(elekLogT.GENERAL, + elektronLogging.ElektronLog.Log(elekLogTypes.GENERAL, log.InfoLevel, log.Fields{}, "Need to cap a node") - elektronLogging.ElektronLog.Log(elekLogT.GENERAL, + elektronLogging.ElektronLog.Log(elekLogTypes.GENERAL, log.InfoLevel, log.Fields{"Cap values of capped victims": fmt.Sprintf("%v", cappedVictims)}, "") - elektronLogging.ElektronLog.Log(elekLogT.GENERAL, + elektronLogging.ElektronLog.Log(elekLogTypes.GENERAL, log.InfoLevel, log.Fields{"Cap values of victims to uncap": fmt.Sprintf("%v", orderCappedVictims)}, "") // Create statics for all victims and choose one to cap @@ -192,12 +192,12 @@ func StartPCPLogAndProgressiveExtremaCap(quit chan struct{}, logging *bool, hiTh // Need to cap this victim. if err := rapl.Cap(victims[i].Host, "rapl", 50.0); err != nil { - elektronLogging.ElektronLog.Log(elekLogT.ERROR, + elektronLogging.ElektronLog.Log(elekLogTypes.ERROR, log.ErrorLevel, log.Fields{"Error capping host": fmt.Sprintf("%s", victims[i].Host)}, "") } else { - elektronLogging.ElektronLog.Log(elekLogT.GENERAL, + elektronLogging.ElektronLog.Log(elekLogTypes.GENERAL, log.InfoLevel, log.Fields{}, fmt.Sprintf("Capped host[%s] at %f", victims[i].Host, 50.0)) // Keeping track of this victim and it's cap value @@ -223,12 +223,12 @@ func StartPCPLogAndProgressiveExtremaCap(quit chan struct{}, logging *bool, hiTh newCapValue := getNextCapValue(capValue, 2) if err := rapl.Cap(alreadyCappedHosts[i], "rapl", newCapValue); err != nil { - elektronLogging.ElektronLog.Log(elekLogT.ERROR, + elektronLogging.ElektronLog.Log(elekLogTypes.ERROR, log.ErrorLevel, log.Fields{"Error capping host": fmt.Sprintf("%s", alreadyCappedHosts[i])}, "") } else { // Successful cap - elektronLogging.ElektronLog.Log(elekLogT.GENERAL, + elektronLogging.ElektronLog.Log(elekLogTypes.GENERAL, log.InfoLevel, log.Fields{}, fmt.Sprintf("Capped host[%s] at %f", alreadyCappedHosts[i], newCapValue)) // Checking whether this victim can be capped further @@ -253,7 +253,7 @@ func StartPCPLogAndProgressiveExtremaCap(quit chan struct{}, logging *bool, hiTh } } if !canCapAlreadyCappedVictim { - elektronLogging.ElektronLog.Log(elekLogT.GENERAL, + elektronLogging.ElektronLog.Log(elekLogTypes.GENERAL, log.InfoLevel, log.Fields{}, "No Victim left to cap") } @@ -261,13 +261,13 @@ func StartPCPLogAndProgressiveExtremaCap(quit chan struct{}, logging *bool, hiTh } else if clusterMean < loThreshold { - elektronLogging.ElektronLog.Log(elekLogT.GENERAL, + elektronLogging.ElektronLog.Log(elekLogTypes.GENERAL, log.InfoLevel, log.Fields{}, "Need to uncap a node") - elektronLogging.ElektronLog.Log(elekLogT.GENERAL, + elektronLogging.ElektronLog.Log(elekLogTypes.GENERAL, log.InfoLevel, log.Fields{"Cap values of capped victims": fmt.Sprintf("%v", cappedVictims)}, "") - elektronLogging.ElektronLog.Log(elekLogT.GENERAL, + elektronLogging.ElektronLog.Log(elekLogTypes.GENERAL, log.InfoLevel, log.Fields{"Cap values of victims to uncap": fmt.Sprintf("%v", orderCappedVictims)}, "") if len(orderCapped) > 0 { @@ -280,12 +280,12 @@ func StartPCPLogAndProgressiveExtremaCap(quit chan struct{}, logging *bool, hiTh newUncapValue := orderCappedVictims[hostToUncap] * 2.0 if err := rapl.Cap(hostToUncap, "rapl", newUncapValue); err != nil { - elektronLogging.ElektronLog.Log(elekLogT.ERROR, + elektronLogging.ElektronLog.Log(elekLogTypes.ERROR, log.ErrorLevel, log.Fields{"Error uncapping host": fmt.Sprintf("%s", hostToUncap)}, "") } else { // Successful uncap - elektronLogging.ElektronLog.Log(elekLogT.GENERAL, + elektronLogging.ElektronLog.Log(elekLogTypes.GENERAL, log.InfoLevel, log.Fields{}, fmt.Sprintf("Uncapped host[%s] to %f", hostToUncap, newUncapValue)) // Can we uncap this host further. If not, then we remove its entry from orderCapped @@ -308,7 +308,7 @@ func StartPCPLogAndProgressiveExtremaCap(quit chan struct{}, logging *bool, hiTh } } } else { - elektronLogging.ElektronLog.Log(elekLogT.GENERAL, + elektronLogging.ElektronLog.Log(elekLogTypes.GENERAL, log.InfoLevel, log.Fields{}, "No host staged for Uncapped") } @@ -319,7 +319,7 @@ func StartPCPLogAndProgressiveExtremaCap(quit chan struct{}, logging *bool, hiTh }(logging, hiThreshold, loThreshold) - elektronLogging.ElektronLog.Log(elekLogT.GENERAL, + elektronLogging.ElektronLog.Log(elekLogTypes.GENERAL, log.InfoLevel, log.Fields{}, "PCP logging started") if err := cmd.Start(); err != nil { @@ -330,7 +330,7 @@ func StartPCPLogAndProgressiveExtremaCap(quit chan struct{}, logging *bool, hiTh select { case <-quit: - elektronLogging.ElektronLog.Log(elekLogT.GENERAL, + elektronLogging.ElektronLog.Log(elekLogTypes.GENERAL, log.InfoLevel, log.Fields{}, "Stopping PCP logging in 5 seconds") time.Sleep(5 * time.Second) diff --git a/scheduler.go b/scheduler.go index d6c28a2..a0d453d 100644 --- a/scheduler.go +++ b/scheduler.go @@ -27,7 +27,7 @@ import ( log "github.com/sirupsen/logrus" "github.com/spdfg/elektron/def" "github.com/spdfg/elektron/elektronLogging" - elekLogT "github.com/spdfg/elektron/elektronLogging/types" + elekLogTypes "github.com/spdfg/elektron/elektronLogging/types" "github.com/spdfg/elektron/pcp" "github.com/spdfg/elektron/powerCap" "github.com/spdfg/elektron/schedulers" @@ -278,11 +278,11 @@ func main() { // Starting the scheduler driver. if status, err := driver.Run(); err != nil { - elektronLogging.ElektronLog.Log(elekLogT.ERROR, + elektronLogging.ElektronLog.Log(elekLogTypes.ERROR, log.ErrorLevel, log.Fields{"status": status.String(), "error": err.Error()}, "Framework stopped ") } - elektronLogging.ElektronLog.Log(elekLogT.GENERAL, + elektronLogging.ElektronLog.Log(elekLogTypes.GENERAL, log.InfoLevel, log.Fields{}, "Exiting...") } diff --git a/schedulers/base.go b/schedulers/base.go index 677ed81..decec5c 100644 --- a/schedulers/base.go +++ b/schedulers/base.go @@ -31,7 +31,7 @@ import ( log "github.com/sirupsen/logrus" "github.com/spdfg/elektron/def" "github.com/spdfg/elektron/elektronLogging" - elekLogT "github.com/spdfg/elektron/elektronLogging/types" + elekLogTypes "github.com/spdfg/elektron/elektronLogging/types" "github.com/spdfg/elektron/utilities" "github.com/spdfg/elektron/utilities/schedUtils" ) @@ -249,7 +249,7 @@ func (s *BaseScheduler) StatusUpdate(driver sched.SchedulerDriver, status *mesos } func (s *BaseScheduler) LogTaskStarting(ts *def.Task, offer *mesos.Offer) { - lmt := elekLogT.GENERAL + lmt := elekLogTypes.GENERAL if ts == nil { elektronLogging.ElektronLog.Log(lmt, log.InfoLevel, log.Fields{"host": fmt.Sprintf("%s", offer.GetHostname())}, "TASKS STARTING...") @@ -263,35 +263,35 @@ func (s *BaseScheduler) LogTaskStarting(ts *def.Task, offer *mesos.Offer) { } func (s *BaseScheduler) LogTaskWattsConsideration(ts def.Task, host string, wattsToConsider float64) { - lmt := elekLogT.GENERAL + lmt := elekLogTypes.GENERAL elektronLogging.ElektronLog.Log(lmt, log.InfoLevel, log.Fields{"task": ts.Name, "host": host, "Watts": fmt.Sprintf("%f", wattsToConsider)}, "Watts considered for ") } func (s *BaseScheduler) LogOffersReceived(offers []*mesos.Offer) { - lmt := elekLogT.GENERAL + lmt := elekLogTypes.GENERAL elektronLogging.ElektronLog.Log(lmt, log.InfoLevel, log.Fields{"Resource offers received": fmt.Sprintf("%d", len(offers))}, "") } func (s *BaseScheduler) LogNoPendingTasksDeclineOffers(offer *mesos.Offer) { - lmt := elekLogT.WARNING + lmt := elekLogTypes.WARNING elektronLogging.ElektronLog.Log(lmt, log.WarnLevel, log.Fields{"DECLINING OFFER for host": fmt.Sprintf("%s", offer.GetHostname())}, "No tasks left to schedule ") } func (s *BaseScheduler) LogNumberOfRunningTasks() { - lmt := elekLogT.GENERAL + lmt := elekLogTypes.GENERAL elektronLogging.ElektronLog.Log(lmt, log.InfoLevel, log.Fields{"Number of tasks still Running": fmt.Sprintf("%d", s.tasksRunning)}, "") } func (s *BaseScheduler) LogCoLocatedTasks(slaveID string) { - lmt := elekLogT.GENERAL + lmt := elekLogTypes.GENERAL buffer := bytes.Buffer{} s.TasksRunningMutex.Lock() for taskName := range s.Running[slaveID] { @@ -304,13 +304,13 @@ func (s *BaseScheduler) LogCoLocatedTasks(slaveID string) { } func (s *BaseScheduler) LogSchedTrace(taskToSchedule *mesos.TaskInfo, offer *mesos.Offer) { - elektronLogging.ElektronLog.Log(elekLogT.SCHED_TRACE, + elektronLogging.ElektronLog.Log(elekLogTypes.SCHED_TRACE, log.InfoLevel, log.Fields{offer.GetHostname(): fmt.Sprintf("%s", taskToSchedule.GetTaskId().GetValue())}, "") } func (s *BaseScheduler) LogTerminateScheduler() { - lmt := elekLogT.GENERAL + lmt := elekLogTypes.GENERAL elektronLogging.ElektronLog.Log(lmt, log.InfoLevel, log.Fields{}, "Done scheduling all tasks!") @@ -318,7 +318,7 @@ func (s *BaseScheduler) LogTerminateScheduler() { func (s *BaseScheduler) LogInsufficientResourcesDeclineOffer(offer *mesos.Offer, offerResources ...interface{}) { - lmt := elekLogT.WARNING + lmt := elekLogTypes.WARNING buffer := bytes.Buffer{} buffer.WriteString(fmt.Sprintf("", offerResources...)) elektronLogging.ElektronLog.Log(lmt, @@ -327,21 +327,21 @@ func (s *BaseScheduler) LogInsufficientResourcesDeclineOffer(offer *mesos.Offer, } func (s *BaseScheduler) LogOfferRescinded(offerID *mesos.OfferID) { - lmt := elekLogT.ERROR + lmt := elekLogTypes.ERROR elektronLogging.ElektronLog.Log(lmt, log.ErrorLevel, log.Fields{"OfferID": fmt.Sprintf("%s", offerID)}, "OFFER RESCINDED") } func (s *BaseScheduler) LogSlaveLost(slaveID *mesos.SlaveID) { - lmt := elekLogT.ERROR + lmt := elekLogTypes.ERROR elektronLogging.ElektronLog.Log(lmt, log.ErrorLevel, log.Fields{"SlaveID": fmt.Sprintf("%s", slaveID)}, "SLAVE LOST") } func (s *BaseScheduler) LogExecutorLost(executorID *mesos.ExecutorID, slaveID *mesos.SlaveID) { - lmt := elekLogT.ERROR + lmt := elekLogTypes.ERROR elektronLogging.ElektronLog.Log(lmt, log.ErrorLevel, log.Fields{"ExecutorID": fmt.Sprintf("%s", executorID), "SlaveID": fmt.Sprintf("%s", slaveID)}, "EXECUTOR LOST") @@ -349,21 +349,21 @@ func (s *BaseScheduler) LogExecutorLost(executorID *mesos.ExecutorID, slaveID *m func (s *BaseScheduler) LogFrameworkMessage(executorID *mesos.ExecutorID, slaveID *mesos.SlaveID, message string) { - lmt := elekLogT.GENERAL + lmt := elekLogTypes.GENERAL elektronLogging.ElektronLog.Log(lmt, log.InfoLevel, log.Fields{"Received Framework message from executor": executorID}, message) } func (s *BaseScheduler) LogMesosError(err string) { - lmt := elekLogT.ERROR + lmt := elekLogTypes.ERROR elektronLogging.ElektronLog.Log(lmt, log.ErrorLevel, log.Fields{"MESOS ERROR": fmt.Sprintf("%v", err)}, "") } func (s *BaseScheduler) LogElectronError(err error) { - lmt := elekLogT.ERROR + lmt := elekLogTypes.ERROR elektronLogging.ElektronLog.Log(lmt, log.ErrorLevel, log.Fields{"ELECTRON ERROR": fmt.Sprintf("%v", err)}, "") @@ -371,36 +371,36 @@ func (s *BaseScheduler) LogElectronError(err error) { func (s *BaseScheduler) LogFrameworkRegistered(frameworkID *mesos.FrameworkID, masterInfo *mesos.MasterInfo) { - lmt := elekLogT.SUCCESS + lmt := elekLogTypes.SUCCESS elektronLogging.ElektronLog.Log(lmt, log.InfoLevel, log.Fields{"frameworkID": fmt.Sprintf("%s", frameworkID), "master": fmt.Sprintf("%s", masterInfo)}, "FRAMEWORK REGISTERED!") } func (s *BaseScheduler) LogFrameworkReregistered(masterInfo *mesos.MasterInfo) { - lmt := elekLogT.GENERAL + lmt := elekLogTypes.GENERAL elektronLogging.ElektronLog.Log(lmt, log.InfoLevel, log.Fields{"master": fmt.Sprintf("%s", masterInfo)}, "Framework re-registered") } func (s *BaseScheduler) LogDisconnected() { - lmt := elekLogT.WARNING + lmt := elekLogTypes.WARNING elektronLogging.ElektronLog.Log(lmt, log.WarnLevel, log.Fields{}, "Framework disconnected with master") } func (s *BaseScheduler) LogTaskStatusUpdate(status *mesos.TaskStatus) { - lmt := elekLogT.GENERAL + lmt := elekLogTypes.GENERAL switch *status.State { case mesos.TaskState_TASK_ERROR, mesos.TaskState_TASK_FAILED, mesos.TaskState_TASK_KILLED, mesos.TaskState_TASK_LOST: - lmt = elekLogT.ERROR + lmt = elekLogTypes.ERROR case mesos.TaskState_TASK_FINISHED: - lmt = elekLogT.SUCCESS + lmt = elekLogTypes.SUCCESS default: - lmt = elekLogT.GENERAL + lmt = elekLogTypes.GENERAL } elektronLogging.ElektronLog.Log(lmt, log.InfoLevel, @@ -409,7 +409,7 @@ func (s *BaseScheduler) LogTaskStatusUpdate(status *mesos.TaskStatus) { func (s *BaseScheduler) LogSchedPolicySwitch(name string, nextPolicy SchedPolicyState) { logSPS := func() { - elektronLogging.ElektronLog.Log(elekLogT.SPS, + elektronLogging.ElektronLog.Log(elekLogTypes.SPS, log.InfoLevel, log.Fields{"Name": name}, "") } @@ -420,14 +420,14 @@ func (s *BaseScheduler) LogSchedPolicySwitch(name string, nextPolicy SchedPolicy } // Logging the size of the scheduling window and the scheduling policy // that is going to schedule the tasks in the scheduling window. - elektronLogging.ElektronLog.Log(elekLogT.SCHED_WINDOW, + elektronLogging.ElektronLog.Log(elekLogTypes.SCHED_WINDOW, log.InfoLevel, log.Fields{"Window size": fmt.Sprintf("%d", s.schedWindowSize), "Name": name}, "") } func (s *BaseScheduler) LogClsfnAndTaskDistOverhead(overhead time.Duration) { // Logging the overhead in microseconds. - elektronLogging.ElektronLog.Log(elekLogT.CLSFN_TASKDIST_OVERHEAD, + elektronLogging.ElektronLog.Log(elekLogTypes.CLSFN_TASKDIST_OVERHEAD, log.InfoLevel, log.Fields{"Overhead in microseconds": fmt.Sprintf("%f", float64(overhead.Nanoseconds())/1000.0)}, "") } diff --git a/schedulers/helpers.go b/schedulers/helpers.go index 59ada5d..8a2f532 100644 --- a/schedulers/helpers.go +++ b/schedulers/helpers.go @@ -27,7 +27,7 @@ import ( "github.com/spdfg/elektron/constants" "github.com/spdfg/elektron/def" "github.com/spdfg/elektron/elektronLogging" - elekLogT "github.com/spdfg/elektron/elektronLogging/types" + elekLogTypes "github.com/spdfg/elektron/elektronLogging/types" "github.com/spdfg/elektron/utilities" "github.com/spdfg/elektron/utilities/mesosUtils" ) @@ -35,12 +35,12 @@ import ( func coLocated(tasks map[string]bool, s BaseScheduler) { for task := range tasks { - elektronLogging.ElektronLog.Log(elekLogT.GENERAL, + elektronLogging.ElektronLog.Log(elekLogTypes.GENERAL, log.InfoLevel, log.Fields{"Task": task}, "") } - elektronLogging.ElektronLog.Log(elekLogT.GENERAL, + elektronLogging.ElektronLog.Log(elekLogTypes.GENERAL, log.InfoLevel, log.Fields{}, "---------------------") } diff --git a/schedulers/schedPolicy.go b/schedulers/schedPolicy.go index 36521b3..e4716d7 100644 --- a/schedulers/schedPolicy.go +++ b/schedulers/schedPolicy.go @@ -27,7 +27,7 @@ import ( log "github.com/sirupsen/logrus" "github.com/spdfg/elektron/def" "github.com/spdfg/elektron/elektronLogging" - elekLogT "github.com/spdfg/elektron/elektronLogging/types" + elekLogTypes "github.com/spdfg/elektron/elektronLogging/types" ) type SchedPolicyContext interface { @@ -90,7 +90,7 @@ func switchTaskDistBased(baseSchedRef *BaseScheduler) string { // Determine the distribution of tasks in the new scheduling window. taskDist, err := def.GetTaskDistributionInWindow(baseSchedRef.schedWindowSize, baseSchedRef.tasks) baseSchedRef.LogClsfnAndTaskDistOverhead(time.Now().Sub(startTime)) - elektronLogging.ElektronLog.Log(elekLogT.GENERAL, + elektronLogging.ElektronLog.Log(elekLogTypes.GENERAL, log.InfoLevel, log.Fields{"Task Distribution": fmt.Sprintf("%f", taskDist)}, "Switching... ") if err != nil { diff --git a/utilities/offerUtils/offerUtils.go b/utilities/offerUtils/offerUtils.go index 06a594c..a3062d8 100644 --- a/utilities/offerUtils/offerUtils.go +++ b/utilities/offerUtils/offerUtils.go @@ -24,7 +24,7 @@ import ( log "github.com/sirupsen/logrus" "github.com/spdfg/elektron/constants" "github.com/spdfg/elektron/elektronLogging" - elekLogT "github.com/spdfg/elektron/elektronLogging/types" + elekLogTypes "github.com/spdfg/elektron/elektronLogging/types" "strings" ) @@ -90,13 +90,13 @@ func UpdateEnvironment(offer *mesos.Offer) { var host = offer.GetHostname() // If this host is not present in the set of hosts. if _, ok := constants.Hosts[host]; !ok { - elektronLogging.ElektronLog.Log(elekLogT.GENERAL, log.InfoLevel, + elektronLogging.ElektronLog.Log(elekLogTypes.GENERAL, log.InfoLevel, log.Fields{"Adding host": fmt.Sprintf("%s", host)}, "New host detected") // Add this host. constants.Hosts[host] = struct{}{} // Get the power class of this host. class := PowerClass(offer) - elektronLogging.ElektronLog.Log(elekLogT.GENERAL, log.InfoLevel, + elektronLogging.ElektronLog.Log(elekLogTypes.GENERAL, log.InfoLevel, log.Fields{"host": fmt.Sprintf("%s", host), "PowerClass": fmt.Sprintf("%s", class)}, "Registering the power class...") // If new power class, register the power class. if _, ok := constants.PowerClasses[class]; !ok { diff --git a/utilities/schedUtils/schedUtils.go b/utilities/schedUtils/schedUtils.go index f90e9de..ffa3124 100644 --- a/utilities/schedUtils/schedUtils.go +++ b/utilities/schedUtils/schedUtils.go @@ -23,7 +23,7 @@ import ( log "github.com/sirupsen/logrus" "github.com/spdfg/elektron/def" "github.com/spdfg/elektron/elektronLogging" - elekLogT "github.com/spdfg/elektron/elektronLogging/types" + elekLogTypes "github.com/spdfg/elektron/elektronLogging/types" "github.com/spdfg/elektron/utilities" ) @@ -79,7 +79,7 @@ func (s *fillNextOfferCycle) apply(taskQueue []def.Task) (int, int) { for _, task := range taskQueue { numberOfTasksTraversed++ for i := *task.Instances; i > 0; i-- { - elektronLogging.ElektronLog.Log(elekLogT.GENERAL, log.InfoLevel, + elektronLogging.ElektronLog.Log(elekLogTypes.GENERAL, log.InfoLevel, log.Fields{}, fmt.Sprintf("Checking if Instance #%d of Task[%s] can be scheduled "+ "during the next offer cycle...", i, task.Name)) if canSchedule(task) { -- 2.47.2 From 7996240b2ebe7caca88bb3c57c824f37034737a7 Mon Sep 17 00:00:00 2001 From: balandi1 Date: Thu, 21 Nov 2019 13:47:22 -0500 Subject: [PATCH 10/48] Encapsulated log directory name into a struct --- .../clsfnTaskDistOverheadLogger.go | 5 +- elektronLogging/consoleLogger.go | 5 +- elektronLogging/createLogDir.go | 47 ++++++++++--------- elektronLogging/logger.go | 8 ++-- elektronLogging/pcpLogger.go | 5 +- elektronLogging/schedPolicySwitchLogger.go | 5 +- elektronLogging/schedTraceLogger.go | 5 +- elektronLogging/schedWindowLogger.go | 5 +- 8 files changed, 47 insertions(+), 38 deletions(-) diff --git a/elektronLogging/clsfnTaskDistOverheadLogger.go b/elektronLogging/clsfnTaskDistOverheadLogger.go index 9bae203..891a736 100644 --- a/elektronLogging/clsfnTaskDistOverheadLogger.go +++ b/elektronLogging/clsfnTaskDistOverheadLogger.go @@ -38,8 +38,9 @@ func (cLog *ClsfnTaskDistOverheadLogger) Log(logType int, level log.Level, logDa func (cLog *ClsfnTaskDistOverheadLogger) SetLogFile(prefix string) { tskDistLogPrefix := strings.Join([]string{prefix, config.TaskDistConfig.FilenameExtension}, "") - if logDir != "" { - tskDistLogPrefix = strings.Join([]string{logDir, tskDistLogPrefix}, "/") + dirName := logDir.getDirName() + if dirName != "" { + tskDistLogPrefix = strings.Join([]string{dirName, tskDistLogPrefix}, "/") } if logFile, err := os.Create(tskDistLogPrefix); err != nil { log.Fatal("Unable to create logFile: ", err) diff --git a/elektronLogging/consoleLogger.go b/elektronLogging/consoleLogger.go index 1c6b379..77e7d03 100644 --- a/elektronLogging/consoleLogger.go +++ b/elektronLogging/consoleLogger.go @@ -35,8 +35,9 @@ func (cLog *ConsoleLogger) Log(logType int, level log.Level, logData log.Fields, func (cLog *ConsoleLogger) SetLogFile(prefix string) { consoleLogPrefix := strings.Join([]string{prefix, config.ConsoleConfig.FilenameExtension}, "") - if logDir != "" { - consoleLogPrefix = strings.Join([]string{logDir, consoleLogPrefix}, "/") + dirName := logDir.getDirName() + if dirName != "" { + consoleLogPrefix = strings.Join([]string{dirName, consoleLogPrefix}, "/") } if logFile, err := os.Create(consoleLogPrefix); err != nil { log.Fatal("Unable to create logFile: ", err) diff --git a/elektronLogging/createLogDir.go b/elektronLogging/createLogDir.go index 8de5faa..006bdff 100644 --- a/elektronLogging/createLogDir.go +++ b/elektronLogging/createLogDir.go @@ -1,34 +1,37 @@ package elektronLogging import ( - logrus "github.com/sirupsen/logrus" + log "github.com/sirupsen/logrus" "os" "strconv" "strings" "time" ) -var logDir string - -func GetLogDir(startTime time.Time, prefix string) { - if logDir == "" { - logDir = createLogDir(prefix, startTime) - } +type logDirectory struct { + name string } -func createLogDir(prefix string, startTime time.Time) string { - - // Creating directory to store all logs for this run - logDirName := strings.Join([]string{"./", prefix, strconv.Itoa(startTime.Year())}, "") - logDirName = strings.Join([]string{logDirName, startTime.Month().String(), strconv.Itoa(startTime.Day())}, "-") - logDirName = strings.Join([]string{logDirName, strconv.Itoa(startTime.Hour())}, "_") - logDirName = strings.Join([]string{logDirName, strconv.Itoa(startTime.Minute()), strconv.Itoa(startTime.Second())}, "-") - - if _, err := os.Stat(logDirName); os.IsNotExist(err) { - os.Mkdir(logDirName, 0755) - } else { - logrus.Println("Unable to create log directory: ", err) - logDirName = "" - } - return logDirName +func (logD *logDirectory) getDirName() string { + return logD.name +} + +func (logD *logDirectory) createLogDir(prefix string, startTime time.Time) { + + if logD.name == "" { + // Creating directory to store all logs for this run + logDirName := strings.Join([]string{"./", prefix, strconv.Itoa(startTime.Year())}, "") + logDirName = strings.Join([]string{logDirName, startTime.Month().String(), strconv.Itoa(startTime.Day())}, "-") + logDirName = strings.Join([]string{logDirName, strconv.Itoa(startTime.Hour())}, "_") + logDirName = strings.Join([]string{logDirName, strconv.Itoa(startTime.Minute()), strconv.Itoa(startTime.Second())}, "-") + + if _, err := os.Stat(logDirName); os.IsNotExist(err) { + os.Mkdir(logDirName, 0755) + } else { + log.Println("Unable to create log directory: ", err) + logDirName = "" + } + + logD.name = logDirName + } } diff --git a/elektronLogging/logger.go b/elektronLogging/logger.go index 1a275f5..c2ad4a5 100644 --- a/elektronLogging/logger.go +++ b/elektronLogging/logger.go @@ -12,6 +12,7 @@ var config LoggerConfig var logger *log.Logger var formatter ElektronFormatter var ElektronLog *LoggerImpl +var logDir logDirectory func BuildLogger(prefix string) { @@ -22,10 +23,9 @@ func BuildLogger(prefix string) { startTime := time.Now() formatter.TimestampFormat = "2006-01-02 15:04:05" formattedStartTime := startTime.Format("20060102150405") - GetLogDir(startTime, "_") - - prefix = strings.Join([]string{prefix, formattedStartTime}, "_") - + + logDir.createLogDir(prefix, startTime) + prefix = strings.Join([]string{prefix, formattedStartTime}, "_") logger = &log.Logger{ Out: os.Stderr, Level: log.DebugLevel, diff --git a/elektronLogging/pcpLogger.go b/elektronLogging/pcpLogger.go index d7d12ae..dd11077 100644 --- a/elektronLogging/pcpLogger.go +++ b/elektronLogging/pcpLogger.go @@ -38,8 +38,9 @@ func (pLog *PcpLogger) Log(logType int, level log.Level, logData log.Fields, mes func (plog *PcpLogger) SetLogFile(prefix string) { pcpLogPrefix := strings.Join([]string{prefix, config.PCPConfig.FilenameExtension}, "") - if logDir != "" { - pcpLogPrefix = strings.Join([]string{logDir, pcpLogPrefix}, "/") + dirName := logDir.getDirName() + if dirName != "" { + pcpLogPrefix = strings.Join([]string{dirName, pcpLogPrefix}, "/") } if logFile, err := os.Create(pcpLogPrefix); err != nil { log.Fatal("Unable to create logFile: ", err) diff --git a/elektronLogging/schedPolicySwitchLogger.go b/elektronLogging/schedPolicySwitchLogger.go index 6417bd3..79daffb 100644 --- a/elektronLogging/schedPolicySwitchLogger.go +++ b/elektronLogging/schedPolicySwitchLogger.go @@ -38,8 +38,9 @@ func (sLog *SchedPolicySwitchLogger) Log(logType int, level log.Level, logData l func (sLog *SchedPolicySwitchLogger) SetLogFile(prefix string) { spsLogPrefix := strings.Join([]string{prefix, config.SPSConfig.FilenameExtension}, "") - if logDir != "" { - spsLogPrefix = strings.Join([]string{logDir, spsLogPrefix}, "/") + dirName := logDir.getDirName() + if dirName != "" { + spsLogPrefix = strings.Join([]string{dirName, spsLogPrefix}, "/") } if logFile, err := os.Create(spsLogPrefix); err != nil { log.Fatal("Unable to create logFile: ", err) diff --git a/elektronLogging/schedTraceLogger.go b/elektronLogging/schedTraceLogger.go index 59b65bf..59f4935 100644 --- a/elektronLogging/schedTraceLogger.go +++ b/elektronLogging/schedTraceLogger.go @@ -38,8 +38,9 @@ func (sLog *SchedTraceLogger) Log(logType int, level log.Level, logData log.Fiel func (sLog *SchedTraceLogger) SetLogFile(prefix string) { schedTraceLogPrefix := strings.Join([]string{prefix, config.SchedTraceConfig.FilenameExtension}, "") - if logDir != "" { - schedTraceLogPrefix = strings.Join([]string{logDir, schedTraceLogPrefix}, "/") + dirName := logDir.getDirName() + if dirName != "" { + schedTraceLogPrefix = strings.Join([]string{dirName, schedTraceLogPrefix}, "/") } if logFile, err := os.Create(schedTraceLogPrefix); err != nil { log.Fatal("Unable to create logFile: ", err) diff --git a/elektronLogging/schedWindowLogger.go b/elektronLogging/schedWindowLogger.go index e9e83ad..4e296b5 100644 --- a/elektronLogging/schedWindowLogger.go +++ b/elektronLogging/schedWindowLogger.go @@ -38,8 +38,9 @@ func (sLog *SchedWindowLogger) Log(logType int, level log.Level, logData log.Fie func (sLog *SchedWindowLogger) SetLogFile(prefix string) { schedWindowLogPrefix := strings.Join([]string{prefix, config.SchedWindowConfig.FilenameExtension}, "") - if logDir != "" { - schedWindowLogPrefix = strings.Join([]string{logDir, schedWindowLogPrefix}, "/") + dirName := logDir.getDirName() + if dirName != "" { + schedWindowLogPrefix = strings.Join([]string{dirName, schedWindowLogPrefix}, "/") } if logFile, err := os.Create(schedWindowLogPrefix); err != nil { log.Fatal("Unable to create logFile: ", err) -- 2.47.2 From 9952b9861d09ee04278ac8ec3d71564e74b74556 Mon Sep 17 00:00:00 2001 From: balandi1 Date: Thu, 21 Nov 2019 14:02:47 -0500 Subject: [PATCH 11/48] Renamed alias log to elekLog --- def/taskUtils.go | 10 +- elektronLogging/ElektronFormatter.go | 14 +-- .../clsfnTaskDistOverheadLogger.go | 8 +- elektronLogging/consoleLogger.go | 8 +- elektronLogging/createLogDir.go | 38 +++---- elektronLogging/logger.go | 14 +-- elektronLogging/loggerChain.go | 6 +- elektronLogging/loggerConfig.go | 6 +- elektronLogging/pcpLogger.go | 8 +- elektronLogging/schedPolicySwitchLogger.go | 8 +- elektronLogging/schedTraceLogger.go | 8 +- elektronLogging/schedWindowLogger.go | 8 +- pcp/pcp.go | 22 ++--- powerCap/extrema.go | 60 ++++++------ powerCap/progressiveExtrema.go | 94 +++++++++--------- scheduler.go | 34 +++---- schedulers/MaxGreedyMins.go | 8 +- schedulers/MaxMin.go | 6 +- schedulers/base.go | 98 +++++++++---------- schedulers/bin-packing.go | 6 +- schedulers/helpers.go | 14 +-- schedulers/schedPolicy.go | 14 +-- utilities/offerUtils/offerUtils.go | 10 +- utilities/schedUtils/schedUtils.go | 6 +- 24 files changed, 254 insertions(+), 254 deletions(-) diff --git a/def/taskUtils.go b/def/taskUtils.go index cb93afa..0e9c4ce 100644 --- a/def/taskUtils.go +++ b/def/taskUtils.go @@ -25,7 +25,7 @@ import ( "github.com/mash/gokmeans" "github.com/montanaflynn/stats" - log "github.com/sirupsen/logrus" + elekLog "github.com/sirupsen/logrus" "github.com/spdfg/elektron/elektronLogging" elekLogTypes "github.com/spdfg/elektron/elektronLogging/types" ) @@ -52,8 +52,8 @@ func (tc TasksToClassify) taskObservationCalculator(task Task) []float64 { } else if task.Watts != 0.0 { return []float64{task.Watts} } else { - elektronLogging.ElektronLog.Log(elekLogTypes.ERROR, log.FatalLevel, - log.Fields{}, "Unable to classify tasks. Missing Watts or ClassToWatts attribute in workload") + elektronLogging.ElektronLog.Log(elekLogTypes.ERROR, elekLog.FatalLevel, + elekLog.Fields{}, "Unable to classify tasks. Missing Watts or ClassToWatts attribute in workload") return []float64{0.0} // Won't reach here. } } @@ -108,8 +108,8 @@ func clusterSizeAvgMMMPU(tasks []Task, taskObservation func(task Task) []float64 } else { // skip this value // there is an error in the task config. - elektronLogging.ElektronLog.Log(elekLogTypes.ERROR, log.ErrorLevel, - log.Fields{}, fmt.Sprintf("%s", err)) + elektronLogging.ElektronLog.Log(elekLogTypes.ERROR, elekLog.ErrorLevel, + elekLog.Fields{}, fmt.Sprintf("%s", err)) } } else { // There is only one observation for the task. diff --git a/elektronLogging/ElektronFormatter.go b/elektronLogging/ElektronFormatter.go index c54fc6a..b3b347b 100644 --- a/elektronLogging/ElektronFormatter.go +++ b/elektronLogging/ElektronFormatter.go @@ -3,7 +3,7 @@ package elektronLogging import ( "bytes" "github.com/fatih/color" - log "github.com/sirupsen/logrus" + elekLog "github.com/sirupsen/logrus" "strings" ) @@ -11,21 +11,21 @@ type ElektronFormatter struct { TimestampFormat string } -func (f ElektronFormatter) getColor(entry *log.Entry) *color.Color { +func (f ElektronFormatter) getColor(entry *elekLog.Entry) *color.Color { switch entry.Level { - case log.InfoLevel: + case elekLog.InfoLevel: return color.New(color.FgGreen, color.Bold) - case log.WarnLevel: + case elekLog.WarnLevel: return color.New(color.FgYellow, color.Bold) - case log.ErrorLevel: + case elekLog.ErrorLevel: return color.New(color.FgRed, color.Bold) - case log.FatalLevel: + case elekLog.FatalLevel: return color.New(color.FgRed, color.Bold) default: return color.New(color.FgWhite, color.Bold) } } -func (f ElektronFormatter) Format(entry *log.Entry) ([]byte, error) { +func (f ElektronFormatter) Format(entry *elekLog.Entry) ([]byte, error) { var b *bytes.Buffer if entry.Buffer != nil { diff --git a/elektronLogging/clsfnTaskDistOverheadLogger.go b/elektronLogging/clsfnTaskDistOverheadLogger.go index 891a736..548df5b 100644 --- a/elektronLogging/clsfnTaskDistOverheadLogger.go +++ b/elektronLogging/clsfnTaskDistOverheadLogger.go @@ -1,7 +1,7 @@ package elektronLogging import ( - log "github.com/sirupsen/logrus" + elekLog "github.com/sirupsen/logrus" "os" "strings" ) @@ -17,7 +17,7 @@ func NewClsfnTaskDistOverheadLogger(logType int, prefix string) *ClsfnTaskDistOv return cLog } -func (cLog *ClsfnTaskDistOverheadLogger) Log(logType int, level log.Level, logData log.Fields, message string) { +func (cLog *ClsfnTaskDistOverheadLogger) Log(logType int, level elekLog.Level, logData elekLog.Fields, message string) { if cLog.Type == logType { logger.SetLevel(level) @@ -38,12 +38,12 @@ func (cLog *ClsfnTaskDistOverheadLogger) Log(logType int, level log.Level, logDa func (cLog *ClsfnTaskDistOverheadLogger) SetLogFile(prefix string) { tskDistLogPrefix := strings.Join([]string{prefix, config.TaskDistConfig.FilenameExtension}, "") - dirName := logDir.getDirName() + dirName := logDir.getDirName() if dirName != "" { tskDistLogPrefix = strings.Join([]string{dirName, tskDistLogPrefix}, "/") } if logFile, err := os.Create(tskDistLogPrefix); err != nil { - log.Fatal("Unable to create logFile: ", err) + elekLog.Fatal("Unable to create logFile: ", err) } else { cLog.LogFileName = logFile cLog.AllowOnConsole = config.TaskDistConfig.AllowOnConsole diff --git a/elektronLogging/consoleLogger.go b/elektronLogging/consoleLogger.go index 77e7d03..32f2274 100644 --- a/elektronLogging/consoleLogger.go +++ b/elektronLogging/consoleLogger.go @@ -1,7 +1,7 @@ package elektronLogging import ( - log "github.com/sirupsen/logrus" + elekLog "github.com/sirupsen/logrus" "os" "strings" ) @@ -16,7 +16,7 @@ func NewConsoleLogger(logType int, prefix string) *ConsoleLogger { cLog.SetLogFile(prefix) return cLog } -func (cLog *ConsoleLogger) Log(logType int, level log.Level, logData log.Fields, message string) { +func (cLog *ConsoleLogger) Log(logType int, level elekLog.Level, logData elekLog.Fields, message string) { if logType <= cLog.Type { logger.SetLevel(level) @@ -35,12 +35,12 @@ func (cLog *ConsoleLogger) Log(logType int, level log.Level, logData log.Fields, func (cLog *ConsoleLogger) SetLogFile(prefix string) { consoleLogPrefix := strings.Join([]string{prefix, config.ConsoleConfig.FilenameExtension}, "") - dirName := logDir.getDirName() + dirName := logDir.getDirName() if dirName != "" { consoleLogPrefix = strings.Join([]string{dirName, consoleLogPrefix}, "/") } if logFile, err := os.Create(consoleLogPrefix); err != nil { - log.Fatal("Unable to create logFile: ", err) + elekLog.Fatal("Unable to create logFile: ", err) } else { cLog.LogFileName = logFile cLog.AllowOnConsole = true diff --git a/elektronLogging/createLogDir.go b/elektronLogging/createLogDir.go index 006bdff..76774f3 100644 --- a/elektronLogging/createLogDir.go +++ b/elektronLogging/createLogDir.go @@ -1,7 +1,7 @@ package elektronLogging import ( - log "github.com/sirupsen/logrus" + elekLog "github.com/sirupsen/logrus" "os" "strconv" "strings" @@ -9,29 +9,29 @@ import ( ) type logDirectory struct { - name string + name string } func (logD *logDirectory) getDirName() string { - return logD.name + return logD.name } func (logD *logDirectory) createLogDir(prefix string, startTime time.Time) { - - if logD.name == "" { - // Creating directory to store all logs for this run - logDirName := strings.Join([]string{"./", prefix, strconv.Itoa(startTime.Year())}, "") - logDirName = strings.Join([]string{logDirName, startTime.Month().String(), strconv.Itoa(startTime.Day())}, "-") - logDirName = strings.Join([]string{logDirName, strconv.Itoa(startTime.Hour())}, "_") - logDirName = strings.Join([]string{logDirName, strconv.Itoa(startTime.Minute()), strconv.Itoa(startTime.Second())}, "-") - if _, err := os.Stat(logDirName); os.IsNotExist(err) { - os.Mkdir(logDirName, 0755) - } else { - log.Println("Unable to create log directory: ", err) - logDirName = "" - } - - logD.name = logDirName - } + if logD.name == "" { + // Creating directory to store all logs for this run + logDirName := strings.Join([]string{"./", prefix, strconv.Itoa(startTime.Year())}, "") + logDirName = strings.Join([]string{logDirName, startTime.Month().String(), strconv.Itoa(startTime.Day())}, "-") + logDirName = strings.Join([]string{logDirName, strconv.Itoa(startTime.Hour())}, "_") + logDirName = strings.Join([]string{logDirName, strconv.Itoa(startTime.Minute()), strconv.Itoa(startTime.Second())}, "-") + + if _, err := os.Stat(logDirName); os.IsNotExist(err) { + os.Mkdir(logDirName, 0755) + } else { + elekLog.Println("Unable to create elekLog directory: ", err) + logDirName = "" + } + + logD.name = logDirName + } } diff --git a/elektronLogging/logger.go b/elektronLogging/logger.go index c2ad4a5..74ba35c 100644 --- a/elektronLogging/logger.go +++ b/elektronLogging/logger.go @@ -1,7 +1,7 @@ package elektronLogging import ( - log "github.com/sirupsen/logrus" + elekLog "github.com/sirupsen/logrus" . "github.com/spdfg/elektron/elektronLogging/types" "os" "strings" @@ -9,7 +9,7 @@ import ( ) var config LoggerConfig -var logger *log.Logger +var logger *elekLog.Logger var formatter ElektronFormatter var ElektronLog *LoggerImpl var logDir logDirectory @@ -19,16 +19,16 @@ func BuildLogger(prefix string) { // read configuration from yaml config.GetConfig() - // create the log directory + // create the elekLog directory startTime := time.Now() formatter.TimestampFormat = "2006-01-02 15:04:05" formattedStartTime := startTime.Format("20060102150405") - + logDir.createLogDir(prefix, startTime) - prefix = strings.Join([]string{prefix, formattedStartTime}, "_") - logger = &log.Logger{ + prefix = strings.Join([]string{prefix, formattedStartTime}, "_") + logger = &elekLog.Logger{ Out: os.Stderr, - Level: log.DebugLevel, + Level: elekLog.DebugLevel, Formatter: &formatter, } diff --git a/elektronLogging/loggerChain.go b/elektronLogging/loggerChain.go index 8a8207a..996757b 100644 --- a/elektronLogging/loggerChain.go +++ b/elektronLogging/loggerChain.go @@ -1,13 +1,13 @@ package elektronLogging import ( - log "github.com/sirupsen/logrus" + elekLog "github.com/sirupsen/logrus" "os" ) type Logger interface { SetNext(logType Logger) - Log(logType int, level log.Level, logData log.Fields, message string) + Log(logType int, level elekLog.Level, logData elekLog.Fields, message string) SetLogFile(prefix string) } type LoggerImpl struct { @@ -21,7 +21,7 @@ func (l *LoggerImpl) SetNext(logType Logger) { l.next = logType } -func (l *LoggerImpl) Log(logType int, level log.Level, logData log.Fields, message string) { +func (l *LoggerImpl) Log(logType int, level elekLog.Level, logData elekLog.Fields, message string) { if l.next != nil { l.next.Log(logType, level, logData, message) } diff --git a/elektronLogging/loggerConfig.go b/elektronLogging/loggerConfig.go index 790669e..4aae8c9 100644 --- a/elektronLogging/loggerConfig.go +++ b/elektronLogging/loggerConfig.go @@ -1,7 +1,7 @@ package elektronLogging import ( - log "github.com/sirupsen/logrus" + elekLog "github.com/sirupsen/logrus" elekEnv "github.com/spdfg/elektron/environment" "gopkg.in/yaml.v2" "io/ioutil" @@ -57,11 +57,11 @@ func (c *LoggerConfig) GetConfig() *LoggerConfig { yamlFile, err := ioutil.ReadFile(elekEnv.LogConfigYaml) if err != nil { - log.Printf("yamlFile.Get err #%v ", err) + elekLog.Printf("yamlFile.Get err #%v ", err) } err = yaml.Unmarshal(yamlFile, c) if err != nil { - log.Fatalf("Unmarshal: %v", err) + elekLog.Fatalf("Unmarshal: %v", err) } return c diff --git a/elektronLogging/pcpLogger.go b/elektronLogging/pcpLogger.go index dd11077..a70cb1b 100644 --- a/elektronLogging/pcpLogger.go +++ b/elektronLogging/pcpLogger.go @@ -1,7 +1,7 @@ package elektronLogging import ( - log "github.com/sirupsen/logrus" + elekLog "github.com/sirupsen/logrus" "os" "strings" ) @@ -17,7 +17,7 @@ func NewPcpLogger(logType int, prefix string) *PcpLogger { return pLog } -func (pLog *PcpLogger) Log(logType int, level log.Level, logData log.Fields, message string) { +func (pLog *PcpLogger) Log(logType int, level elekLog.Level, logData elekLog.Fields, message string) { if pLog.Type == logType { logger.SetLevel(level) @@ -38,12 +38,12 @@ func (pLog *PcpLogger) Log(logType int, level log.Level, logData log.Fields, mes func (plog *PcpLogger) SetLogFile(prefix string) { pcpLogPrefix := strings.Join([]string{prefix, config.PCPConfig.FilenameExtension}, "") - dirName := logDir.getDirName() + dirName := logDir.getDirName() if dirName != "" { pcpLogPrefix = strings.Join([]string{dirName, pcpLogPrefix}, "/") } if logFile, err := os.Create(pcpLogPrefix); err != nil { - log.Fatal("Unable to create logFile: ", err) + elekLog.Fatal("Unable to create logFile: ", err) } else { plog.LogFileName = logFile plog.AllowOnConsole = config.PCPConfig.AllowOnConsole diff --git a/elektronLogging/schedPolicySwitchLogger.go b/elektronLogging/schedPolicySwitchLogger.go index 79daffb..0df54ac 100644 --- a/elektronLogging/schedPolicySwitchLogger.go +++ b/elektronLogging/schedPolicySwitchLogger.go @@ -1,7 +1,7 @@ package elektronLogging import ( - log "github.com/sirupsen/logrus" + elekLog "github.com/sirupsen/logrus" "os" "strings" ) @@ -17,7 +17,7 @@ func NewSchedPolicySwitchLogger(logType int, prefix string) *SchedPolicySwitchLo return sLog } -func (sLog *SchedPolicySwitchLogger) Log(logType int, level log.Level, logData log.Fields, message string) { +func (sLog *SchedPolicySwitchLogger) Log(logType int, level elekLog.Level, logData elekLog.Fields, message string) { if sLog.Type == logType { logger.SetLevel(level) @@ -38,12 +38,12 @@ func (sLog *SchedPolicySwitchLogger) Log(logType int, level log.Level, logData l func (sLog *SchedPolicySwitchLogger) SetLogFile(prefix string) { spsLogPrefix := strings.Join([]string{prefix, config.SPSConfig.FilenameExtension}, "") - dirName := logDir.getDirName() + dirName := logDir.getDirName() if dirName != "" { spsLogPrefix = strings.Join([]string{dirName, spsLogPrefix}, "/") } if logFile, err := os.Create(spsLogPrefix); err != nil { - log.Fatal("Unable to create logFile: ", err) + elekLog.Fatal("Unable to create logFile: ", err) } else { sLog.LogFileName = logFile sLog.AllowOnConsole = config.SPSConfig.AllowOnConsole diff --git a/elektronLogging/schedTraceLogger.go b/elektronLogging/schedTraceLogger.go index 59f4935..8686ff8 100644 --- a/elektronLogging/schedTraceLogger.go +++ b/elektronLogging/schedTraceLogger.go @@ -1,7 +1,7 @@ package elektronLogging import ( - log "github.com/sirupsen/logrus" + elekLog "github.com/sirupsen/logrus" "os" "strings" ) @@ -17,7 +17,7 @@ func NewSchedTraceLogger(logType int, prefix string) *SchedTraceLogger { return sLog } -func (sLog *SchedTraceLogger) Log(logType int, level log.Level, logData log.Fields, message string) { +func (sLog *SchedTraceLogger) Log(logType int, level elekLog.Level, logData elekLog.Fields, message string) { if sLog.Type == logType { logger.SetLevel(level) @@ -38,12 +38,12 @@ func (sLog *SchedTraceLogger) Log(logType int, level log.Level, logData log.Fiel func (sLog *SchedTraceLogger) SetLogFile(prefix string) { schedTraceLogPrefix := strings.Join([]string{prefix, config.SchedTraceConfig.FilenameExtension}, "") - dirName := logDir.getDirName() + dirName := logDir.getDirName() if dirName != "" { schedTraceLogPrefix = strings.Join([]string{dirName, schedTraceLogPrefix}, "/") } if logFile, err := os.Create(schedTraceLogPrefix); err != nil { - log.Fatal("Unable to create logFile: ", err) + elekLog.Fatal("Unable to create logFile: ", err) } else { sLog.LogFileName = logFile sLog.AllowOnConsole = config.SchedTraceConfig.AllowOnConsole diff --git a/elektronLogging/schedWindowLogger.go b/elektronLogging/schedWindowLogger.go index 4e296b5..69b3480 100644 --- a/elektronLogging/schedWindowLogger.go +++ b/elektronLogging/schedWindowLogger.go @@ -1,7 +1,7 @@ package elektronLogging import ( - log "github.com/sirupsen/logrus" + elekLog "github.com/sirupsen/logrus" "os" "strings" ) @@ -17,7 +17,7 @@ func NewSchedWindowLogger(logType int, prefix string) *SchedWindowLogger { return sLog } -func (sLog *SchedWindowLogger) Log(logType int, level log.Level, logData log.Fields, message string) { +func (sLog *SchedWindowLogger) Log(logType int, level elekLog.Level, logData elekLog.Fields, message string) { if sLog.Type == logType { logger.SetLevel(level) @@ -38,12 +38,12 @@ func (sLog *SchedWindowLogger) Log(logType int, level log.Level, logData log.Fie func (sLog *SchedWindowLogger) SetLogFile(prefix string) { schedWindowLogPrefix := strings.Join([]string{prefix, config.SchedWindowConfig.FilenameExtension}, "") - dirName := logDir.getDirName() + dirName := logDir.getDirName() if dirName != "" { schedWindowLogPrefix = strings.Join([]string{dirName, schedWindowLogPrefix}, "/") } if logFile, err := os.Create(schedWindowLogPrefix); err != nil { - log.Fatal("Unable to create logFile: ", err) + elekLog.Fatal("Unable to create logFile: ", err) } else { sLog.LogFileName = logFile sLog.AllowOnConsole = config.SchedWindowConfig.AllowOnConsole diff --git a/pcp/pcp.go b/pcp/pcp.go index f1ff505..ad9d6c9 100644 --- a/pcp/pcp.go +++ b/pcp/pcp.go @@ -24,7 +24,7 @@ import ( "syscall" "time" - log "github.com/sirupsen/logrus" + elekLog "github.com/sirupsen/logrus" "github.com/spdfg/elektron/elektronLogging" elekLogT "github.com/spdfg/elektron/elektronLogging/types" ) @@ -36,7 +36,7 @@ func Start(quit chan struct{}, logging *bool, pcpConfigFile string) { pipe, err := cmd.StdoutPipe() if err != nil { - log.Fatal(err) + elekLog.Fatal(err) } //cmd.Stdout = stdout @@ -48,8 +48,8 @@ func Start(quit chan struct{}, logging *bool, pcpConfigFile string) { // Write to logfile elektronLogging.ElektronLog.Log(elekLogT.PCP, - log.InfoLevel, - log.Fields{}, scanner.Text()) + elekLog.InfoLevel, + elekLog.Fields{}, scanner.Text()) // Throw away first set of results scanner.Scan() @@ -61,8 +61,8 @@ func Start(quit chan struct{}, logging *bool, pcpConfigFile string) { if *logging { elektronLogging.ElektronLog.Log(elekLogT.PCP, - log.InfoLevel, - log.Fields{}, text) + elekLog.InfoLevel, + elekLog.Fields{}, text) } seconds++ @@ -70,11 +70,11 @@ func Start(quit chan struct{}, logging *bool, pcpConfigFile string) { }(logging) elektronLogging.ElektronLog.Log(elekLogT.GENERAL, - log.InfoLevel, - log.Fields{}, "PCP logging started") + elekLog.InfoLevel, + elekLog.Fields{}, "PCP logging started") if err := cmd.Start(); err != nil { - log.Fatal(err) + elekLog.Fatal(err) } pgid, err := syscall.Getpgid(cmd.Process.Pid) @@ -82,8 +82,8 @@ func Start(quit chan struct{}, logging *bool, pcpConfigFile string) { select { case <-quit: elektronLogging.ElektronLog.Log(elekLogT.GENERAL, - log.InfoLevel, - log.Fields{}, "Stopping PCP logging in 5 seconds") + elekLog.InfoLevel, + elekLog.Fields{}, "Stopping PCP logging in 5 seconds") time.Sleep(5 * time.Second) // http://stackoverflow.com/questions/22470193/why-wont-go-kill-a-child-process-correctly diff --git a/powerCap/extrema.go b/powerCap/extrema.go index 83e76b4..be2a8ba 100644 --- a/powerCap/extrema.go +++ b/powerCap/extrema.go @@ -29,7 +29,7 @@ import ( "syscall" "time" - log "github.com/sirupsen/logrus" + elekLog "github.com/sirupsen/logrus" "github.com/spdfg/elektron/elektronLogging" elekLogTypes "github.com/spdfg/elektron/elektronLogging/types" "github.com/spdfg/elektron/pcp" @@ -44,13 +44,13 @@ func StartPCPLogAndExtremaDynamicCap(quit chan struct{}, logging *bool, hiThresh if hiThreshold < loThreshold { elektronLogging.ElektronLog.Log(elekLogTypes.GENERAL, - log.InfoLevel, - log.Fields{}, "High threshold is lower than low threshold!") + elekLog.InfoLevel, + elekLog.Fields{}, "High threshold is lower than low threshold!") } pipe, err := cmd.StdoutPipe() if err != nil { - log.Fatal(err) + elekLog.Fatal(err) } //cmd.Stdout = stdout @@ -62,8 +62,8 @@ func StartPCPLogAndExtremaDynamicCap(quit chan struct{}, logging *bool, hiThresh // Write to logfile elektronLogging.ElektronLog.Log(elekLogTypes.PCP, - log.InfoLevel, - log.Fields{}, scanner.Text()) + elekLog.InfoLevel, + elekLog.Fields{}, scanner.Text()) headers := strings.Split(scanner.Text(), ",") @@ -100,15 +100,15 @@ func StartPCPLogAndExtremaDynamicCap(quit chan struct{}, logging *bool, hiThresh if *logging { elektronLogging.ElektronLog.Log(elekLogTypes.GENERAL, - log.InfoLevel, - log.Fields{}, "Logging PCP...") + elekLog.InfoLevel, + elekLog.Fields{}, "Logging PCP...") text := scanner.Text() split := strings.Split(text, ",") elektronLogging.ElektronLog.Log(elekLogTypes.PCP, - log.InfoLevel, - log.Fields{}, text) + elekLog.InfoLevel, + elekLog.Fields{}, text) totalPower := 0.0 for _, powerIndex := range powerIndexes { @@ -120,8 +120,8 @@ func StartPCPLogAndExtremaDynamicCap(quit chan struct{}, logging *bool, hiThresh powerHistories[host] = powerHistories[host].Next() elektronLogging.ElektronLog.Log(elekLogTypes.GENERAL, - log.InfoLevel, - log.Fields{"Host": fmt.Sprintf("%s", indexToHost[powerIndex]), "Power": fmt.Sprintf("%f", (power * pcp.RAPLUnits))}, + elekLog.InfoLevel, + elekLog.Fields{"Host": fmt.Sprintf("%s", indexToHost[powerIndex]), "Power": fmt.Sprintf("%f", (power * pcp.RAPLUnits))}, "") totalPower += power @@ -134,15 +134,15 @@ func StartPCPLogAndExtremaDynamicCap(quit chan struct{}, logging *bool, hiThresh clusterMean := pcp.AverageClusterPowerHistory(clusterPowerHist) elektronLogging.ElektronLog.Log(elekLogTypes.GENERAL, - log.InfoLevel, - log.Fields{"Total power": fmt.Sprintf("%f %d", clusterPower, clusterPowerHist.Len()), + elekLog.InfoLevel, + elekLog.Fields{"Total power": fmt.Sprintf("%f %d", clusterPower, clusterPowerHist.Len()), "Sec Avg": fmt.Sprintf("%f", clusterMean)}, "") if clusterMean > hiThreshold { elektronLogging.ElektronLog.Log(elekLogTypes.GENERAL, - log.InfoLevel, - log.Fields{}, "Need to cap a node") + elekLog.InfoLevel, + elekLog.Fields{}, "Need to cap a node") // Create statics for all victims and choose one to cap victims := make([]pcp.Victim, 0, 8) @@ -164,13 +164,13 @@ func StartPCPLogAndExtremaDynamicCap(quit chan struct{}, logging *bool, hiThresh cappedHosts[victim.Host] = true orderCapped = append(orderCapped, victim.Host) elektronLogging.ElektronLog.Log(elekLogTypes.GENERAL, - log.InfoLevel, - log.Fields{"Capping Victim": fmt.Sprintf("%s", victim.Host), + elekLog.InfoLevel, + elekLog.Fields{"Capping Victim": fmt.Sprintf("%s", victim.Host), "Avg. Wattage": fmt.Sprintf("%f", victim.Watts*pcp.RAPLUnits)}, "") if err := rapl.Cap(victim.Host, "rapl", 50); err != nil { elektronLogging.ElektronLog.Log(elekLogTypes.ERROR, - log.ErrorLevel, - log.Fields{}, "Error capping host") + elekLog.ErrorLevel, + elekLog.Fields{}, "Error capping host") } break // Only cap one machine at at time. } @@ -183,14 +183,14 @@ func StartPCPLogAndExtremaDynamicCap(quit chan struct{}, logging *bool, hiThresh orderCapped = orderCapped[:len(orderCapped)-1] cappedHosts[host] = false // User RAPL package to send uncap. - log.Printf("Uncapping host %s", host) + elekLog.Printf("Uncapping host %s", host) elektronLogging.ElektronLog.Log(elekLogTypes.GENERAL, - log.InfoLevel, - log.Fields{"Uncapped host": host}, "") + elekLog.InfoLevel, + elekLog.Fields{"Uncapped host": host}, "") if err := rapl.Cap(host, "rapl", 100); err != nil { elektronLogging.ElektronLog.Log(elekLogTypes.ERROR, - log.ErrorLevel, - log.Fields{}, "Error capping host") + elekLog.ErrorLevel, + elekLog.Fields{}, "Error capping host") } } } @@ -201,11 +201,11 @@ func StartPCPLogAndExtremaDynamicCap(quit chan struct{}, logging *bool, hiThresh }(logging, hiThreshold, loThreshold) elektronLogging.ElektronLog.Log(elekLogTypes.GENERAL, - log.InfoLevel, - log.Fields{}, "PCP logging started") + elekLog.InfoLevel, + elekLog.Fields{}, "PCP logging started") if err := cmd.Start(); err != nil { - log.Fatal(err) + elekLog.Fatal(err) } pgid, err := syscall.Getpgid(cmd.Process.Pid) @@ -213,8 +213,8 @@ func StartPCPLogAndExtremaDynamicCap(quit chan struct{}, logging *bool, hiThresh select { case <-quit: elektronLogging.ElektronLog.Log(elekLogTypes.GENERAL, - log.InfoLevel, - log.Fields{}, "Stopping PCP logging in 5 seconds") + elekLog.InfoLevel, + elekLog.Fields{}, "Stopping PCP logging in 5 seconds") time.Sleep(5 * time.Second) // http://stackoverflow.com/questions/22470193/why-wont-go-kill-a-child-process-correctly diff --git a/powerCap/progressiveExtrema.go b/powerCap/progressiveExtrema.go index 034376f..789a0ca 100644 --- a/powerCap/progressiveExtrema.go +++ b/powerCap/progressiveExtrema.go @@ -30,7 +30,7 @@ import ( "syscall" "time" - log "github.com/sirupsen/logrus" + elekLog "github.com/sirupsen/logrus" "github.com/spdfg/elektron/constants" "github.com/spdfg/elektron/elektronLogging" elekLogTypes "github.com/spdfg/elektron/elektronLogging/types" @@ -57,13 +57,13 @@ func StartPCPLogAndProgressiveExtremaCap(quit chan struct{}, logging *bool, hiTh if hiThreshold < loThreshold { elektronLogging.ElektronLog.Log(elekLogTypes.GENERAL, - log.InfoLevel, - log.Fields{}, "High threshold is lower than low threshold!") + elekLog.InfoLevel, + elekLog.Fields{}, "High threshold is lower than low threshold!") } pipe, err := cmd.StdoutPipe() if err != nil { - log.Fatal(err) + elekLog.Fatal(err) } //cmd.Stdout = stdout @@ -75,8 +75,8 @@ func StartPCPLogAndProgressiveExtremaCap(quit chan struct{}, logging *bool, hiTh // Write to logfile elektronLogging.ElektronLog.Log(elekLogTypes.PCP, - log.InfoLevel, - log.Fields{}, scanner.Text()) + elekLog.InfoLevel, + elekLog.Fields{}, scanner.Text()) headers := strings.Split(scanner.Text(), ",") @@ -116,14 +116,14 @@ func StartPCPLogAndProgressiveExtremaCap(quit chan struct{}, logging *bool, hiTh for scanner.Scan() { if *logging { elektronLogging.ElektronLog.Log(elekLogTypes.GENERAL, - log.InfoLevel, - log.Fields{}, "Logging PCP...") + elekLog.InfoLevel, + elekLog.Fields{}, "Logging PCP...") split := strings.Split(scanner.Text(), ",") text := scanner.Text() elektronLogging.ElektronLog.Log(elekLogTypes.PCP, - log.InfoLevel, - log.Fields{}, text) + elekLog.InfoLevel, + elekLog.Fields{}, text) totalPower := 0.0 for _, powerIndex := range powerIndexes { @@ -135,8 +135,8 @@ func StartPCPLogAndProgressiveExtremaCap(quit chan struct{}, logging *bool, hiTh powerHistories[host] = powerHistories[host].Next() elektronLogging.ElektronLog.Log(elekLogTypes.GENERAL, - log.InfoLevel, - log.Fields{"Host": fmt.Sprintf("%s", indexToHost[powerIndex]), "Power": fmt.Sprintf("%f", (power * pcp.RAPLUnits))}, + elekLog.InfoLevel, + elekLog.Fields{"Host": fmt.Sprintf("%s", indexToHost[powerIndex]), "Power": fmt.Sprintf("%f", (power * pcp.RAPLUnits))}, "") totalPower += power } @@ -148,23 +148,23 @@ func StartPCPLogAndProgressiveExtremaCap(quit chan struct{}, logging *bool, hiTh clusterMean := pcp.AverageClusterPowerHistory(clusterPowerHist) elektronLogging.ElektronLog.Log(elekLogTypes.GENERAL, - log.InfoLevel, - log.Fields{"Total power": fmt.Sprintf("%f %d", clusterPower, clusterPowerHist.Len()), + elekLog.InfoLevel, + elekLog.Fields{"Total power": fmt.Sprintf("%f %d", clusterPower, clusterPowerHist.Len()), "Sec Avg": fmt.Sprintf("%f", clusterMean)}, "") if clusterMean >= hiThreshold { elektronLogging.ElektronLog.Log(elekLogTypes.GENERAL, - log.InfoLevel, - log.Fields{}, "Need to cap a node") + elekLog.InfoLevel, + elekLog.Fields{}, "Need to cap a node") elektronLogging.ElektronLog.Log(elekLogTypes.GENERAL, - log.InfoLevel, - log.Fields{"Cap values of capped victims": fmt.Sprintf("%v", cappedVictims)}, "") + elekLog.InfoLevel, + elekLog.Fields{"Cap values of capped victims": fmt.Sprintf("%v", cappedVictims)}, "") elektronLogging.ElektronLog.Log(elekLogTypes.GENERAL, - log.InfoLevel, - log.Fields{"Cap values of victims to uncap": fmt.Sprintf("%v", orderCappedVictims)}, "") + elekLog.InfoLevel, + elekLog.Fields{"Cap values of victims to uncap": fmt.Sprintf("%v", orderCappedVictims)}, "") // Create statics for all victims and choose one to cap victims := make([]pcp.Victim, 0, 8) @@ -193,13 +193,13 @@ func StartPCPLogAndProgressiveExtremaCap(quit chan struct{}, logging *bool, hiTh if err := rapl.Cap(victims[i].Host, "rapl", 50.0); err != nil { elektronLogging.ElektronLog.Log(elekLogTypes.ERROR, - log.ErrorLevel, - log.Fields{"Error capping host": fmt.Sprintf("%s", victims[i].Host)}, "") + elekLog.ErrorLevel, + elekLog.Fields{"Error capping host": fmt.Sprintf("%s", victims[i].Host)}, "") } else { elektronLogging.ElektronLog.Log(elekLogTypes.GENERAL, - log.InfoLevel, - log.Fields{}, fmt.Sprintf("Capped host[%s] at %f", victims[i].Host, 50.0)) + elekLog.InfoLevel, + elekLog.Fields{}, fmt.Sprintf("Capped host[%s] at %f", victims[i].Host, 50.0)) // Keeping track of this victim and it's cap value cappedVictims[victims[i].Host] = 50.0 newVictimFound = true @@ -224,13 +224,13 @@ func StartPCPLogAndProgressiveExtremaCap(quit chan struct{}, logging *bool, hiTh if err := rapl.Cap(alreadyCappedHosts[i], "rapl", newCapValue); err != nil { elektronLogging.ElektronLog.Log(elekLogTypes.ERROR, - log.ErrorLevel, - log.Fields{"Error capping host": fmt.Sprintf("%s", alreadyCappedHosts[i])}, "") + elekLog.ErrorLevel, + elekLog.Fields{"Error capping host": fmt.Sprintf("%s", alreadyCappedHosts[i])}, "") } else { // Successful cap elektronLogging.ElektronLog.Log(elekLogTypes.GENERAL, - log.InfoLevel, - log.Fields{}, fmt.Sprintf("Capped host[%s] at %f", alreadyCappedHosts[i], newCapValue)) + elekLog.InfoLevel, + elekLog.Fields{}, fmt.Sprintf("Capped host[%s] at %f", alreadyCappedHosts[i], newCapValue)) // Checking whether this victim can be capped further if newCapValue <= constants.LowerCapLimit { // Deleting victim from cappedVictims. @@ -254,22 +254,22 @@ func StartPCPLogAndProgressiveExtremaCap(quit chan struct{}, logging *bool, hiTh } if !canCapAlreadyCappedVictim { elektronLogging.ElektronLog.Log(elekLogTypes.GENERAL, - log.InfoLevel, - log.Fields{}, "No Victim left to cap") + elekLog.InfoLevel, + elekLog.Fields{}, "No Victim left to cap") } } } else if clusterMean < loThreshold { elektronLogging.ElektronLog.Log(elekLogTypes.GENERAL, - log.InfoLevel, - log.Fields{}, "Need to uncap a node") + elekLog.InfoLevel, + elekLog.Fields{}, "Need to uncap a node") elektronLogging.ElektronLog.Log(elekLogTypes.GENERAL, - log.InfoLevel, - log.Fields{"Cap values of capped victims": fmt.Sprintf("%v", cappedVictims)}, "") + elekLog.InfoLevel, + elekLog.Fields{"Cap values of capped victims": fmt.Sprintf("%v", cappedVictims)}, "") elektronLogging.ElektronLog.Log(elekLogTypes.GENERAL, - log.InfoLevel, - log.Fields{"Cap values of victims to uncap": fmt.Sprintf("%v", orderCappedVictims)}, "") + elekLog.InfoLevel, + elekLog.Fields{"Cap values of victims to uncap": fmt.Sprintf("%v", orderCappedVictims)}, "") if len(orderCapped) > 0 { // We pick the host that is capped the most to uncap. orderCappedToSort := utilities.GetPairList(orderCappedVictims) @@ -281,13 +281,13 @@ func StartPCPLogAndProgressiveExtremaCap(quit chan struct{}, logging *bool, hiTh if err := rapl.Cap(hostToUncap, "rapl", newUncapValue); err != nil { elektronLogging.ElektronLog.Log(elekLogTypes.ERROR, - log.ErrorLevel, - log.Fields{"Error uncapping host": fmt.Sprintf("%s", hostToUncap)}, "") + elekLog.ErrorLevel, + elekLog.Fields{"Error uncapping host": fmt.Sprintf("%s", hostToUncap)}, "") } else { // Successful uncap elektronLogging.ElektronLog.Log(elekLogTypes.GENERAL, - log.InfoLevel, - log.Fields{}, fmt.Sprintf("Uncapped host[%s] to %f", hostToUncap, newUncapValue)) + elekLog.InfoLevel, + elekLog.Fields{}, fmt.Sprintf("Uncapped host[%s] to %f", hostToUncap, newUncapValue)) // Can we uncap this host further. If not, then we remove its entry from orderCapped if newUncapValue >= 100.0 { // can compare using == // Deleting entry from orderCapped @@ -309,8 +309,8 @@ func StartPCPLogAndProgressiveExtremaCap(quit chan struct{}, logging *bool, hiTh } } else { elektronLogging.ElektronLog.Log(elekLogTypes.GENERAL, - log.InfoLevel, - log.Fields{}, "No host staged for Uncapped") + elekLog.InfoLevel, + elekLog.Fields{}, "No host staged for Uncapped") } } } @@ -320,10 +320,10 @@ func StartPCPLogAndProgressiveExtremaCap(quit chan struct{}, logging *bool, hiTh }(logging, hiThreshold, loThreshold) elektronLogging.ElektronLog.Log(elekLogTypes.GENERAL, - log.InfoLevel, - log.Fields{}, "PCP logging started") + elekLog.InfoLevel, + elekLog.Fields{}, "PCP logging started") if err := cmd.Start(); err != nil { - log.Fatal(err) + elekLog.Fatal(err) } pgid, err := syscall.Getpgid(cmd.Process.Pid) @@ -331,8 +331,8 @@ func StartPCPLogAndProgressiveExtremaCap(quit chan struct{}, logging *bool, hiTh select { case <-quit: elektronLogging.ElektronLog.Log(elekLogTypes.GENERAL, - log.InfoLevel, - log.Fields{}, "Stopping PCP logging in 5 seconds") + elekLog.InfoLevel, + elekLog.Fields{}, "Stopping PCP logging in 5 seconds") time.Sleep(5 * time.Second) // http://stackoverflow.com/questions/22470193/why-wont-go-kill-a-child-process-correctly diff --git a/scheduler.go b/scheduler.go index a0d453d..6987e9a 100644 --- a/scheduler.go +++ b/scheduler.go @@ -24,7 +24,7 @@ import ( "github.com/golang/protobuf/proto" mesos "github.com/mesos/mesos-go/api/v0/mesosproto" sched "github.com/mesos/mesos-go/api/v0/scheduler" - log "github.com/sirupsen/logrus" + elekLog "github.com/sirupsen/logrus" "github.com/spdfg/elektron/def" "github.com/spdfg/elektron/elektronLogging" elekLogTypes "github.com/spdfg/elektron/elektronLogging/types" @@ -104,7 +104,7 @@ func main() { if *schedPolicyName != "first-fit" { if _, ok := schedulers.SchedPolicies[*schedPolicyName]; !ok { // invalid scheduling policy - log.Println("Invalid scheduling policy given. The possible scheduling policies are:") + elekLog.Println("Invalid scheduling policy given. The possible scheduling policies are:") listAllSchedulingPolicies() os.Exit(1) } @@ -130,7 +130,7 @@ func main() { if *enableSchedPolicySwitch { // Scheduling policy config file required. if spcf := *schedPolConfigFile; spcf == "" { - log.Fatal("Scheduling policy characteristics file not provided.") + elekLog.Fatal("Scheduling policy characteristics file not provided.") } else { // Initializing the characteristics of the scheduling policies. schedulers.InitSchedPolicyCharacteristics(spcf) @@ -148,7 +148,7 @@ func main() { // If CMW is disabled, then the Median of Medians Max Peak Power Usage value is used // as the watts value for each task. if *wattsAsAResource { - log.Println("WaaR enabled...") + elekLog.Println("WaaR enabled...") schedOptions = append(schedOptions, schedulers.WithWattsAsAResource(*wattsAsAResource)) schedOptions = append(schedOptions, schedulers.WithClassMapWatts(*classMapWatts)) } @@ -165,7 +165,7 @@ func main() { "prog-extrema": {}, } if _, ok := powercapValues[*powerCapPolicy]; !ok { - log.Fatal("Incorrect power-capping algorithm specified.") + elekLog.Fatal("Incorrect power-capping algorithm specified.") } else { // Indicating which power capping algorithm to use, if any. // The pcp-logging with/without power capping will be run after the @@ -185,7 +185,7 @@ func main() { // These values are not used to configure the scheduler. // hiThreshold and loThreshold are passed to the powercappers. if *hiThreshold < *loThreshold { - log.Fatal("High threshold is of a lower value than low " + + elekLog.Fatal("High threshold is of a lower value than low " + "threshold.") } } @@ -195,11 +195,11 @@ func main() { // Tasks // If httpServer is disabled, then path of file containing workload needs to be provided. if *tasksFile == "" { - log.Fatal("Tasks specifications file not provided.") + elekLog.Fatal("Tasks specifications file not provided.") } tasks, err := def.TasksFromJSON(*tasksFile) if err != nil || len(tasks) == 0 { - log.Fatal("Invalid tasks specification file provided.") + elekLog.Fatal("Invalid tasks specification file provided.") } schedOptions = append(schedOptions, schedulers.WithTasks(tasks)) @@ -216,12 +216,12 @@ func main() { Scheduler: scheduler, }) if err != nil { - log.Fatal(fmt.Sprintf("Unable to create scheduler driver: %s", err)) + elekLog.Fatal(fmt.Sprintf("Unable to create scheduler driver: %s", err)) } // Checking if prefix contains any special characters. if strings.Contains(*pcplogPrefix, "/") { - log.Fatal("log file prefix should not contain '/'.") + elekLog.Fatal("elekLog file prefix should not contain '/'.") } elektronLogging.BuildLogger(*pcplogPrefix) @@ -236,7 +236,7 @@ func main() { *loThreshold, *pcpConfigFile) } - // Take a second between starting PCP log and continuing. + // Take a second between starting PCP elekLog and continuing. time.Sleep(1 * time.Second) // Attempt to handle SIGINT to not leave pmdumptext running. @@ -250,7 +250,7 @@ func main() { return } - log.Println("Received SIGINT... stopping") + elekLog.Println("Received SIGINT... stopping") close(done) }() @@ -266,7 +266,7 @@ func main() { select { case <-done: close(pcpLog) - time.Sleep(5 * time.Second) //Wait for PCP to log a few more seconds + time.Sleep(5 * time.Second) //Wait for PCP to elekLog a few more seconds // Closing logging channels. //case <-time.After(shutdownTimeout): } @@ -279,10 +279,10 @@ func main() { // Starting the scheduler driver. if status, err := driver.Run(); err != nil { elektronLogging.ElektronLog.Log(elekLogTypes.ERROR, - log.ErrorLevel, - log.Fields{"status": status.String(), "error": err.Error()}, "Framework stopped ") + elekLog.ErrorLevel, + elekLog.Fields{"status": status.String(), "error": err.Error()}, "Framework stopped ") } elektronLogging.ElektronLog.Log(elekLogTypes.GENERAL, - log.InfoLevel, - log.Fields{}, "Exiting...") + elekLog.InfoLevel, + elekLog.Fields{}, "Exiting...") } diff --git a/schedulers/MaxGreedyMins.go b/schedulers/MaxGreedyMins.go index b4b250d..720882d 100644 --- a/schedulers/MaxGreedyMins.go +++ b/schedulers/MaxGreedyMins.go @@ -19,7 +19,7 @@ package schedulers import ( - log "github.com/sirupsen/logrus" + elekLog "github.com/sirupsen/logrus" mesos "github.com/mesos/mesos-go/api/v0/mesosproto" sched "github.com/mesos/mesos-go/api/v0/scheduler" @@ -39,7 +39,7 @@ func (s *MaxGreedyMins) takeOffer(spc SchedPolicyContext, offer *mesos.Offer, ta wattsConsideration, err := def.WattsToConsider(task, baseSchedRef.classMapWatts, offer) if err != nil { // Error in determining wattsConsideration - log.Fatal(err) + elekLog.Fatal(err) } if (cpus >= (totalCPU + task.CPU)) && (mem >= (totalRAM + task.RAM)) && (!baseSchedRef.wattsAsAResource || (watts >= (totalWatts + wattsConsideration))) { @@ -136,7 +136,7 @@ func (s *MaxGreedyMins) ConsumeOffers(spc SchedPolicyContext, driver sched.Sched wattsConsideration, err := def.WattsToConsider(task, baseSchedRef.classMapWatts, offer) if err != nil { // Error in determining wattsConsideration - log.Fatal(err) + elekLog.Fatal(err) } // Don't take offer if it doesn't match our task's host requirement @@ -161,7 +161,7 @@ func (s *MaxGreedyMins) ConsumeOffers(spc SchedPolicyContext, driver sched.Sched wattsConsideration, err := def.WattsToConsider(task, baseSchedRef.classMapWatts, offer) if err != nil { // Error in determining wattsConsideration - log.Fatal(err) + elekLog.Fatal(err) } // Don't take offer if it doesn't match our task's host requirement diff --git a/schedulers/MaxMin.go b/schedulers/MaxMin.go index a7ba29e..513359e 100644 --- a/schedulers/MaxMin.go +++ b/schedulers/MaxMin.go @@ -19,7 +19,7 @@ package schedulers import ( - log "github.com/sirupsen/logrus" + elekLog "github.com/sirupsen/logrus" mesos "github.com/mesos/mesos-go/api/v0/mesosproto" sched "github.com/mesos/mesos-go/api/v0/scheduler" @@ -39,7 +39,7 @@ func (s *MaxMin) takeOffer(spc SchedPolicyContext, offer *mesos.Offer, task def. wattsConsideration, err := def.WattsToConsider(task, baseSchedRef.classMapWatts, offer) if err != nil { // Error in determining wattsConsideration - log.Fatal(err) + elekLog.Fatal(err) } if (cpus >= (totalCPU + task.CPU)) && (mem >= (totalRAM + task.RAM)) && (!baseSchedRef.wattsAsAResource || (watts >= (totalWatts + wattsConsideration))) { @@ -148,7 +148,7 @@ func (s *MaxMin) ConsumeOffers(spc SchedPolicyContext, driver sched.SchedulerDri wattsConsideration, err := def.WattsToConsider(task, baseSchedRef.classMapWatts, offer) if err != nil { // Error in determining wattsConsideration. - log.Fatal(err) + elekLog.Fatal(err) } // Don't take offer if it doesn't match our task's host requirement. diff --git a/schedulers/base.go b/schedulers/base.go index decec5c..3a6d77d 100644 --- a/schedulers/base.go +++ b/schedulers/base.go @@ -28,7 +28,7 @@ import ( mesos "github.com/mesos/mesos-go/api/v0/mesosproto" "github.com/mesos/mesos-go/api/v0/mesosutil" sched "github.com/mesos/mesos-go/api/v0/scheduler" - log "github.com/sirupsen/logrus" + elekLog "github.com/sirupsen/logrus" "github.com/spdfg/elektron/def" "github.com/spdfg/elektron/elektronLogging" elekLogTypes "github.com/spdfg/elektron/elektronLogging/types" @@ -67,7 +67,7 @@ type BaseScheduler struct { // Controls when to shutdown pcp logging. PCPLog chan struct{} - schedTrace *log.Logger + schedTrace *elekLog.Logger mutex sync.Mutex @@ -102,7 +102,7 @@ func (s *BaseScheduler) init(opts ...SchedulerOptions) { for _, opt := range opts { // applying options if err := opt(s); err != nil { - log.Fatal(err) + elekLog.Fatal(err) } } s.TasksRunningMutex.Lock() @@ -251,12 +251,12 @@ func (s *BaseScheduler) StatusUpdate(driver sched.SchedulerDriver, status *mesos func (s *BaseScheduler) LogTaskStarting(ts *def.Task, offer *mesos.Offer) { lmt := elekLogTypes.GENERAL if ts == nil { - elektronLogging.ElektronLog.Log(lmt, log.InfoLevel, - log.Fields{"host": fmt.Sprintf("%s", offer.GetHostname())}, "TASKS STARTING...") + elektronLogging.ElektronLog.Log(lmt, elekLog.InfoLevel, + elekLog.Fields{"host": fmt.Sprintf("%s", offer.GetHostname())}, "TASKS STARTING...") } else { elektronLogging.ElektronLog.Log(lmt, - log.InfoLevel, - log.Fields{"task": fmt.Sprintf("%s", ts.Name), + elekLog.InfoLevel, + elekLog.Fields{"task": fmt.Sprintf("%s", ts.Name), "Instance": fmt.Sprintf("%d", *ts.Instances), "host": fmt.Sprintf("%s", offer.GetHostname())}, "TASK STARTING... ") } @@ -265,29 +265,29 @@ func (s *BaseScheduler) LogTaskStarting(ts *def.Task, offer *mesos.Offer) { func (s *BaseScheduler) LogTaskWattsConsideration(ts def.Task, host string, wattsToConsider float64) { lmt := elekLogTypes.GENERAL elektronLogging.ElektronLog.Log(lmt, - log.InfoLevel, - log.Fields{"task": ts.Name, "host": host, "Watts": fmt.Sprintf("%f", wattsToConsider)}, "Watts considered for ") + elekLog.InfoLevel, + elekLog.Fields{"task": ts.Name, "host": host, "Watts": fmt.Sprintf("%f", wattsToConsider)}, "Watts considered for ") } func (s *BaseScheduler) LogOffersReceived(offers []*mesos.Offer) { lmt := elekLogTypes.GENERAL elektronLogging.ElektronLog.Log(lmt, - log.InfoLevel, - log.Fields{"Resource offers received": fmt.Sprintf("%d", len(offers))}, "") + elekLog.InfoLevel, + elekLog.Fields{"Resource offers received": fmt.Sprintf("%d", len(offers))}, "") } func (s *BaseScheduler) LogNoPendingTasksDeclineOffers(offer *mesos.Offer) { lmt := elekLogTypes.WARNING elektronLogging.ElektronLog.Log(lmt, - log.WarnLevel, - log.Fields{"DECLINING OFFER for host": fmt.Sprintf("%s", offer.GetHostname())}, "No tasks left to schedule ") + elekLog.WarnLevel, + elekLog.Fields{"DECLINING OFFER for host": fmt.Sprintf("%s", offer.GetHostname())}, "No tasks left to schedule ") } func (s *BaseScheduler) LogNumberOfRunningTasks() { lmt := elekLogTypes.GENERAL elektronLogging.ElektronLog.Log(lmt, - log.InfoLevel, - log.Fields{"Number of tasks still Running": fmt.Sprintf("%d", s.tasksRunning)}, "") + elekLog.InfoLevel, + elekLog.Fields{"Number of tasks still Running": fmt.Sprintf("%d", s.tasksRunning)}, "") } func (s *BaseScheduler) LogCoLocatedTasks(slaveID string) { @@ -299,21 +299,21 @@ func (s *BaseScheduler) LogCoLocatedTasks(slaveID string) { } s.TasksRunningMutex.Unlock() elektronLogging.ElektronLog.Log(lmt, - log.InfoLevel, - log.Fields{"Colocated with": fmt.Sprintf("%s", buffer.String())}, "") + elekLog.InfoLevel, + elekLog.Fields{"Colocated with": fmt.Sprintf("%s", buffer.String())}, "") } func (s *BaseScheduler) LogSchedTrace(taskToSchedule *mesos.TaskInfo, offer *mesos.Offer) { elektronLogging.ElektronLog.Log(elekLogTypes.SCHED_TRACE, - log.InfoLevel, - log.Fields{offer.GetHostname(): fmt.Sprintf("%s", taskToSchedule.GetTaskId().GetValue())}, "") + elekLog.InfoLevel, + elekLog.Fields{offer.GetHostname(): fmt.Sprintf("%s", taskToSchedule.GetTaskId().GetValue())}, "") } func (s *BaseScheduler) LogTerminateScheduler() { lmt := elekLogTypes.GENERAL elektronLogging.ElektronLog.Log(lmt, - log.InfoLevel, - log.Fields{}, "Done scheduling all tasks!") + elekLog.InfoLevel, + elekLog.Fields{}, "Done scheduling all tasks!") } func (s *BaseScheduler) LogInsufficientResourcesDeclineOffer(offer *mesos.Offer, @@ -322,73 +322,73 @@ func (s *BaseScheduler) LogInsufficientResourcesDeclineOffer(offer *mesos.Offer, buffer := bytes.Buffer{} buffer.WriteString(fmt.Sprintf("", offerResources...)) elektronLogging.ElektronLog.Log(lmt, - log.WarnLevel, - log.Fields{"Offer Resources": fmt.Sprintf("%s", buffer.String())}, "DECLINING OFFER... Offer has insufficient resources to launch a task") + elekLog.WarnLevel, + elekLog.Fields{"Offer Resources": fmt.Sprintf("%s", buffer.String())}, "DECLINING OFFER... Offer has insufficient resources to launch a task") } func (s *BaseScheduler) LogOfferRescinded(offerID *mesos.OfferID) { lmt := elekLogTypes.ERROR elektronLogging.ElektronLog.Log(lmt, - log.ErrorLevel, - log.Fields{"OfferID": fmt.Sprintf("%s", offerID)}, "OFFER RESCINDED") + elekLog.ErrorLevel, + elekLog.Fields{"OfferID": fmt.Sprintf("%s", offerID)}, "OFFER RESCINDED") } func (s *BaseScheduler) LogSlaveLost(slaveID *mesos.SlaveID) { lmt := elekLogTypes.ERROR elektronLogging.ElektronLog.Log(lmt, - log.ErrorLevel, - log.Fields{"SlaveID": fmt.Sprintf("%s", slaveID)}, "SLAVE LOST") + elekLog.ErrorLevel, + elekLog.Fields{"SlaveID": fmt.Sprintf("%s", slaveID)}, "SLAVE LOST") } func (s *BaseScheduler) LogExecutorLost(executorID *mesos.ExecutorID, slaveID *mesos.SlaveID) { lmt := elekLogTypes.ERROR elektronLogging.ElektronLog.Log(lmt, - log.ErrorLevel, - log.Fields{"ExecutorID": fmt.Sprintf("%s", executorID), "SlaveID": fmt.Sprintf("%s", slaveID)}, "EXECUTOR LOST") + elekLog.ErrorLevel, + elekLog.Fields{"ExecutorID": fmt.Sprintf("%s", executorID), "SlaveID": fmt.Sprintf("%s", slaveID)}, "EXECUTOR LOST") } func (s *BaseScheduler) LogFrameworkMessage(executorID *mesos.ExecutorID, slaveID *mesos.SlaveID, message string) { lmt := elekLogTypes.GENERAL elektronLogging.ElektronLog.Log(lmt, - log.InfoLevel, - log.Fields{"Received Framework message from executor": executorID}, message) + elekLog.InfoLevel, + elekLog.Fields{"Received Framework message from executor": executorID}, message) } func (s *BaseScheduler) LogMesosError(err string) { lmt := elekLogTypes.ERROR elektronLogging.ElektronLog.Log(lmt, - log.ErrorLevel, - log.Fields{"MESOS ERROR": fmt.Sprintf("%v", err)}, "") + elekLog.ErrorLevel, + elekLog.Fields{"MESOS ERROR": fmt.Sprintf("%v", err)}, "") } func (s *BaseScheduler) LogElectronError(err error) { lmt := elekLogTypes.ERROR elektronLogging.ElektronLog.Log(lmt, - log.ErrorLevel, - log.Fields{"ELECTRON ERROR": fmt.Sprintf("%v", err)}, "") + elekLog.ErrorLevel, + elekLog.Fields{"ELECTRON ERROR": fmt.Sprintf("%v", err)}, "") } func (s *BaseScheduler) LogFrameworkRegistered(frameworkID *mesos.FrameworkID, masterInfo *mesos.MasterInfo) { lmt := elekLogTypes.SUCCESS elektronLogging.ElektronLog.Log(lmt, - log.InfoLevel, - log.Fields{"frameworkID": fmt.Sprintf("%s", frameworkID), "master": fmt.Sprintf("%s", masterInfo)}, "FRAMEWORK REGISTERED!") + elekLog.InfoLevel, + elekLog.Fields{"frameworkID": fmt.Sprintf("%s", frameworkID), "master": fmt.Sprintf("%s", masterInfo)}, "FRAMEWORK REGISTERED!") } func (s *BaseScheduler) LogFrameworkReregistered(masterInfo *mesos.MasterInfo) { lmt := elekLogTypes.GENERAL elektronLogging.ElektronLog.Log(lmt, - log.InfoLevel, - log.Fields{"master": fmt.Sprintf("%s", masterInfo)}, "Framework re-registered") + elekLog.InfoLevel, + elekLog.Fields{"master": fmt.Sprintf("%s", masterInfo)}, "Framework re-registered") } func (s *BaseScheduler) LogDisconnected() { lmt := elekLogTypes.WARNING elektronLogging.ElektronLog.Log(lmt, - log.WarnLevel, - log.Fields{}, "Framework disconnected with master") + elekLog.WarnLevel, + elekLog.Fields{}, "Framework disconnected with master") } func (s *BaseScheduler) LogTaskStatusUpdate(status *mesos.TaskStatus) { @@ -403,15 +403,15 @@ func (s *BaseScheduler) LogTaskStatusUpdate(status *mesos.TaskStatus) { lmt = elekLogTypes.GENERAL } elektronLogging.ElektronLog.Log(lmt, - log.InfoLevel, - log.Fields{"task": fmt.Sprintf("%s", *status.TaskId.Value), "state": NameFor(status.State)}, "Task Status received") + elekLog.InfoLevel, + elekLog.Fields{"task": fmt.Sprintf("%s", *status.TaskId.Value), "state": NameFor(status.State)}, "Task Status received") } func (s *BaseScheduler) LogSchedPolicySwitch(name string, nextPolicy SchedPolicyState) { logSPS := func() { elektronLogging.ElektronLog.Log(elekLogTypes.SPS, - log.InfoLevel, - log.Fields{"Name": name}, "") + elekLog.InfoLevel, + elekLog.Fields{"Name": name}, "") } if s.hasReceivedResourceOffers && (s.curSchedPolicy != nextPolicy) { logSPS() @@ -421,13 +421,13 @@ func (s *BaseScheduler) LogSchedPolicySwitch(name string, nextPolicy SchedPolicy // Logging the size of the scheduling window and the scheduling policy // that is going to schedule the tasks in the scheduling window. elektronLogging.ElektronLog.Log(elekLogTypes.SCHED_WINDOW, - log.InfoLevel, - log.Fields{"Window size": fmt.Sprintf("%d", s.schedWindowSize), "Name": name}, "") + elekLog.InfoLevel, + elekLog.Fields{"Window size": fmt.Sprintf("%d", s.schedWindowSize), "Name": name}, "") } func (s *BaseScheduler) LogClsfnAndTaskDistOverhead(overhead time.Duration) { // Logging the overhead in microseconds. elektronLogging.ElektronLog.Log(elekLogTypes.CLSFN_TASKDIST_OVERHEAD, - log.InfoLevel, - log.Fields{"Overhead in microseconds": fmt.Sprintf("%f", float64(overhead.Nanoseconds())/1000.0)}, "") + elekLog.InfoLevel, + elekLog.Fields{"Overhead in microseconds": fmt.Sprintf("%f", float64(overhead.Nanoseconds())/1000.0)}, "") } diff --git a/schedulers/bin-packing.go b/schedulers/bin-packing.go index aba4fbb..42729f5 100644 --- a/schedulers/bin-packing.go +++ b/schedulers/bin-packing.go @@ -19,7 +19,7 @@ package schedulers import ( - "log" + elekLog "github.com/sirupsen/logrus" mesos "github.com/mesos/mesos-go/api/v0/mesosproto" sched "github.com/mesos/mesos-go/api/v0/scheduler" @@ -39,7 +39,7 @@ func (s *BinPackSortedWatts) takeOffer(spc SchedPolicyContext, offer *mesos.Offe wattsConsideration, err := def.WattsToConsider(task, baseSchedRef.classMapWatts, offer) if err != nil { // Error in determining wattsConsideration. - log.Fatal(err) + elekLog.Fatal(err) } if (cpus >= (totalCPU + task.CPU)) && (mem >= (totalRAM + task.RAM)) && (!baseSchedRef.wattsAsAResource || (watts >= (totalWatts + wattsConsideration))) { @@ -83,7 +83,7 @@ func (s *BinPackSortedWatts) ConsumeOffers(spc SchedPolicyContext, driver sched. wattsConsideration, err := def.WattsToConsider(task, baseSchedRef.classMapWatts, offer) if err != nil { // Error in determining wattsConsideration. - log.Fatal(err) + elekLog.Fatal(err) } // Don't take offer if it doesn't match our task's host requirement. diff --git a/schedulers/helpers.go b/schedulers/helpers.go index 8a2f532..39317f1 100644 --- a/schedulers/helpers.go +++ b/schedulers/helpers.go @@ -23,7 +23,7 @@ import ( mesos "github.com/mesos/mesos-go/api/v0/mesosproto" sched "github.com/mesos/mesos-go/api/v0/scheduler" "github.com/pkg/errors" - log "github.com/sirupsen/logrus" + elekLog "github.com/sirupsen/logrus" "github.com/spdfg/elektron/constants" "github.com/spdfg/elektron/def" "github.com/spdfg/elektron/elektronLogging" @@ -36,13 +36,13 @@ func coLocated(tasks map[string]bool, s BaseScheduler) { for task := range tasks { elektronLogging.ElektronLog.Log(elekLogTypes.GENERAL, - log.InfoLevel, - log.Fields{"Task": task}, "") + elekLog.InfoLevel, + elekLog.Fields{"Task": task}, "") } elektronLogging.ElektronLog.Log(elekLogTypes.GENERAL, - log.InfoLevel, - log.Fields{}, "---------------------") + elekLog.InfoLevel, + elekLog.Fields{}, "---------------------") } // Get the powerClass of the given hostname. @@ -157,7 +157,7 @@ func WithSchedPolSwitchEnabled(enableSchedPolicySwitch bool, switchingCriteria s func WithNameOfFirstSchedPolToFix(nameOfFirstSchedPol string) SchedulerOptions { return func(s ElectronScheduler) error { if nameOfFirstSchedPol == "" { - log.Println("First scheduling policy to deploy not mentioned. This is now" + + elekLog.Println("First scheduling policy to deploy not mentioned. This is now" + " going to be determined at runtime.") return nil } @@ -175,7 +175,7 @@ func WithFixedSchedulingWindow(toFixSchedWindow bool, fixedSchedWindowSize int) if fixedSchedWindowSize <= 0 { return errors.New("Invalid value of scheduling window size. Please provide a value > 0.") } - log.Println(fmt.Sprintf("Fixing the size of the scheduling window to %d.."+ + elekLog.Println(fmt.Sprintf("Fixing the size of the scheduling window to %d.."+ ".", fixedSchedWindowSize)) s.(*BaseScheduler).toFixSchedWindow = toFixSchedWindow s.(*BaseScheduler).schedWindowSize = fixedSchedWindowSize diff --git a/schedulers/schedPolicy.go b/schedulers/schedPolicy.go index e4716d7..c477ba7 100644 --- a/schedulers/schedPolicy.go +++ b/schedulers/schedPolicy.go @@ -24,7 +24,7 @@ import ( mesos "github.com/mesos/mesos-go/api/v0/mesosproto" sched "github.com/mesos/mesos-go/api/v0/scheduler" - log "github.com/sirupsen/logrus" + elekLog "github.com/sirupsen/logrus" "github.com/spdfg/elektron/def" "github.com/spdfg/elektron/elektronLogging" elekLogTypes "github.com/spdfg/elektron/elektronLogging/types" @@ -91,8 +91,8 @@ func switchTaskDistBased(baseSchedRef *BaseScheduler) string { taskDist, err := def.GetTaskDistributionInWindow(baseSchedRef.schedWindowSize, baseSchedRef.tasks) baseSchedRef.LogClsfnAndTaskDistOverhead(time.Now().Sub(startTime)) elektronLogging.ElektronLog.Log(elekLogTypes.GENERAL, - log.InfoLevel, - log.Fields{"Task Distribution": fmt.Sprintf("%f", taskDist)}, "Switching... ") + elekLog.InfoLevel, + elekLog.Fields{"Task Distribution": fmt.Sprintf("%f", taskDist)}, "Switching... ") if err != nil { // All the tasks in the window were only classified into 1 cluster. // Max-Min and Max-GreedyMins would work the same way as Bin-Packing for this situation. @@ -220,8 +220,8 @@ func (bsps *baseSchedPolicyState) SwitchIfNecessary(spc SchedPolicyContext) { switchToPolicyName = switchBasedOn[baseSchedRef.schedPolSwitchCriteria](baseSchedRef) } else { // We continue working with the currently deployed scheduling policy. - log.Println("Continuing with the current scheduling policy...") - log.Printf("TasksScheduled[%d], SchedWindowSize[%d]", bsps.numTasksScheduled, + elekLog.Println("Continuing with the current scheduling policy...") + elekLog.Printf("TasksScheduled[%d], SchedWindowSize[%d]", bsps.numTasksScheduled, baseSchedRef.schedWindowSize) return } @@ -234,8 +234,8 @@ func (bsps *baseSchedPolicyState) SwitchIfNecessary(spc SchedPolicyContext) { bsps.numTasksScheduled = 0 } else { // We continue working with the currently deployed scheduling policy. - log.Println("Continuing with the current scheduling policy...") - log.Printf("TasksScheduled[%d], SchedWindowSize[%d]", bsps.numTasksScheduled, + elekLog.Println("Continuing with the current scheduling policy...") + elekLog.Printf("TasksScheduled[%d], SchedWindowSize[%d]", bsps.numTasksScheduled, baseSchedRef.schedWindowSize) return } diff --git a/utilities/offerUtils/offerUtils.go b/utilities/offerUtils/offerUtils.go index a3062d8..cd8cc89 100644 --- a/utilities/offerUtils/offerUtils.go +++ b/utilities/offerUtils/offerUtils.go @@ -21,7 +21,7 @@ package offerUtils import ( "fmt" mesos "github.com/mesos/mesos-go/api/v0/mesosproto" - log "github.com/sirupsen/logrus" + elekLog "github.com/sirupsen/logrus" "github.com/spdfg/elektron/constants" "github.com/spdfg/elektron/elektronLogging" elekLogTypes "github.com/spdfg/elektron/elektronLogging/types" @@ -90,14 +90,14 @@ func UpdateEnvironment(offer *mesos.Offer) { var host = offer.GetHostname() // If this host is not present in the set of hosts. if _, ok := constants.Hosts[host]; !ok { - elektronLogging.ElektronLog.Log(elekLogTypes.GENERAL, log.InfoLevel, - log.Fields{"Adding host": fmt.Sprintf("%s", host)}, "New host detected") + elektronLogging.ElektronLog.Log(elekLogTypes.GENERAL, elekLog.InfoLevel, + elekLog.Fields{"Adding host": fmt.Sprintf("%s", host)}, "New host detected") // Add this host. constants.Hosts[host] = struct{}{} // Get the power class of this host. class := PowerClass(offer) - elektronLogging.ElektronLog.Log(elekLogTypes.GENERAL, log.InfoLevel, - log.Fields{"host": fmt.Sprintf("%s", host), "PowerClass": fmt.Sprintf("%s", class)}, "Registering the power class...") + elektronLogging.ElektronLog.Log(elekLogTypes.GENERAL, elekLog.InfoLevel, + elekLog.Fields{"host": fmt.Sprintf("%s", host), "PowerClass": fmt.Sprintf("%s", class)}, "Registering the power class...") // If new power class, register the power class. if _, ok := constants.PowerClasses[class]; !ok { constants.PowerClasses[class] = make(map[string]struct{}) diff --git a/utilities/schedUtils/schedUtils.go b/utilities/schedUtils/schedUtils.go index ffa3124..c24b02d 100644 --- a/utilities/schedUtils/schedUtils.go +++ b/utilities/schedUtils/schedUtils.go @@ -20,7 +20,7 @@ package schedUtils import ( "fmt" - log "github.com/sirupsen/logrus" + elekLog "github.com/sirupsen/logrus" "github.com/spdfg/elektron/def" "github.com/spdfg/elektron/elektronLogging" elekLogTypes "github.com/spdfg/elektron/elektronLogging/types" @@ -79,8 +79,8 @@ func (s *fillNextOfferCycle) apply(taskQueue []def.Task) (int, int) { for _, task := range taskQueue { numberOfTasksTraversed++ for i := *task.Instances; i > 0; i-- { - elektronLogging.ElektronLog.Log(elekLogTypes.GENERAL, log.InfoLevel, - log.Fields{}, fmt.Sprintf("Checking if Instance #%d of Task[%s] can be scheduled "+ + elektronLogging.ElektronLog.Log(elekLogTypes.GENERAL, elekLog.InfoLevel, + elekLog.Fields{}, fmt.Sprintf("Checking if Instance #%d of Task[%s] can be scheduled "+ "during the next offer cycle...", i, task.Name)) if canSchedule(task) { filledCPU += task.CPU -- 2.47.2 From 270c8669e6995fdc1dc5a401f8fc60e08ce82976 Mon Sep 17 00:00:00 2001 From: balandi1 Date: Thu, 21 Nov 2019 14:12:53 -0500 Subject: [PATCH 12/48] Revert previous commit. Renamed wrong alias --- def/taskUtils.go | 10 +- elektronLogging/ElektronFormatter.go | 14 +-- .../clsfnTaskDistOverheadLogger.go | 6 +- elektronLogging/consoleLogger.go | 6 +- elektronLogging/createLogDir.go | 4 +- elektronLogging/logger.go | 10 +- elektronLogging/loggerChain.go | 6 +- elektronLogging/loggerConfig.go | 6 +- elektronLogging/pcpLogger.go | 6 +- elektronLogging/schedPolicySwitchLogger.go | 6 +- elektronLogging/schedTraceLogger.go | 6 +- elektronLogging/schedWindowLogger.go | 6 +- pcp/pcp.go | 22 ++--- powerCap/extrema.go | 60 ++++++------ powerCap/progressiveExtrema.go | 94 +++++++++--------- scheduler.go | 34 +++---- schedulers/MaxGreedyMins.go | 8 +- schedulers/MaxMin.go | 6 +- schedulers/base.go | 98 +++++++++---------- schedulers/bin-packing.go | 6 +- schedulers/helpers.go | 14 +-- schedulers/schedPolicy.go | 14 +-- utilities/offerUtils/offerUtils.go | 10 +- utilities/schedUtils/schedUtils.go | 6 +- 24 files changed, 229 insertions(+), 229 deletions(-) diff --git a/def/taskUtils.go b/def/taskUtils.go index 0e9c4ce..cb93afa 100644 --- a/def/taskUtils.go +++ b/def/taskUtils.go @@ -25,7 +25,7 @@ import ( "github.com/mash/gokmeans" "github.com/montanaflynn/stats" - elekLog "github.com/sirupsen/logrus" + log "github.com/sirupsen/logrus" "github.com/spdfg/elektron/elektronLogging" elekLogTypes "github.com/spdfg/elektron/elektronLogging/types" ) @@ -52,8 +52,8 @@ func (tc TasksToClassify) taskObservationCalculator(task Task) []float64 { } else if task.Watts != 0.0 { return []float64{task.Watts} } else { - elektronLogging.ElektronLog.Log(elekLogTypes.ERROR, elekLog.FatalLevel, - elekLog.Fields{}, "Unable to classify tasks. Missing Watts or ClassToWatts attribute in workload") + elektronLogging.ElektronLog.Log(elekLogTypes.ERROR, log.FatalLevel, + log.Fields{}, "Unable to classify tasks. Missing Watts or ClassToWatts attribute in workload") return []float64{0.0} // Won't reach here. } } @@ -108,8 +108,8 @@ func clusterSizeAvgMMMPU(tasks []Task, taskObservation func(task Task) []float64 } else { // skip this value // there is an error in the task config. - elektronLogging.ElektronLog.Log(elekLogTypes.ERROR, elekLog.ErrorLevel, - elekLog.Fields{}, fmt.Sprintf("%s", err)) + elektronLogging.ElektronLog.Log(elekLogTypes.ERROR, log.ErrorLevel, + log.Fields{}, fmt.Sprintf("%s", err)) } } else { // There is only one observation for the task. diff --git a/elektronLogging/ElektronFormatter.go b/elektronLogging/ElektronFormatter.go index b3b347b..c54fc6a 100644 --- a/elektronLogging/ElektronFormatter.go +++ b/elektronLogging/ElektronFormatter.go @@ -3,7 +3,7 @@ package elektronLogging import ( "bytes" "github.com/fatih/color" - elekLog "github.com/sirupsen/logrus" + log "github.com/sirupsen/logrus" "strings" ) @@ -11,21 +11,21 @@ type ElektronFormatter struct { TimestampFormat string } -func (f ElektronFormatter) getColor(entry *elekLog.Entry) *color.Color { +func (f ElektronFormatter) getColor(entry *log.Entry) *color.Color { switch entry.Level { - case elekLog.InfoLevel: + case log.InfoLevel: return color.New(color.FgGreen, color.Bold) - case elekLog.WarnLevel: + case log.WarnLevel: return color.New(color.FgYellow, color.Bold) - case elekLog.ErrorLevel: + case log.ErrorLevel: return color.New(color.FgRed, color.Bold) - case elekLog.FatalLevel: + case log.FatalLevel: return color.New(color.FgRed, color.Bold) default: return color.New(color.FgWhite, color.Bold) } } -func (f ElektronFormatter) Format(entry *elekLog.Entry) ([]byte, error) { +func (f ElektronFormatter) Format(entry *log.Entry) ([]byte, error) { var b *bytes.Buffer if entry.Buffer != nil { diff --git a/elektronLogging/clsfnTaskDistOverheadLogger.go b/elektronLogging/clsfnTaskDistOverheadLogger.go index 548df5b..8216c71 100644 --- a/elektronLogging/clsfnTaskDistOverheadLogger.go +++ b/elektronLogging/clsfnTaskDistOverheadLogger.go @@ -1,7 +1,7 @@ package elektronLogging import ( - elekLog "github.com/sirupsen/logrus" + log "github.com/sirupsen/logrus" "os" "strings" ) @@ -17,7 +17,7 @@ func NewClsfnTaskDistOverheadLogger(logType int, prefix string) *ClsfnTaskDistOv return cLog } -func (cLog *ClsfnTaskDistOverheadLogger) Log(logType int, level elekLog.Level, logData elekLog.Fields, message string) { +func (cLog *ClsfnTaskDistOverheadLogger) Log(logType int, level log.Level, logData log.Fields, message string) { if cLog.Type == logType { logger.SetLevel(level) @@ -43,7 +43,7 @@ func (cLog *ClsfnTaskDistOverheadLogger) SetLogFile(prefix string) { tskDistLogPrefix = strings.Join([]string{dirName, tskDistLogPrefix}, "/") } if logFile, err := os.Create(tskDistLogPrefix); err != nil { - elekLog.Fatal("Unable to create logFile: ", err) + log.Fatal("Unable to create logFile: ", err) } else { cLog.LogFileName = logFile cLog.AllowOnConsole = config.TaskDistConfig.AllowOnConsole diff --git a/elektronLogging/consoleLogger.go b/elektronLogging/consoleLogger.go index 32f2274..c142a7a 100644 --- a/elektronLogging/consoleLogger.go +++ b/elektronLogging/consoleLogger.go @@ -1,7 +1,7 @@ package elektronLogging import ( - elekLog "github.com/sirupsen/logrus" + log "github.com/sirupsen/logrus" "os" "strings" ) @@ -16,7 +16,7 @@ func NewConsoleLogger(logType int, prefix string) *ConsoleLogger { cLog.SetLogFile(prefix) return cLog } -func (cLog *ConsoleLogger) Log(logType int, level elekLog.Level, logData elekLog.Fields, message string) { +func (cLog *ConsoleLogger) Log(logType int, level log.Level, logData log.Fields, message string) { if logType <= cLog.Type { logger.SetLevel(level) @@ -40,7 +40,7 @@ func (cLog *ConsoleLogger) SetLogFile(prefix string) { consoleLogPrefix = strings.Join([]string{dirName, consoleLogPrefix}, "/") } if logFile, err := os.Create(consoleLogPrefix); err != nil { - elekLog.Fatal("Unable to create logFile: ", err) + log.Fatal("Unable to create logFile: ", err) } else { cLog.LogFileName = logFile cLog.AllowOnConsole = true diff --git a/elektronLogging/createLogDir.go b/elektronLogging/createLogDir.go index 76774f3..8b9a148 100644 --- a/elektronLogging/createLogDir.go +++ b/elektronLogging/createLogDir.go @@ -1,7 +1,7 @@ package elektronLogging import ( - elekLog "github.com/sirupsen/logrus" + log "github.com/sirupsen/logrus" "os" "strconv" "strings" @@ -28,7 +28,7 @@ func (logD *logDirectory) createLogDir(prefix string, startTime time.Time) { if _, err := os.Stat(logDirName); os.IsNotExist(err) { os.Mkdir(logDirName, 0755) } else { - elekLog.Println("Unable to create elekLog directory: ", err) + log.Println("Unable to create log directory: ", err) logDirName = "" } diff --git a/elektronLogging/logger.go b/elektronLogging/logger.go index 74ba35c..1818536 100644 --- a/elektronLogging/logger.go +++ b/elektronLogging/logger.go @@ -1,7 +1,7 @@ package elektronLogging import ( - elekLog "github.com/sirupsen/logrus" + log "github.com/sirupsen/logrus" . "github.com/spdfg/elektron/elektronLogging/types" "os" "strings" @@ -9,7 +9,7 @@ import ( ) var config LoggerConfig -var logger *elekLog.Logger +var logger *log.Logger var formatter ElektronFormatter var ElektronLog *LoggerImpl var logDir logDirectory @@ -19,16 +19,16 @@ func BuildLogger(prefix string) { // read configuration from yaml config.GetConfig() - // create the elekLog directory + // create the log directory startTime := time.Now() formatter.TimestampFormat = "2006-01-02 15:04:05" formattedStartTime := startTime.Format("20060102150405") logDir.createLogDir(prefix, startTime) prefix = strings.Join([]string{prefix, formattedStartTime}, "_") - logger = &elekLog.Logger{ + logger = &log.Logger{ Out: os.Stderr, - Level: elekLog.DebugLevel, + Level: log.DebugLevel, Formatter: &formatter, } diff --git a/elektronLogging/loggerChain.go b/elektronLogging/loggerChain.go index 996757b..8a8207a 100644 --- a/elektronLogging/loggerChain.go +++ b/elektronLogging/loggerChain.go @@ -1,13 +1,13 @@ package elektronLogging import ( - elekLog "github.com/sirupsen/logrus" + log "github.com/sirupsen/logrus" "os" ) type Logger interface { SetNext(logType Logger) - Log(logType int, level elekLog.Level, logData elekLog.Fields, message string) + Log(logType int, level log.Level, logData log.Fields, message string) SetLogFile(prefix string) } type LoggerImpl struct { @@ -21,7 +21,7 @@ func (l *LoggerImpl) SetNext(logType Logger) { l.next = logType } -func (l *LoggerImpl) Log(logType int, level elekLog.Level, logData elekLog.Fields, message string) { +func (l *LoggerImpl) Log(logType int, level log.Level, logData log.Fields, message string) { if l.next != nil { l.next.Log(logType, level, logData, message) } diff --git a/elektronLogging/loggerConfig.go b/elektronLogging/loggerConfig.go index 4aae8c9..790669e 100644 --- a/elektronLogging/loggerConfig.go +++ b/elektronLogging/loggerConfig.go @@ -1,7 +1,7 @@ package elektronLogging import ( - elekLog "github.com/sirupsen/logrus" + log "github.com/sirupsen/logrus" elekEnv "github.com/spdfg/elektron/environment" "gopkg.in/yaml.v2" "io/ioutil" @@ -57,11 +57,11 @@ func (c *LoggerConfig) GetConfig() *LoggerConfig { yamlFile, err := ioutil.ReadFile(elekEnv.LogConfigYaml) if err != nil { - elekLog.Printf("yamlFile.Get err #%v ", err) + log.Printf("yamlFile.Get err #%v ", err) } err = yaml.Unmarshal(yamlFile, c) if err != nil { - elekLog.Fatalf("Unmarshal: %v", err) + log.Fatalf("Unmarshal: %v", err) } return c diff --git a/elektronLogging/pcpLogger.go b/elektronLogging/pcpLogger.go index a70cb1b..594ae95 100644 --- a/elektronLogging/pcpLogger.go +++ b/elektronLogging/pcpLogger.go @@ -1,7 +1,7 @@ package elektronLogging import ( - elekLog "github.com/sirupsen/logrus" + log "github.com/sirupsen/logrus" "os" "strings" ) @@ -17,7 +17,7 @@ func NewPcpLogger(logType int, prefix string) *PcpLogger { return pLog } -func (pLog *PcpLogger) Log(logType int, level elekLog.Level, logData elekLog.Fields, message string) { +func (pLog *PcpLogger) Log(logType int, level log.Level, logData log.Fields, message string) { if pLog.Type == logType { logger.SetLevel(level) @@ -43,7 +43,7 @@ func (plog *PcpLogger) SetLogFile(prefix string) { pcpLogPrefix = strings.Join([]string{dirName, pcpLogPrefix}, "/") } if logFile, err := os.Create(pcpLogPrefix); err != nil { - elekLog.Fatal("Unable to create logFile: ", err) + log.Fatal("Unable to create logFile: ", err) } else { plog.LogFileName = logFile plog.AllowOnConsole = config.PCPConfig.AllowOnConsole diff --git a/elektronLogging/schedPolicySwitchLogger.go b/elektronLogging/schedPolicySwitchLogger.go index 0df54ac..ee72240 100644 --- a/elektronLogging/schedPolicySwitchLogger.go +++ b/elektronLogging/schedPolicySwitchLogger.go @@ -1,7 +1,7 @@ package elektronLogging import ( - elekLog "github.com/sirupsen/logrus" + log "github.com/sirupsen/logrus" "os" "strings" ) @@ -17,7 +17,7 @@ func NewSchedPolicySwitchLogger(logType int, prefix string) *SchedPolicySwitchLo return sLog } -func (sLog *SchedPolicySwitchLogger) Log(logType int, level elekLog.Level, logData elekLog.Fields, message string) { +func (sLog *SchedPolicySwitchLogger) Log(logType int, level log.Level, logData log.Fields, message string) { if sLog.Type == logType { logger.SetLevel(level) @@ -43,7 +43,7 @@ func (sLog *SchedPolicySwitchLogger) SetLogFile(prefix string) { spsLogPrefix = strings.Join([]string{dirName, spsLogPrefix}, "/") } if logFile, err := os.Create(spsLogPrefix); err != nil { - elekLog.Fatal("Unable to create logFile: ", err) + log.Fatal("Unable to create logFile: ", err) } else { sLog.LogFileName = logFile sLog.AllowOnConsole = config.SPSConfig.AllowOnConsole diff --git a/elektronLogging/schedTraceLogger.go b/elektronLogging/schedTraceLogger.go index 8686ff8..87ae4ec 100644 --- a/elektronLogging/schedTraceLogger.go +++ b/elektronLogging/schedTraceLogger.go @@ -1,7 +1,7 @@ package elektronLogging import ( - elekLog "github.com/sirupsen/logrus" + log "github.com/sirupsen/logrus" "os" "strings" ) @@ -17,7 +17,7 @@ func NewSchedTraceLogger(logType int, prefix string) *SchedTraceLogger { return sLog } -func (sLog *SchedTraceLogger) Log(logType int, level elekLog.Level, logData elekLog.Fields, message string) { +func (sLog *SchedTraceLogger) Log(logType int, level log.Level, logData log.Fields, message string) { if sLog.Type == logType { logger.SetLevel(level) @@ -43,7 +43,7 @@ func (sLog *SchedTraceLogger) SetLogFile(prefix string) { schedTraceLogPrefix = strings.Join([]string{dirName, schedTraceLogPrefix}, "/") } if logFile, err := os.Create(schedTraceLogPrefix); err != nil { - elekLog.Fatal("Unable to create logFile: ", err) + log.Fatal("Unable to create logFile: ", err) } else { sLog.LogFileName = logFile sLog.AllowOnConsole = config.SchedTraceConfig.AllowOnConsole diff --git a/elektronLogging/schedWindowLogger.go b/elektronLogging/schedWindowLogger.go index 69b3480..ae55f95 100644 --- a/elektronLogging/schedWindowLogger.go +++ b/elektronLogging/schedWindowLogger.go @@ -1,7 +1,7 @@ package elektronLogging import ( - elekLog "github.com/sirupsen/logrus" + log "github.com/sirupsen/logrus" "os" "strings" ) @@ -17,7 +17,7 @@ func NewSchedWindowLogger(logType int, prefix string) *SchedWindowLogger { return sLog } -func (sLog *SchedWindowLogger) Log(logType int, level elekLog.Level, logData elekLog.Fields, message string) { +func (sLog *SchedWindowLogger) Log(logType int, level log.Level, logData log.Fields, message string) { if sLog.Type == logType { logger.SetLevel(level) @@ -43,7 +43,7 @@ func (sLog *SchedWindowLogger) SetLogFile(prefix string) { schedWindowLogPrefix = strings.Join([]string{dirName, schedWindowLogPrefix}, "/") } if logFile, err := os.Create(schedWindowLogPrefix); err != nil { - elekLog.Fatal("Unable to create logFile: ", err) + log.Fatal("Unable to create logFile: ", err) } else { sLog.LogFileName = logFile sLog.AllowOnConsole = config.SchedWindowConfig.AllowOnConsole diff --git a/pcp/pcp.go b/pcp/pcp.go index ad9d6c9..f1ff505 100644 --- a/pcp/pcp.go +++ b/pcp/pcp.go @@ -24,7 +24,7 @@ import ( "syscall" "time" - elekLog "github.com/sirupsen/logrus" + log "github.com/sirupsen/logrus" "github.com/spdfg/elektron/elektronLogging" elekLogT "github.com/spdfg/elektron/elektronLogging/types" ) @@ -36,7 +36,7 @@ func Start(quit chan struct{}, logging *bool, pcpConfigFile string) { pipe, err := cmd.StdoutPipe() if err != nil { - elekLog.Fatal(err) + log.Fatal(err) } //cmd.Stdout = stdout @@ -48,8 +48,8 @@ func Start(quit chan struct{}, logging *bool, pcpConfigFile string) { // Write to logfile elektronLogging.ElektronLog.Log(elekLogT.PCP, - elekLog.InfoLevel, - elekLog.Fields{}, scanner.Text()) + log.InfoLevel, + log.Fields{}, scanner.Text()) // Throw away first set of results scanner.Scan() @@ -61,8 +61,8 @@ func Start(quit chan struct{}, logging *bool, pcpConfigFile string) { if *logging { elektronLogging.ElektronLog.Log(elekLogT.PCP, - elekLog.InfoLevel, - elekLog.Fields{}, text) + log.InfoLevel, + log.Fields{}, text) } seconds++ @@ -70,11 +70,11 @@ func Start(quit chan struct{}, logging *bool, pcpConfigFile string) { }(logging) elektronLogging.ElektronLog.Log(elekLogT.GENERAL, - elekLog.InfoLevel, - elekLog.Fields{}, "PCP logging started") + log.InfoLevel, + log.Fields{}, "PCP logging started") if err := cmd.Start(); err != nil { - elekLog.Fatal(err) + log.Fatal(err) } pgid, err := syscall.Getpgid(cmd.Process.Pid) @@ -82,8 +82,8 @@ func Start(quit chan struct{}, logging *bool, pcpConfigFile string) { select { case <-quit: elektronLogging.ElektronLog.Log(elekLogT.GENERAL, - elekLog.InfoLevel, - elekLog.Fields{}, "Stopping PCP logging in 5 seconds") + log.InfoLevel, + log.Fields{}, "Stopping PCP logging in 5 seconds") time.Sleep(5 * time.Second) // http://stackoverflow.com/questions/22470193/why-wont-go-kill-a-child-process-correctly diff --git a/powerCap/extrema.go b/powerCap/extrema.go index be2a8ba..83e76b4 100644 --- a/powerCap/extrema.go +++ b/powerCap/extrema.go @@ -29,7 +29,7 @@ import ( "syscall" "time" - elekLog "github.com/sirupsen/logrus" + log "github.com/sirupsen/logrus" "github.com/spdfg/elektron/elektronLogging" elekLogTypes "github.com/spdfg/elektron/elektronLogging/types" "github.com/spdfg/elektron/pcp" @@ -44,13 +44,13 @@ func StartPCPLogAndExtremaDynamicCap(quit chan struct{}, logging *bool, hiThresh if hiThreshold < loThreshold { elektronLogging.ElektronLog.Log(elekLogTypes.GENERAL, - elekLog.InfoLevel, - elekLog.Fields{}, "High threshold is lower than low threshold!") + log.InfoLevel, + log.Fields{}, "High threshold is lower than low threshold!") } pipe, err := cmd.StdoutPipe() if err != nil { - elekLog.Fatal(err) + log.Fatal(err) } //cmd.Stdout = stdout @@ -62,8 +62,8 @@ func StartPCPLogAndExtremaDynamicCap(quit chan struct{}, logging *bool, hiThresh // Write to logfile elektronLogging.ElektronLog.Log(elekLogTypes.PCP, - elekLog.InfoLevel, - elekLog.Fields{}, scanner.Text()) + log.InfoLevel, + log.Fields{}, scanner.Text()) headers := strings.Split(scanner.Text(), ",") @@ -100,15 +100,15 @@ func StartPCPLogAndExtremaDynamicCap(quit chan struct{}, logging *bool, hiThresh if *logging { elektronLogging.ElektronLog.Log(elekLogTypes.GENERAL, - elekLog.InfoLevel, - elekLog.Fields{}, "Logging PCP...") + log.InfoLevel, + log.Fields{}, "Logging PCP...") text := scanner.Text() split := strings.Split(text, ",") elektronLogging.ElektronLog.Log(elekLogTypes.PCP, - elekLog.InfoLevel, - elekLog.Fields{}, text) + log.InfoLevel, + log.Fields{}, text) totalPower := 0.0 for _, powerIndex := range powerIndexes { @@ -120,8 +120,8 @@ func StartPCPLogAndExtremaDynamicCap(quit chan struct{}, logging *bool, hiThresh powerHistories[host] = powerHistories[host].Next() elektronLogging.ElektronLog.Log(elekLogTypes.GENERAL, - elekLog.InfoLevel, - elekLog.Fields{"Host": fmt.Sprintf("%s", indexToHost[powerIndex]), "Power": fmt.Sprintf("%f", (power * pcp.RAPLUnits))}, + log.InfoLevel, + log.Fields{"Host": fmt.Sprintf("%s", indexToHost[powerIndex]), "Power": fmt.Sprintf("%f", (power * pcp.RAPLUnits))}, "") totalPower += power @@ -134,15 +134,15 @@ func StartPCPLogAndExtremaDynamicCap(quit chan struct{}, logging *bool, hiThresh clusterMean := pcp.AverageClusterPowerHistory(clusterPowerHist) elektronLogging.ElektronLog.Log(elekLogTypes.GENERAL, - elekLog.InfoLevel, - elekLog.Fields{"Total power": fmt.Sprintf("%f %d", clusterPower, clusterPowerHist.Len()), + log.InfoLevel, + log.Fields{"Total power": fmt.Sprintf("%f %d", clusterPower, clusterPowerHist.Len()), "Sec Avg": fmt.Sprintf("%f", clusterMean)}, "") if clusterMean > hiThreshold { elektronLogging.ElektronLog.Log(elekLogTypes.GENERAL, - elekLog.InfoLevel, - elekLog.Fields{}, "Need to cap a node") + log.InfoLevel, + log.Fields{}, "Need to cap a node") // Create statics for all victims and choose one to cap victims := make([]pcp.Victim, 0, 8) @@ -164,13 +164,13 @@ func StartPCPLogAndExtremaDynamicCap(quit chan struct{}, logging *bool, hiThresh cappedHosts[victim.Host] = true orderCapped = append(orderCapped, victim.Host) elektronLogging.ElektronLog.Log(elekLogTypes.GENERAL, - elekLog.InfoLevel, - elekLog.Fields{"Capping Victim": fmt.Sprintf("%s", victim.Host), + log.InfoLevel, + log.Fields{"Capping Victim": fmt.Sprintf("%s", victim.Host), "Avg. Wattage": fmt.Sprintf("%f", victim.Watts*pcp.RAPLUnits)}, "") if err := rapl.Cap(victim.Host, "rapl", 50); err != nil { elektronLogging.ElektronLog.Log(elekLogTypes.ERROR, - elekLog.ErrorLevel, - elekLog.Fields{}, "Error capping host") + log.ErrorLevel, + log.Fields{}, "Error capping host") } break // Only cap one machine at at time. } @@ -183,14 +183,14 @@ func StartPCPLogAndExtremaDynamicCap(quit chan struct{}, logging *bool, hiThresh orderCapped = orderCapped[:len(orderCapped)-1] cappedHosts[host] = false // User RAPL package to send uncap. - elekLog.Printf("Uncapping host %s", host) + log.Printf("Uncapping host %s", host) elektronLogging.ElektronLog.Log(elekLogTypes.GENERAL, - elekLog.InfoLevel, - elekLog.Fields{"Uncapped host": host}, "") + log.InfoLevel, + log.Fields{"Uncapped host": host}, "") if err := rapl.Cap(host, "rapl", 100); err != nil { elektronLogging.ElektronLog.Log(elekLogTypes.ERROR, - elekLog.ErrorLevel, - elekLog.Fields{}, "Error capping host") + log.ErrorLevel, + log.Fields{}, "Error capping host") } } } @@ -201,11 +201,11 @@ func StartPCPLogAndExtremaDynamicCap(quit chan struct{}, logging *bool, hiThresh }(logging, hiThreshold, loThreshold) elektronLogging.ElektronLog.Log(elekLogTypes.GENERAL, - elekLog.InfoLevel, - elekLog.Fields{}, "PCP logging started") + log.InfoLevel, + log.Fields{}, "PCP logging started") if err := cmd.Start(); err != nil { - elekLog.Fatal(err) + log.Fatal(err) } pgid, err := syscall.Getpgid(cmd.Process.Pid) @@ -213,8 +213,8 @@ func StartPCPLogAndExtremaDynamicCap(quit chan struct{}, logging *bool, hiThresh select { case <-quit: elektronLogging.ElektronLog.Log(elekLogTypes.GENERAL, - elekLog.InfoLevel, - elekLog.Fields{}, "Stopping PCP logging in 5 seconds") + log.InfoLevel, + log.Fields{}, "Stopping PCP logging in 5 seconds") time.Sleep(5 * time.Second) // http://stackoverflow.com/questions/22470193/why-wont-go-kill-a-child-process-correctly diff --git a/powerCap/progressiveExtrema.go b/powerCap/progressiveExtrema.go index 789a0ca..034376f 100644 --- a/powerCap/progressiveExtrema.go +++ b/powerCap/progressiveExtrema.go @@ -30,7 +30,7 @@ import ( "syscall" "time" - elekLog "github.com/sirupsen/logrus" + log "github.com/sirupsen/logrus" "github.com/spdfg/elektron/constants" "github.com/spdfg/elektron/elektronLogging" elekLogTypes "github.com/spdfg/elektron/elektronLogging/types" @@ -57,13 +57,13 @@ func StartPCPLogAndProgressiveExtremaCap(quit chan struct{}, logging *bool, hiTh if hiThreshold < loThreshold { elektronLogging.ElektronLog.Log(elekLogTypes.GENERAL, - elekLog.InfoLevel, - elekLog.Fields{}, "High threshold is lower than low threshold!") + log.InfoLevel, + log.Fields{}, "High threshold is lower than low threshold!") } pipe, err := cmd.StdoutPipe() if err != nil { - elekLog.Fatal(err) + log.Fatal(err) } //cmd.Stdout = stdout @@ -75,8 +75,8 @@ func StartPCPLogAndProgressiveExtremaCap(quit chan struct{}, logging *bool, hiTh // Write to logfile elektronLogging.ElektronLog.Log(elekLogTypes.PCP, - elekLog.InfoLevel, - elekLog.Fields{}, scanner.Text()) + log.InfoLevel, + log.Fields{}, scanner.Text()) headers := strings.Split(scanner.Text(), ",") @@ -116,14 +116,14 @@ func StartPCPLogAndProgressiveExtremaCap(quit chan struct{}, logging *bool, hiTh for scanner.Scan() { if *logging { elektronLogging.ElektronLog.Log(elekLogTypes.GENERAL, - elekLog.InfoLevel, - elekLog.Fields{}, "Logging PCP...") + log.InfoLevel, + log.Fields{}, "Logging PCP...") split := strings.Split(scanner.Text(), ",") text := scanner.Text() elektronLogging.ElektronLog.Log(elekLogTypes.PCP, - elekLog.InfoLevel, - elekLog.Fields{}, text) + log.InfoLevel, + log.Fields{}, text) totalPower := 0.0 for _, powerIndex := range powerIndexes { @@ -135,8 +135,8 @@ func StartPCPLogAndProgressiveExtremaCap(quit chan struct{}, logging *bool, hiTh powerHistories[host] = powerHistories[host].Next() elektronLogging.ElektronLog.Log(elekLogTypes.GENERAL, - elekLog.InfoLevel, - elekLog.Fields{"Host": fmt.Sprintf("%s", indexToHost[powerIndex]), "Power": fmt.Sprintf("%f", (power * pcp.RAPLUnits))}, + log.InfoLevel, + log.Fields{"Host": fmt.Sprintf("%s", indexToHost[powerIndex]), "Power": fmt.Sprintf("%f", (power * pcp.RAPLUnits))}, "") totalPower += power } @@ -148,23 +148,23 @@ func StartPCPLogAndProgressiveExtremaCap(quit chan struct{}, logging *bool, hiTh clusterMean := pcp.AverageClusterPowerHistory(clusterPowerHist) elektronLogging.ElektronLog.Log(elekLogTypes.GENERAL, - elekLog.InfoLevel, - elekLog.Fields{"Total power": fmt.Sprintf("%f %d", clusterPower, clusterPowerHist.Len()), + log.InfoLevel, + log.Fields{"Total power": fmt.Sprintf("%f %d", clusterPower, clusterPowerHist.Len()), "Sec Avg": fmt.Sprintf("%f", clusterMean)}, "") if clusterMean >= hiThreshold { elektronLogging.ElektronLog.Log(elekLogTypes.GENERAL, - elekLog.InfoLevel, - elekLog.Fields{}, "Need to cap a node") + log.InfoLevel, + log.Fields{}, "Need to cap a node") elektronLogging.ElektronLog.Log(elekLogTypes.GENERAL, - elekLog.InfoLevel, - elekLog.Fields{"Cap values of capped victims": fmt.Sprintf("%v", cappedVictims)}, "") + log.InfoLevel, + log.Fields{"Cap values of capped victims": fmt.Sprintf("%v", cappedVictims)}, "") elektronLogging.ElektronLog.Log(elekLogTypes.GENERAL, - elekLog.InfoLevel, - elekLog.Fields{"Cap values of victims to uncap": fmt.Sprintf("%v", orderCappedVictims)}, "") + log.InfoLevel, + log.Fields{"Cap values of victims to uncap": fmt.Sprintf("%v", orderCappedVictims)}, "") // Create statics for all victims and choose one to cap victims := make([]pcp.Victim, 0, 8) @@ -193,13 +193,13 @@ func StartPCPLogAndProgressiveExtremaCap(quit chan struct{}, logging *bool, hiTh if err := rapl.Cap(victims[i].Host, "rapl", 50.0); err != nil { elektronLogging.ElektronLog.Log(elekLogTypes.ERROR, - elekLog.ErrorLevel, - elekLog.Fields{"Error capping host": fmt.Sprintf("%s", victims[i].Host)}, "") + log.ErrorLevel, + log.Fields{"Error capping host": fmt.Sprintf("%s", victims[i].Host)}, "") } else { elektronLogging.ElektronLog.Log(elekLogTypes.GENERAL, - elekLog.InfoLevel, - elekLog.Fields{}, fmt.Sprintf("Capped host[%s] at %f", victims[i].Host, 50.0)) + log.InfoLevel, + log.Fields{}, fmt.Sprintf("Capped host[%s] at %f", victims[i].Host, 50.0)) // Keeping track of this victim and it's cap value cappedVictims[victims[i].Host] = 50.0 newVictimFound = true @@ -224,13 +224,13 @@ func StartPCPLogAndProgressiveExtremaCap(quit chan struct{}, logging *bool, hiTh if err := rapl.Cap(alreadyCappedHosts[i], "rapl", newCapValue); err != nil { elektronLogging.ElektronLog.Log(elekLogTypes.ERROR, - elekLog.ErrorLevel, - elekLog.Fields{"Error capping host": fmt.Sprintf("%s", alreadyCappedHosts[i])}, "") + log.ErrorLevel, + log.Fields{"Error capping host": fmt.Sprintf("%s", alreadyCappedHosts[i])}, "") } else { // Successful cap elektronLogging.ElektronLog.Log(elekLogTypes.GENERAL, - elekLog.InfoLevel, - elekLog.Fields{}, fmt.Sprintf("Capped host[%s] at %f", alreadyCappedHosts[i], newCapValue)) + log.InfoLevel, + log.Fields{}, fmt.Sprintf("Capped host[%s] at %f", alreadyCappedHosts[i], newCapValue)) // Checking whether this victim can be capped further if newCapValue <= constants.LowerCapLimit { // Deleting victim from cappedVictims. @@ -254,22 +254,22 @@ func StartPCPLogAndProgressiveExtremaCap(quit chan struct{}, logging *bool, hiTh } if !canCapAlreadyCappedVictim { elektronLogging.ElektronLog.Log(elekLogTypes.GENERAL, - elekLog.InfoLevel, - elekLog.Fields{}, "No Victim left to cap") + log.InfoLevel, + log.Fields{}, "No Victim left to cap") } } } else if clusterMean < loThreshold { elektronLogging.ElektronLog.Log(elekLogTypes.GENERAL, - elekLog.InfoLevel, - elekLog.Fields{}, "Need to uncap a node") + log.InfoLevel, + log.Fields{}, "Need to uncap a node") elektronLogging.ElektronLog.Log(elekLogTypes.GENERAL, - elekLog.InfoLevel, - elekLog.Fields{"Cap values of capped victims": fmt.Sprintf("%v", cappedVictims)}, "") + log.InfoLevel, + log.Fields{"Cap values of capped victims": fmt.Sprintf("%v", cappedVictims)}, "") elektronLogging.ElektronLog.Log(elekLogTypes.GENERAL, - elekLog.InfoLevel, - elekLog.Fields{"Cap values of victims to uncap": fmt.Sprintf("%v", orderCappedVictims)}, "") + log.InfoLevel, + log.Fields{"Cap values of victims to uncap": fmt.Sprintf("%v", orderCappedVictims)}, "") if len(orderCapped) > 0 { // We pick the host that is capped the most to uncap. orderCappedToSort := utilities.GetPairList(orderCappedVictims) @@ -281,13 +281,13 @@ func StartPCPLogAndProgressiveExtremaCap(quit chan struct{}, logging *bool, hiTh if err := rapl.Cap(hostToUncap, "rapl", newUncapValue); err != nil { elektronLogging.ElektronLog.Log(elekLogTypes.ERROR, - elekLog.ErrorLevel, - elekLog.Fields{"Error uncapping host": fmt.Sprintf("%s", hostToUncap)}, "") + log.ErrorLevel, + log.Fields{"Error uncapping host": fmt.Sprintf("%s", hostToUncap)}, "") } else { // Successful uncap elektronLogging.ElektronLog.Log(elekLogTypes.GENERAL, - elekLog.InfoLevel, - elekLog.Fields{}, fmt.Sprintf("Uncapped host[%s] to %f", hostToUncap, newUncapValue)) + log.InfoLevel, + log.Fields{}, fmt.Sprintf("Uncapped host[%s] to %f", hostToUncap, newUncapValue)) // Can we uncap this host further. If not, then we remove its entry from orderCapped if newUncapValue >= 100.0 { // can compare using == // Deleting entry from orderCapped @@ -309,8 +309,8 @@ func StartPCPLogAndProgressiveExtremaCap(quit chan struct{}, logging *bool, hiTh } } else { elektronLogging.ElektronLog.Log(elekLogTypes.GENERAL, - elekLog.InfoLevel, - elekLog.Fields{}, "No host staged for Uncapped") + log.InfoLevel, + log.Fields{}, "No host staged for Uncapped") } } } @@ -320,10 +320,10 @@ func StartPCPLogAndProgressiveExtremaCap(quit chan struct{}, logging *bool, hiTh }(logging, hiThreshold, loThreshold) elektronLogging.ElektronLog.Log(elekLogTypes.GENERAL, - elekLog.InfoLevel, - elekLog.Fields{}, "PCP logging started") + log.InfoLevel, + log.Fields{}, "PCP logging started") if err := cmd.Start(); err != nil { - elekLog.Fatal(err) + log.Fatal(err) } pgid, err := syscall.Getpgid(cmd.Process.Pid) @@ -331,8 +331,8 @@ func StartPCPLogAndProgressiveExtremaCap(quit chan struct{}, logging *bool, hiTh select { case <-quit: elektronLogging.ElektronLog.Log(elekLogTypes.GENERAL, - elekLog.InfoLevel, - elekLog.Fields{}, "Stopping PCP logging in 5 seconds") + log.InfoLevel, + log.Fields{}, "Stopping PCP logging in 5 seconds") time.Sleep(5 * time.Second) // http://stackoverflow.com/questions/22470193/why-wont-go-kill-a-child-process-correctly diff --git a/scheduler.go b/scheduler.go index 6987e9a..a0d453d 100644 --- a/scheduler.go +++ b/scheduler.go @@ -24,7 +24,7 @@ import ( "github.com/golang/protobuf/proto" mesos "github.com/mesos/mesos-go/api/v0/mesosproto" sched "github.com/mesos/mesos-go/api/v0/scheduler" - elekLog "github.com/sirupsen/logrus" + log "github.com/sirupsen/logrus" "github.com/spdfg/elektron/def" "github.com/spdfg/elektron/elektronLogging" elekLogTypes "github.com/spdfg/elektron/elektronLogging/types" @@ -104,7 +104,7 @@ func main() { if *schedPolicyName != "first-fit" { if _, ok := schedulers.SchedPolicies[*schedPolicyName]; !ok { // invalid scheduling policy - elekLog.Println("Invalid scheduling policy given. The possible scheduling policies are:") + log.Println("Invalid scheduling policy given. The possible scheduling policies are:") listAllSchedulingPolicies() os.Exit(1) } @@ -130,7 +130,7 @@ func main() { if *enableSchedPolicySwitch { // Scheduling policy config file required. if spcf := *schedPolConfigFile; spcf == "" { - elekLog.Fatal("Scheduling policy characteristics file not provided.") + log.Fatal("Scheduling policy characteristics file not provided.") } else { // Initializing the characteristics of the scheduling policies. schedulers.InitSchedPolicyCharacteristics(spcf) @@ -148,7 +148,7 @@ func main() { // If CMW is disabled, then the Median of Medians Max Peak Power Usage value is used // as the watts value for each task. if *wattsAsAResource { - elekLog.Println("WaaR enabled...") + log.Println("WaaR enabled...") schedOptions = append(schedOptions, schedulers.WithWattsAsAResource(*wattsAsAResource)) schedOptions = append(schedOptions, schedulers.WithClassMapWatts(*classMapWatts)) } @@ -165,7 +165,7 @@ func main() { "prog-extrema": {}, } if _, ok := powercapValues[*powerCapPolicy]; !ok { - elekLog.Fatal("Incorrect power-capping algorithm specified.") + log.Fatal("Incorrect power-capping algorithm specified.") } else { // Indicating which power capping algorithm to use, if any. // The pcp-logging with/without power capping will be run after the @@ -185,7 +185,7 @@ func main() { // These values are not used to configure the scheduler. // hiThreshold and loThreshold are passed to the powercappers. if *hiThreshold < *loThreshold { - elekLog.Fatal("High threshold is of a lower value than low " + + log.Fatal("High threshold is of a lower value than low " + "threshold.") } } @@ -195,11 +195,11 @@ func main() { // Tasks // If httpServer is disabled, then path of file containing workload needs to be provided. if *tasksFile == "" { - elekLog.Fatal("Tasks specifications file not provided.") + log.Fatal("Tasks specifications file not provided.") } tasks, err := def.TasksFromJSON(*tasksFile) if err != nil || len(tasks) == 0 { - elekLog.Fatal("Invalid tasks specification file provided.") + log.Fatal("Invalid tasks specification file provided.") } schedOptions = append(schedOptions, schedulers.WithTasks(tasks)) @@ -216,12 +216,12 @@ func main() { Scheduler: scheduler, }) if err != nil { - elekLog.Fatal(fmt.Sprintf("Unable to create scheduler driver: %s", err)) + log.Fatal(fmt.Sprintf("Unable to create scheduler driver: %s", err)) } // Checking if prefix contains any special characters. if strings.Contains(*pcplogPrefix, "/") { - elekLog.Fatal("elekLog file prefix should not contain '/'.") + log.Fatal("log file prefix should not contain '/'.") } elektronLogging.BuildLogger(*pcplogPrefix) @@ -236,7 +236,7 @@ func main() { *loThreshold, *pcpConfigFile) } - // Take a second between starting PCP elekLog and continuing. + // Take a second between starting PCP log and continuing. time.Sleep(1 * time.Second) // Attempt to handle SIGINT to not leave pmdumptext running. @@ -250,7 +250,7 @@ func main() { return } - elekLog.Println("Received SIGINT... stopping") + log.Println("Received SIGINT... stopping") close(done) }() @@ -266,7 +266,7 @@ func main() { select { case <-done: close(pcpLog) - time.Sleep(5 * time.Second) //Wait for PCP to elekLog a few more seconds + time.Sleep(5 * time.Second) //Wait for PCP to log a few more seconds // Closing logging channels. //case <-time.After(shutdownTimeout): } @@ -279,10 +279,10 @@ func main() { // Starting the scheduler driver. if status, err := driver.Run(); err != nil { elektronLogging.ElektronLog.Log(elekLogTypes.ERROR, - elekLog.ErrorLevel, - elekLog.Fields{"status": status.String(), "error": err.Error()}, "Framework stopped ") + log.ErrorLevel, + log.Fields{"status": status.String(), "error": err.Error()}, "Framework stopped ") } elektronLogging.ElektronLog.Log(elekLogTypes.GENERAL, - elekLog.InfoLevel, - elekLog.Fields{}, "Exiting...") + log.InfoLevel, + log.Fields{}, "Exiting...") } diff --git a/schedulers/MaxGreedyMins.go b/schedulers/MaxGreedyMins.go index 720882d..b4b250d 100644 --- a/schedulers/MaxGreedyMins.go +++ b/schedulers/MaxGreedyMins.go @@ -19,7 +19,7 @@ package schedulers import ( - elekLog "github.com/sirupsen/logrus" + log "github.com/sirupsen/logrus" mesos "github.com/mesos/mesos-go/api/v0/mesosproto" sched "github.com/mesos/mesos-go/api/v0/scheduler" @@ -39,7 +39,7 @@ func (s *MaxGreedyMins) takeOffer(spc SchedPolicyContext, offer *mesos.Offer, ta wattsConsideration, err := def.WattsToConsider(task, baseSchedRef.classMapWatts, offer) if err != nil { // Error in determining wattsConsideration - elekLog.Fatal(err) + log.Fatal(err) } if (cpus >= (totalCPU + task.CPU)) && (mem >= (totalRAM + task.RAM)) && (!baseSchedRef.wattsAsAResource || (watts >= (totalWatts + wattsConsideration))) { @@ -136,7 +136,7 @@ func (s *MaxGreedyMins) ConsumeOffers(spc SchedPolicyContext, driver sched.Sched wattsConsideration, err := def.WattsToConsider(task, baseSchedRef.classMapWatts, offer) if err != nil { // Error in determining wattsConsideration - elekLog.Fatal(err) + log.Fatal(err) } // Don't take offer if it doesn't match our task's host requirement @@ -161,7 +161,7 @@ func (s *MaxGreedyMins) ConsumeOffers(spc SchedPolicyContext, driver sched.Sched wattsConsideration, err := def.WattsToConsider(task, baseSchedRef.classMapWatts, offer) if err != nil { // Error in determining wattsConsideration - elekLog.Fatal(err) + log.Fatal(err) } // Don't take offer if it doesn't match our task's host requirement diff --git a/schedulers/MaxMin.go b/schedulers/MaxMin.go index 513359e..a7ba29e 100644 --- a/schedulers/MaxMin.go +++ b/schedulers/MaxMin.go @@ -19,7 +19,7 @@ package schedulers import ( - elekLog "github.com/sirupsen/logrus" + log "github.com/sirupsen/logrus" mesos "github.com/mesos/mesos-go/api/v0/mesosproto" sched "github.com/mesos/mesos-go/api/v0/scheduler" @@ -39,7 +39,7 @@ func (s *MaxMin) takeOffer(spc SchedPolicyContext, offer *mesos.Offer, task def. wattsConsideration, err := def.WattsToConsider(task, baseSchedRef.classMapWatts, offer) if err != nil { // Error in determining wattsConsideration - elekLog.Fatal(err) + log.Fatal(err) } if (cpus >= (totalCPU + task.CPU)) && (mem >= (totalRAM + task.RAM)) && (!baseSchedRef.wattsAsAResource || (watts >= (totalWatts + wattsConsideration))) { @@ -148,7 +148,7 @@ func (s *MaxMin) ConsumeOffers(spc SchedPolicyContext, driver sched.SchedulerDri wattsConsideration, err := def.WattsToConsider(task, baseSchedRef.classMapWatts, offer) if err != nil { // Error in determining wattsConsideration. - elekLog.Fatal(err) + log.Fatal(err) } // Don't take offer if it doesn't match our task's host requirement. diff --git a/schedulers/base.go b/schedulers/base.go index 3a6d77d..decec5c 100644 --- a/schedulers/base.go +++ b/schedulers/base.go @@ -28,7 +28,7 @@ import ( mesos "github.com/mesos/mesos-go/api/v0/mesosproto" "github.com/mesos/mesos-go/api/v0/mesosutil" sched "github.com/mesos/mesos-go/api/v0/scheduler" - elekLog "github.com/sirupsen/logrus" + log "github.com/sirupsen/logrus" "github.com/spdfg/elektron/def" "github.com/spdfg/elektron/elektronLogging" elekLogTypes "github.com/spdfg/elektron/elektronLogging/types" @@ -67,7 +67,7 @@ type BaseScheduler struct { // Controls when to shutdown pcp logging. PCPLog chan struct{} - schedTrace *elekLog.Logger + schedTrace *log.Logger mutex sync.Mutex @@ -102,7 +102,7 @@ func (s *BaseScheduler) init(opts ...SchedulerOptions) { for _, opt := range opts { // applying options if err := opt(s); err != nil { - elekLog.Fatal(err) + log.Fatal(err) } } s.TasksRunningMutex.Lock() @@ -251,12 +251,12 @@ func (s *BaseScheduler) StatusUpdate(driver sched.SchedulerDriver, status *mesos func (s *BaseScheduler) LogTaskStarting(ts *def.Task, offer *mesos.Offer) { lmt := elekLogTypes.GENERAL if ts == nil { - elektronLogging.ElektronLog.Log(lmt, elekLog.InfoLevel, - elekLog.Fields{"host": fmt.Sprintf("%s", offer.GetHostname())}, "TASKS STARTING...") + elektronLogging.ElektronLog.Log(lmt, log.InfoLevel, + log.Fields{"host": fmt.Sprintf("%s", offer.GetHostname())}, "TASKS STARTING...") } else { elektronLogging.ElektronLog.Log(lmt, - elekLog.InfoLevel, - elekLog.Fields{"task": fmt.Sprintf("%s", ts.Name), + log.InfoLevel, + log.Fields{"task": fmt.Sprintf("%s", ts.Name), "Instance": fmt.Sprintf("%d", *ts.Instances), "host": fmt.Sprintf("%s", offer.GetHostname())}, "TASK STARTING... ") } @@ -265,29 +265,29 @@ func (s *BaseScheduler) LogTaskStarting(ts *def.Task, offer *mesos.Offer) { func (s *BaseScheduler) LogTaskWattsConsideration(ts def.Task, host string, wattsToConsider float64) { lmt := elekLogTypes.GENERAL elektronLogging.ElektronLog.Log(lmt, - elekLog.InfoLevel, - elekLog.Fields{"task": ts.Name, "host": host, "Watts": fmt.Sprintf("%f", wattsToConsider)}, "Watts considered for ") + log.InfoLevel, + log.Fields{"task": ts.Name, "host": host, "Watts": fmt.Sprintf("%f", wattsToConsider)}, "Watts considered for ") } func (s *BaseScheduler) LogOffersReceived(offers []*mesos.Offer) { lmt := elekLogTypes.GENERAL elektronLogging.ElektronLog.Log(lmt, - elekLog.InfoLevel, - elekLog.Fields{"Resource offers received": fmt.Sprintf("%d", len(offers))}, "") + log.InfoLevel, + log.Fields{"Resource offers received": fmt.Sprintf("%d", len(offers))}, "") } func (s *BaseScheduler) LogNoPendingTasksDeclineOffers(offer *mesos.Offer) { lmt := elekLogTypes.WARNING elektronLogging.ElektronLog.Log(lmt, - elekLog.WarnLevel, - elekLog.Fields{"DECLINING OFFER for host": fmt.Sprintf("%s", offer.GetHostname())}, "No tasks left to schedule ") + log.WarnLevel, + log.Fields{"DECLINING OFFER for host": fmt.Sprintf("%s", offer.GetHostname())}, "No tasks left to schedule ") } func (s *BaseScheduler) LogNumberOfRunningTasks() { lmt := elekLogTypes.GENERAL elektronLogging.ElektronLog.Log(lmt, - elekLog.InfoLevel, - elekLog.Fields{"Number of tasks still Running": fmt.Sprintf("%d", s.tasksRunning)}, "") + log.InfoLevel, + log.Fields{"Number of tasks still Running": fmt.Sprintf("%d", s.tasksRunning)}, "") } func (s *BaseScheduler) LogCoLocatedTasks(slaveID string) { @@ -299,21 +299,21 @@ func (s *BaseScheduler) LogCoLocatedTasks(slaveID string) { } s.TasksRunningMutex.Unlock() elektronLogging.ElektronLog.Log(lmt, - elekLog.InfoLevel, - elekLog.Fields{"Colocated with": fmt.Sprintf("%s", buffer.String())}, "") + log.InfoLevel, + log.Fields{"Colocated with": fmt.Sprintf("%s", buffer.String())}, "") } func (s *BaseScheduler) LogSchedTrace(taskToSchedule *mesos.TaskInfo, offer *mesos.Offer) { elektronLogging.ElektronLog.Log(elekLogTypes.SCHED_TRACE, - elekLog.InfoLevel, - elekLog.Fields{offer.GetHostname(): fmt.Sprintf("%s", taskToSchedule.GetTaskId().GetValue())}, "") + log.InfoLevel, + log.Fields{offer.GetHostname(): fmt.Sprintf("%s", taskToSchedule.GetTaskId().GetValue())}, "") } func (s *BaseScheduler) LogTerminateScheduler() { lmt := elekLogTypes.GENERAL elektronLogging.ElektronLog.Log(lmt, - elekLog.InfoLevel, - elekLog.Fields{}, "Done scheduling all tasks!") + log.InfoLevel, + log.Fields{}, "Done scheduling all tasks!") } func (s *BaseScheduler) LogInsufficientResourcesDeclineOffer(offer *mesos.Offer, @@ -322,73 +322,73 @@ func (s *BaseScheduler) LogInsufficientResourcesDeclineOffer(offer *mesos.Offer, buffer := bytes.Buffer{} buffer.WriteString(fmt.Sprintf("", offerResources...)) elektronLogging.ElektronLog.Log(lmt, - elekLog.WarnLevel, - elekLog.Fields{"Offer Resources": fmt.Sprintf("%s", buffer.String())}, "DECLINING OFFER... Offer has insufficient resources to launch a task") + log.WarnLevel, + log.Fields{"Offer Resources": fmt.Sprintf("%s", buffer.String())}, "DECLINING OFFER... Offer has insufficient resources to launch a task") } func (s *BaseScheduler) LogOfferRescinded(offerID *mesos.OfferID) { lmt := elekLogTypes.ERROR elektronLogging.ElektronLog.Log(lmt, - elekLog.ErrorLevel, - elekLog.Fields{"OfferID": fmt.Sprintf("%s", offerID)}, "OFFER RESCINDED") + log.ErrorLevel, + log.Fields{"OfferID": fmt.Sprintf("%s", offerID)}, "OFFER RESCINDED") } func (s *BaseScheduler) LogSlaveLost(slaveID *mesos.SlaveID) { lmt := elekLogTypes.ERROR elektronLogging.ElektronLog.Log(lmt, - elekLog.ErrorLevel, - elekLog.Fields{"SlaveID": fmt.Sprintf("%s", slaveID)}, "SLAVE LOST") + log.ErrorLevel, + log.Fields{"SlaveID": fmt.Sprintf("%s", slaveID)}, "SLAVE LOST") } func (s *BaseScheduler) LogExecutorLost(executorID *mesos.ExecutorID, slaveID *mesos.SlaveID) { lmt := elekLogTypes.ERROR elektronLogging.ElektronLog.Log(lmt, - elekLog.ErrorLevel, - elekLog.Fields{"ExecutorID": fmt.Sprintf("%s", executorID), "SlaveID": fmt.Sprintf("%s", slaveID)}, "EXECUTOR LOST") + log.ErrorLevel, + log.Fields{"ExecutorID": fmt.Sprintf("%s", executorID), "SlaveID": fmt.Sprintf("%s", slaveID)}, "EXECUTOR LOST") } func (s *BaseScheduler) LogFrameworkMessage(executorID *mesos.ExecutorID, slaveID *mesos.SlaveID, message string) { lmt := elekLogTypes.GENERAL elektronLogging.ElektronLog.Log(lmt, - elekLog.InfoLevel, - elekLog.Fields{"Received Framework message from executor": executorID}, message) + log.InfoLevel, + log.Fields{"Received Framework message from executor": executorID}, message) } func (s *BaseScheduler) LogMesosError(err string) { lmt := elekLogTypes.ERROR elektronLogging.ElektronLog.Log(lmt, - elekLog.ErrorLevel, - elekLog.Fields{"MESOS ERROR": fmt.Sprintf("%v", err)}, "") + log.ErrorLevel, + log.Fields{"MESOS ERROR": fmt.Sprintf("%v", err)}, "") } func (s *BaseScheduler) LogElectronError(err error) { lmt := elekLogTypes.ERROR elektronLogging.ElektronLog.Log(lmt, - elekLog.ErrorLevel, - elekLog.Fields{"ELECTRON ERROR": fmt.Sprintf("%v", err)}, "") + log.ErrorLevel, + log.Fields{"ELECTRON ERROR": fmt.Sprintf("%v", err)}, "") } func (s *BaseScheduler) LogFrameworkRegistered(frameworkID *mesos.FrameworkID, masterInfo *mesos.MasterInfo) { lmt := elekLogTypes.SUCCESS elektronLogging.ElektronLog.Log(lmt, - elekLog.InfoLevel, - elekLog.Fields{"frameworkID": fmt.Sprintf("%s", frameworkID), "master": fmt.Sprintf("%s", masterInfo)}, "FRAMEWORK REGISTERED!") + log.InfoLevel, + log.Fields{"frameworkID": fmt.Sprintf("%s", frameworkID), "master": fmt.Sprintf("%s", masterInfo)}, "FRAMEWORK REGISTERED!") } func (s *BaseScheduler) LogFrameworkReregistered(masterInfo *mesos.MasterInfo) { lmt := elekLogTypes.GENERAL elektronLogging.ElektronLog.Log(lmt, - elekLog.InfoLevel, - elekLog.Fields{"master": fmt.Sprintf("%s", masterInfo)}, "Framework re-registered") + log.InfoLevel, + log.Fields{"master": fmt.Sprintf("%s", masterInfo)}, "Framework re-registered") } func (s *BaseScheduler) LogDisconnected() { lmt := elekLogTypes.WARNING elektronLogging.ElektronLog.Log(lmt, - elekLog.WarnLevel, - elekLog.Fields{}, "Framework disconnected with master") + log.WarnLevel, + log.Fields{}, "Framework disconnected with master") } func (s *BaseScheduler) LogTaskStatusUpdate(status *mesos.TaskStatus) { @@ -403,15 +403,15 @@ func (s *BaseScheduler) LogTaskStatusUpdate(status *mesos.TaskStatus) { lmt = elekLogTypes.GENERAL } elektronLogging.ElektronLog.Log(lmt, - elekLog.InfoLevel, - elekLog.Fields{"task": fmt.Sprintf("%s", *status.TaskId.Value), "state": NameFor(status.State)}, "Task Status received") + log.InfoLevel, + log.Fields{"task": fmt.Sprintf("%s", *status.TaskId.Value), "state": NameFor(status.State)}, "Task Status received") } func (s *BaseScheduler) LogSchedPolicySwitch(name string, nextPolicy SchedPolicyState) { logSPS := func() { elektronLogging.ElektronLog.Log(elekLogTypes.SPS, - elekLog.InfoLevel, - elekLog.Fields{"Name": name}, "") + log.InfoLevel, + log.Fields{"Name": name}, "") } if s.hasReceivedResourceOffers && (s.curSchedPolicy != nextPolicy) { logSPS() @@ -421,13 +421,13 @@ func (s *BaseScheduler) LogSchedPolicySwitch(name string, nextPolicy SchedPolicy // Logging the size of the scheduling window and the scheduling policy // that is going to schedule the tasks in the scheduling window. elektronLogging.ElektronLog.Log(elekLogTypes.SCHED_WINDOW, - elekLog.InfoLevel, - elekLog.Fields{"Window size": fmt.Sprintf("%d", s.schedWindowSize), "Name": name}, "") + log.InfoLevel, + log.Fields{"Window size": fmt.Sprintf("%d", s.schedWindowSize), "Name": name}, "") } func (s *BaseScheduler) LogClsfnAndTaskDistOverhead(overhead time.Duration) { // Logging the overhead in microseconds. elektronLogging.ElektronLog.Log(elekLogTypes.CLSFN_TASKDIST_OVERHEAD, - elekLog.InfoLevel, - elekLog.Fields{"Overhead in microseconds": fmt.Sprintf("%f", float64(overhead.Nanoseconds())/1000.0)}, "") + log.InfoLevel, + log.Fields{"Overhead in microseconds": fmt.Sprintf("%f", float64(overhead.Nanoseconds())/1000.0)}, "") } diff --git a/schedulers/bin-packing.go b/schedulers/bin-packing.go index 42729f5..8bd90fb 100644 --- a/schedulers/bin-packing.go +++ b/schedulers/bin-packing.go @@ -19,7 +19,7 @@ package schedulers import ( - elekLog "github.com/sirupsen/logrus" + log "github.com/sirupsen/logrus" mesos "github.com/mesos/mesos-go/api/v0/mesosproto" sched "github.com/mesos/mesos-go/api/v0/scheduler" @@ -39,7 +39,7 @@ func (s *BinPackSortedWatts) takeOffer(spc SchedPolicyContext, offer *mesos.Offe wattsConsideration, err := def.WattsToConsider(task, baseSchedRef.classMapWatts, offer) if err != nil { // Error in determining wattsConsideration. - elekLog.Fatal(err) + log.Fatal(err) } if (cpus >= (totalCPU + task.CPU)) && (mem >= (totalRAM + task.RAM)) && (!baseSchedRef.wattsAsAResource || (watts >= (totalWatts + wattsConsideration))) { @@ -83,7 +83,7 @@ func (s *BinPackSortedWatts) ConsumeOffers(spc SchedPolicyContext, driver sched. wattsConsideration, err := def.WattsToConsider(task, baseSchedRef.classMapWatts, offer) if err != nil { // Error in determining wattsConsideration. - elekLog.Fatal(err) + log.Fatal(err) } // Don't take offer if it doesn't match our task's host requirement. diff --git a/schedulers/helpers.go b/schedulers/helpers.go index 39317f1..8a2f532 100644 --- a/schedulers/helpers.go +++ b/schedulers/helpers.go @@ -23,7 +23,7 @@ import ( mesos "github.com/mesos/mesos-go/api/v0/mesosproto" sched "github.com/mesos/mesos-go/api/v0/scheduler" "github.com/pkg/errors" - elekLog "github.com/sirupsen/logrus" + log "github.com/sirupsen/logrus" "github.com/spdfg/elektron/constants" "github.com/spdfg/elektron/def" "github.com/spdfg/elektron/elektronLogging" @@ -36,13 +36,13 @@ func coLocated(tasks map[string]bool, s BaseScheduler) { for task := range tasks { elektronLogging.ElektronLog.Log(elekLogTypes.GENERAL, - elekLog.InfoLevel, - elekLog.Fields{"Task": task}, "") + log.InfoLevel, + log.Fields{"Task": task}, "") } elektronLogging.ElektronLog.Log(elekLogTypes.GENERAL, - elekLog.InfoLevel, - elekLog.Fields{}, "---------------------") + log.InfoLevel, + log.Fields{}, "---------------------") } // Get the powerClass of the given hostname. @@ -157,7 +157,7 @@ func WithSchedPolSwitchEnabled(enableSchedPolicySwitch bool, switchingCriteria s func WithNameOfFirstSchedPolToFix(nameOfFirstSchedPol string) SchedulerOptions { return func(s ElectronScheduler) error { if nameOfFirstSchedPol == "" { - elekLog.Println("First scheduling policy to deploy not mentioned. This is now" + + log.Println("First scheduling policy to deploy not mentioned. This is now" + " going to be determined at runtime.") return nil } @@ -175,7 +175,7 @@ func WithFixedSchedulingWindow(toFixSchedWindow bool, fixedSchedWindowSize int) if fixedSchedWindowSize <= 0 { return errors.New("Invalid value of scheduling window size. Please provide a value > 0.") } - elekLog.Println(fmt.Sprintf("Fixing the size of the scheduling window to %d.."+ + log.Println(fmt.Sprintf("Fixing the size of the scheduling window to %d.."+ ".", fixedSchedWindowSize)) s.(*BaseScheduler).toFixSchedWindow = toFixSchedWindow s.(*BaseScheduler).schedWindowSize = fixedSchedWindowSize diff --git a/schedulers/schedPolicy.go b/schedulers/schedPolicy.go index c477ba7..e4716d7 100644 --- a/schedulers/schedPolicy.go +++ b/schedulers/schedPolicy.go @@ -24,7 +24,7 @@ import ( mesos "github.com/mesos/mesos-go/api/v0/mesosproto" sched "github.com/mesos/mesos-go/api/v0/scheduler" - elekLog "github.com/sirupsen/logrus" + log "github.com/sirupsen/logrus" "github.com/spdfg/elektron/def" "github.com/spdfg/elektron/elektronLogging" elekLogTypes "github.com/spdfg/elektron/elektronLogging/types" @@ -91,8 +91,8 @@ func switchTaskDistBased(baseSchedRef *BaseScheduler) string { taskDist, err := def.GetTaskDistributionInWindow(baseSchedRef.schedWindowSize, baseSchedRef.tasks) baseSchedRef.LogClsfnAndTaskDistOverhead(time.Now().Sub(startTime)) elektronLogging.ElektronLog.Log(elekLogTypes.GENERAL, - elekLog.InfoLevel, - elekLog.Fields{"Task Distribution": fmt.Sprintf("%f", taskDist)}, "Switching... ") + log.InfoLevel, + log.Fields{"Task Distribution": fmt.Sprintf("%f", taskDist)}, "Switching... ") if err != nil { // All the tasks in the window were only classified into 1 cluster. // Max-Min and Max-GreedyMins would work the same way as Bin-Packing for this situation. @@ -220,8 +220,8 @@ func (bsps *baseSchedPolicyState) SwitchIfNecessary(spc SchedPolicyContext) { switchToPolicyName = switchBasedOn[baseSchedRef.schedPolSwitchCriteria](baseSchedRef) } else { // We continue working with the currently deployed scheduling policy. - elekLog.Println("Continuing with the current scheduling policy...") - elekLog.Printf("TasksScheduled[%d], SchedWindowSize[%d]", bsps.numTasksScheduled, + log.Println("Continuing with the current scheduling policy...") + log.Printf("TasksScheduled[%d], SchedWindowSize[%d]", bsps.numTasksScheduled, baseSchedRef.schedWindowSize) return } @@ -234,8 +234,8 @@ func (bsps *baseSchedPolicyState) SwitchIfNecessary(spc SchedPolicyContext) { bsps.numTasksScheduled = 0 } else { // We continue working with the currently deployed scheduling policy. - elekLog.Println("Continuing with the current scheduling policy...") - elekLog.Printf("TasksScheduled[%d], SchedWindowSize[%d]", bsps.numTasksScheduled, + log.Println("Continuing with the current scheduling policy...") + log.Printf("TasksScheduled[%d], SchedWindowSize[%d]", bsps.numTasksScheduled, baseSchedRef.schedWindowSize) return } diff --git a/utilities/offerUtils/offerUtils.go b/utilities/offerUtils/offerUtils.go index cd8cc89..a3062d8 100644 --- a/utilities/offerUtils/offerUtils.go +++ b/utilities/offerUtils/offerUtils.go @@ -21,7 +21,7 @@ package offerUtils import ( "fmt" mesos "github.com/mesos/mesos-go/api/v0/mesosproto" - elekLog "github.com/sirupsen/logrus" + log "github.com/sirupsen/logrus" "github.com/spdfg/elektron/constants" "github.com/spdfg/elektron/elektronLogging" elekLogTypes "github.com/spdfg/elektron/elektronLogging/types" @@ -90,14 +90,14 @@ func UpdateEnvironment(offer *mesos.Offer) { var host = offer.GetHostname() // If this host is not present in the set of hosts. if _, ok := constants.Hosts[host]; !ok { - elektronLogging.ElektronLog.Log(elekLogTypes.GENERAL, elekLog.InfoLevel, - elekLog.Fields{"Adding host": fmt.Sprintf("%s", host)}, "New host detected") + elektronLogging.ElektronLog.Log(elekLogTypes.GENERAL, log.InfoLevel, + log.Fields{"Adding host": fmt.Sprintf("%s", host)}, "New host detected") // Add this host. constants.Hosts[host] = struct{}{} // Get the power class of this host. class := PowerClass(offer) - elektronLogging.ElektronLog.Log(elekLogTypes.GENERAL, elekLog.InfoLevel, - elekLog.Fields{"host": fmt.Sprintf("%s", host), "PowerClass": fmt.Sprintf("%s", class)}, "Registering the power class...") + elektronLogging.ElektronLog.Log(elekLogTypes.GENERAL, log.InfoLevel, + log.Fields{"host": fmt.Sprintf("%s", host), "PowerClass": fmt.Sprintf("%s", class)}, "Registering the power class...") // If new power class, register the power class. if _, ok := constants.PowerClasses[class]; !ok { constants.PowerClasses[class] = make(map[string]struct{}) diff --git a/utilities/schedUtils/schedUtils.go b/utilities/schedUtils/schedUtils.go index c24b02d..ffa3124 100644 --- a/utilities/schedUtils/schedUtils.go +++ b/utilities/schedUtils/schedUtils.go @@ -20,7 +20,7 @@ package schedUtils import ( "fmt" - elekLog "github.com/sirupsen/logrus" + log "github.com/sirupsen/logrus" "github.com/spdfg/elektron/def" "github.com/spdfg/elektron/elektronLogging" elekLogTypes "github.com/spdfg/elektron/elektronLogging/types" @@ -79,8 +79,8 @@ func (s *fillNextOfferCycle) apply(taskQueue []def.Task) (int, int) { for _, task := range taskQueue { numberOfTasksTraversed++ for i := *task.Instances; i > 0; i-- { - elektronLogging.ElektronLog.Log(elekLogTypes.GENERAL, elekLog.InfoLevel, - elekLog.Fields{}, fmt.Sprintf("Checking if Instance #%d of Task[%s] can be scheduled "+ + elektronLogging.ElektronLog.Log(elekLogTypes.GENERAL, log.InfoLevel, + log.Fields{}, fmt.Sprintf("Checking if Instance #%d of Task[%s] can be scheduled "+ "during the next offer cycle...", i, task.Name)) if canSchedule(task) { filledCPU += task.CPU -- 2.47.2 From 268df3cd51b51665089c3dde003b7c1a5685e2da Mon Sep 17 00:00:00 2001 From: balandi1 Date: Thu, 21 Nov 2019 14:35:20 -0500 Subject: [PATCH 13/48] Changed alias for elektronLogging to elekLog --- def/taskUtils.go | 6 ++-- pcp/pcp.go | 10 +++---- powerCap/extrema.go | 28 ++++++++--------- powerCap/progressiveExtrema.go | 46 ++++++++++++++-------------- scheduler.go | 8 ++--- schedulers/base.go | 48 +++++++++++++++--------------- schedulers/helpers.go | 6 ++-- schedulers/schedPolicy.go | 4 +-- utilities/offerUtils/offerUtils.go | 6 ++-- utilities/schedUtils/schedUtils.go | 4 +-- 10 files changed, 83 insertions(+), 83 deletions(-) diff --git a/def/taskUtils.go b/def/taskUtils.go index cb93afa..9556e06 100644 --- a/def/taskUtils.go +++ b/def/taskUtils.go @@ -26,7 +26,7 @@ import ( "github.com/mash/gokmeans" "github.com/montanaflynn/stats" log "github.com/sirupsen/logrus" - "github.com/spdfg/elektron/elektronLogging" + elekLog "github.com/spdfg/elektron/elektronLogging" elekLogTypes "github.com/spdfg/elektron/elektronLogging/types" ) @@ -52,7 +52,7 @@ func (tc TasksToClassify) taskObservationCalculator(task Task) []float64 { } else if task.Watts != 0.0 { return []float64{task.Watts} } else { - elektronLogging.ElektronLog.Log(elekLogTypes.ERROR, log.FatalLevel, + elekLog.ElektronLog.Log(elekLogTypes.ERROR, log.FatalLevel, log.Fields{}, "Unable to classify tasks. Missing Watts or ClassToWatts attribute in workload") return []float64{0.0} // Won't reach here. } @@ -108,7 +108,7 @@ func clusterSizeAvgMMMPU(tasks []Task, taskObservation func(task Task) []float64 } else { // skip this value // there is an error in the task config. - elektronLogging.ElektronLog.Log(elekLogTypes.ERROR, log.ErrorLevel, + elekLog.ElektronLog.Log(elekLogTypes.ERROR, log.ErrorLevel, log.Fields{}, fmt.Sprintf("%s", err)) } } else { diff --git a/pcp/pcp.go b/pcp/pcp.go index f1ff505..010cf09 100644 --- a/pcp/pcp.go +++ b/pcp/pcp.go @@ -25,7 +25,7 @@ import ( "time" log "github.com/sirupsen/logrus" - "github.com/spdfg/elektron/elektronLogging" + elekLog "github.com/spdfg/elektron/elektronLogging" elekLogT "github.com/spdfg/elektron/elektronLogging/types" ) @@ -47,7 +47,7 @@ func Start(quit chan struct{}, logging *bool, pcpConfigFile string) { scanner.Scan() // Write to logfile - elektronLogging.ElektronLog.Log(elekLogT.PCP, + elekLog.ElektronLog.Log(elekLogT.PCP, log.InfoLevel, log.Fields{}, scanner.Text()) @@ -60,7 +60,7 @@ func Start(quit chan struct{}, logging *bool, pcpConfigFile string) { text := scanner.Text() if *logging { - elektronLogging.ElektronLog.Log(elekLogT.PCP, + elekLog.ElektronLog.Log(elekLogT.PCP, log.InfoLevel, log.Fields{}, text) } @@ -69,7 +69,7 @@ func Start(quit chan struct{}, logging *bool, pcpConfigFile string) { } }(logging) - elektronLogging.ElektronLog.Log(elekLogT.GENERAL, + elekLog.ElektronLog.Log(elekLogT.GENERAL, log.InfoLevel, log.Fields{}, "PCP logging started") @@ -81,7 +81,7 @@ func Start(quit chan struct{}, logging *bool, pcpConfigFile string) { select { case <-quit: - elektronLogging.ElektronLog.Log(elekLogT.GENERAL, + elekLog.ElektronLog.Log(elekLogT.GENERAL, log.InfoLevel, log.Fields{}, "Stopping PCP logging in 5 seconds") time.Sleep(5 * time.Second) diff --git a/powerCap/extrema.go b/powerCap/extrema.go index 83e76b4..2e202eb 100644 --- a/powerCap/extrema.go +++ b/powerCap/extrema.go @@ -30,7 +30,7 @@ import ( "time" log "github.com/sirupsen/logrus" - "github.com/spdfg/elektron/elektronLogging" + elekLog "github.com/spdfg/elektron/elektronLogging" elekLogTypes "github.com/spdfg/elektron/elektronLogging/types" "github.com/spdfg/elektron/pcp" "github.com/spdfg/elektron/rapl" @@ -43,7 +43,7 @@ func StartPCPLogAndExtremaDynamicCap(quit chan struct{}, logging *bool, hiThresh cmd.SysProcAttr = &syscall.SysProcAttr{Setpgid: true} if hiThreshold < loThreshold { - elektronLogging.ElektronLog.Log(elekLogTypes.GENERAL, + elekLog.ElektronLog.Log(elekLogTypes.GENERAL, log.InfoLevel, log.Fields{}, "High threshold is lower than low threshold!") } @@ -61,7 +61,7 @@ func StartPCPLogAndExtremaDynamicCap(quit chan struct{}, logging *bool, hiThresh scanner.Scan() // Write to logfile - elektronLogging.ElektronLog.Log(elekLogTypes.PCP, + elekLog.ElektronLog.Log(elekLogTypes.PCP, log.InfoLevel, log.Fields{}, scanner.Text()) @@ -99,14 +99,14 @@ func StartPCPLogAndExtremaDynamicCap(quit chan struct{}, logging *bool, hiThresh if *logging { - elektronLogging.ElektronLog.Log(elekLogTypes.GENERAL, + elekLog.ElektronLog.Log(elekLogTypes.GENERAL, log.InfoLevel, log.Fields{}, "Logging PCP...") text := scanner.Text() split := strings.Split(text, ",") - elektronLogging.ElektronLog.Log(elekLogTypes.PCP, + elekLog.ElektronLog.Log(elekLogTypes.PCP, log.InfoLevel, log.Fields{}, text) @@ -119,7 +119,7 @@ func StartPCPLogAndExtremaDynamicCap(quit chan struct{}, logging *bool, hiThresh powerHistories[host].Value = power powerHistories[host] = powerHistories[host].Next() - elektronLogging.ElektronLog.Log(elekLogTypes.GENERAL, + elekLog.ElektronLog.Log(elekLogTypes.GENERAL, log.InfoLevel, log.Fields{"Host": fmt.Sprintf("%s", indexToHost[powerIndex]), "Power": fmt.Sprintf("%f", (power * pcp.RAPLUnits))}, "") @@ -133,14 +133,14 @@ func StartPCPLogAndExtremaDynamicCap(quit chan struct{}, logging *bool, hiThresh clusterMean := pcp.AverageClusterPowerHistory(clusterPowerHist) - elektronLogging.ElektronLog.Log(elekLogTypes.GENERAL, + elekLog.ElektronLog.Log(elekLogTypes.GENERAL, log.InfoLevel, log.Fields{"Total power": fmt.Sprintf("%f %d", clusterPower, clusterPowerHist.Len()), "Sec Avg": fmt.Sprintf("%f", clusterMean)}, "") if clusterMean > hiThreshold { - elektronLogging.ElektronLog.Log(elekLogTypes.GENERAL, + elekLog.ElektronLog.Log(elekLogTypes.GENERAL, log.InfoLevel, log.Fields{}, "Need to cap a node") // Create statics for all victims and choose one to cap @@ -163,12 +163,12 @@ func StartPCPLogAndExtremaDynamicCap(quit chan struct{}, logging *bool, hiThresh if !cappedHosts[victim.Host] { cappedHosts[victim.Host] = true orderCapped = append(orderCapped, victim.Host) - elektronLogging.ElektronLog.Log(elekLogTypes.GENERAL, + elekLog.ElektronLog.Log(elekLogTypes.GENERAL, log.InfoLevel, log.Fields{"Capping Victim": fmt.Sprintf("%s", victim.Host), "Avg. Wattage": fmt.Sprintf("%f", victim.Watts*pcp.RAPLUnits)}, "") if err := rapl.Cap(victim.Host, "rapl", 50); err != nil { - elektronLogging.ElektronLog.Log(elekLogTypes.ERROR, + elekLog.ElektronLog.Log(elekLogTypes.ERROR, log.ErrorLevel, log.Fields{}, "Error capping host") } @@ -184,11 +184,11 @@ func StartPCPLogAndExtremaDynamicCap(quit chan struct{}, logging *bool, hiThresh cappedHosts[host] = false // User RAPL package to send uncap. log.Printf("Uncapping host %s", host) - elektronLogging.ElektronLog.Log(elekLogTypes.GENERAL, + elekLog.ElektronLog.Log(elekLogTypes.GENERAL, log.InfoLevel, log.Fields{"Uncapped host": host}, "") if err := rapl.Cap(host, "rapl", 100); err != nil { - elektronLogging.ElektronLog.Log(elekLogTypes.ERROR, + elekLog.ElektronLog.Log(elekLogTypes.ERROR, log.ErrorLevel, log.Fields{}, "Error capping host") } @@ -200,7 +200,7 @@ func StartPCPLogAndExtremaDynamicCap(quit chan struct{}, logging *bool, hiThresh } }(logging, hiThreshold, loThreshold) - elektronLogging.ElektronLog.Log(elekLogTypes.GENERAL, + elekLog.ElektronLog.Log(elekLogTypes.GENERAL, log.InfoLevel, log.Fields{}, "PCP logging started") @@ -212,7 +212,7 @@ func StartPCPLogAndExtremaDynamicCap(quit chan struct{}, logging *bool, hiThresh select { case <-quit: - elektronLogging.ElektronLog.Log(elekLogTypes.GENERAL, + elekLog.ElektronLog.Log(elekLogTypes.GENERAL, log.InfoLevel, log.Fields{}, "Stopping PCP logging in 5 seconds") time.Sleep(5 * time.Second) diff --git a/powerCap/progressiveExtrema.go b/powerCap/progressiveExtrema.go index 034376f..9fba626 100644 --- a/powerCap/progressiveExtrema.go +++ b/powerCap/progressiveExtrema.go @@ -32,7 +32,7 @@ import ( log "github.com/sirupsen/logrus" "github.com/spdfg/elektron/constants" - "github.com/spdfg/elektron/elektronLogging" + elekLog "github.com/spdfg/elektron/elektronLogging" elekLogTypes "github.com/spdfg/elektron/elektronLogging/types" "github.com/spdfg/elektron/pcp" "github.com/spdfg/elektron/rapl" @@ -56,7 +56,7 @@ func StartPCPLogAndProgressiveExtremaCap(quit chan struct{}, logging *bool, hiTh cmd.SysProcAttr = &syscall.SysProcAttr{Setpgid: true} if hiThreshold < loThreshold { - elektronLogging.ElektronLog.Log(elekLogTypes.GENERAL, + elekLog.ElektronLog.Log(elekLogTypes.GENERAL, log.InfoLevel, log.Fields{}, "High threshold is lower than low threshold!") } @@ -74,7 +74,7 @@ func StartPCPLogAndProgressiveExtremaCap(quit chan struct{}, logging *bool, hiTh scanner.Scan() // Write to logfile - elektronLogging.ElektronLog.Log(elekLogTypes.PCP, + elekLog.ElektronLog.Log(elekLogTypes.PCP, log.InfoLevel, log.Fields{}, scanner.Text()) @@ -115,13 +115,13 @@ func StartPCPLogAndProgressiveExtremaCap(quit chan struct{}, logging *bool, hiTh for scanner.Scan() { if *logging { - elektronLogging.ElektronLog.Log(elekLogTypes.GENERAL, + elekLog.ElektronLog.Log(elekLogTypes.GENERAL, log.InfoLevel, log.Fields{}, "Logging PCP...") split := strings.Split(scanner.Text(), ",") text := scanner.Text() - elektronLogging.ElektronLog.Log(elekLogTypes.PCP, + elekLog.ElektronLog.Log(elekLogTypes.PCP, log.InfoLevel, log.Fields{}, text) @@ -134,7 +134,7 @@ func StartPCPLogAndProgressiveExtremaCap(quit chan struct{}, logging *bool, hiTh powerHistories[host].Value = power powerHistories[host] = powerHistories[host].Next() - elektronLogging.ElektronLog.Log(elekLogTypes.GENERAL, + elekLog.ElektronLog.Log(elekLogTypes.GENERAL, log.InfoLevel, log.Fields{"Host": fmt.Sprintf("%s", indexToHost[powerIndex]), "Power": fmt.Sprintf("%f", (power * pcp.RAPLUnits))}, "") @@ -147,22 +147,22 @@ func StartPCPLogAndProgressiveExtremaCap(quit chan struct{}, logging *bool, hiTh clusterMean := pcp.AverageClusterPowerHistory(clusterPowerHist) - elektronLogging.ElektronLog.Log(elekLogTypes.GENERAL, + elekLog.ElektronLog.Log(elekLogTypes.GENERAL, log.InfoLevel, log.Fields{"Total power": fmt.Sprintf("%f %d", clusterPower, clusterPowerHist.Len()), "Sec Avg": fmt.Sprintf("%f", clusterMean)}, "") if clusterMean >= hiThreshold { - elektronLogging.ElektronLog.Log(elekLogTypes.GENERAL, + elekLog.ElektronLog.Log(elekLogTypes.GENERAL, log.InfoLevel, log.Fields{}, "Need to cap a node") - elektronLogging.ElektronLog.Log(elekLogTypes.GENERAL, + elekLog.ElektronLog.Log(elekLogTypes.GENERAL, log.InfoLevel, log.Fields{"Cap values of capped victims": fmt.Sprintf("%v", cappedVictims)}, "") - elektronLogging.ElektronLog.Log(elekLogTypes.GENERAL, + elekLog.ElektronLog.Log(elekLogTypes.GENERAL, log.InfoLevel, log.Fields{"Cap values of victims to uncap": fmt.Sprintf("%v", orderCappedVictims)}, "") // Create statics for all victims and choose one to cap @@ -192,12 +192,12 @@ func StartPCPLogAndProgressiveExtremaCap(quit chan struct{}, logging *bool, hiTh // Need to cap this victim. if err := rapl.Cap(victims[i].Host, "rapl", 50.0); err != nil { - elektronLogging.ElektronLog.Log(elekLogTypes.ERROR, + elekLog.ElektronLog.Log(elekLogTypes.ERROR, log.ErrorLevel, log.Fields{"Error capping host": fmt.Sprintf("%s", victims[i].Host)}, "") } else { - elektronLogging.ElektronLog.Log(elekLogTypes.GENERAL, + elekLog.ElektronLog.Log(elekLogTypes.GENERAL, log.InfoLevel, log.Fields{}, fmt.Sprintf("Capped host[%s] at %f", victims[i].Host, 50.0)) // Keeping track of this victim and it's cap value @@ -223,12 +223,12 @@ func StartPCPLogAndProgressiveExtremaCap(quit chan struct{}, logging *bool, hiTh newCapValue := getNextCapValue(capValue, 2) if err := rapl.Cap(alreadyCappedHosts[i], "rapl", newCapValue); err != nil { - elektronLogging.ElektronLog.Log(elekLogTypes.ERROR, + elekLog.ElektronLog.Log(elekLogTypes.ERROR, log.ErrorLevel, log.Fields{"Error capping host": fmt.Sprintf("%s", alreadyCappedHosts[i])}, "") } else { // Successful cap - elektronLogging.ElektronLog.Log(elekLogTypes.GENERAL, + elekLog.ElektronLog.Log(elekLogTypes.GENERAL, log.InfoLevel, log.Fields{}, fmt.Sprintf("Capped host[%s] at %f", alreadyCappedHosts[i], newCapValue)) // Checking whether this victim can be capped further @@ -253,7 +253,7 @@ func StartPCPLogAndProgressiveExtremaCap(quit chan struct{}, logging *bool, hiTh } } if !canCapAlreadyCappedVictim { - elektronLogging.ElektronLog.Log(elekLogTypes.GENERAL, + elekLog.ElektronLog.Log(elekLogTypes.GENERAL, log.InfoLevel, log.Fields{}, "No Victim left to cap") } @@ -261,13 +261,13 @@ func StartPCPLogAndProgressiveExtremaCap(quit chan struct{}, logging *bool, hiTh } else if clusterMean < loThreshold { - elektronLogging.ElektronLog.Log(elekLogTypes.GENERAL, + elekLog.ElektronLog.Log(elekLogTypes.GENERAL, log.InfoLevel, log.Fields{}, "Need to uncap a node") - elektronLogging.ElektronLog.Log(elekLogTypes.GENERAL, + elekLog.ElektronLog.Log(elekLogTypes.GENERAL, log.InfoLevel, log.Fields{"Cap values of capped victims": fmt.Sprintf("%v", cappedVictims)}, "") - elektronLogging.ElektronLog.Log(elekLogTypes.GENERAL, + elekLog.ElektronLog.Log(elekLogTypes.GENERAL, log.InfoLevel, log.Fields{"Cap values of victims to uncap": fmt.Sprintf("%v", orderCappedVictims)}, "") if len(orderCapped) > 0 { @@ -280,12 +280,12 @@ func StartPCPLogAndProgressiveExtremaCap(quit chan struct{}, logging *bool, hiTh newUncapValue := orderCappedVictims[hostToUncap] * 2.0 if err := rapl.Cap(hostToUncap, "rapl", newUncapValue); err != nil { - elektronLogging.ElektronLog.Log(elekLogTypes.ERROR, + elekLog.ElektronLog.Log(elekLogTypes.ERROR, log.ErrorLevel, log.Fields{"Error uncapping host": fmt.Sprintf("%s", hostToUncap)}, "") } else { // Successful uncap - elektronLogging.ElektronLog.Log(elekLogTypes.GENERAL, + elekLog.ElektronLog.Log(elekLogTypes.GENERAL, log.InfoLevel, log.Fields{}, fmt.Sprintf("Uncapped host[%s] to %f", hostToUncap, newUncapValue)) // Can we uncap this host further. If not, then we remove its entry from orderCapped @@ -308,7 +308,7 @@ func StartPCPLogAndProgressiveExtremaCap(quit chan struct{}, logging *bool, hiTh } } } else { - elektronLogging.ElektronLog.Log(elekLogTypes.GENERAL, + elekLog.ElektronLog.Log(elekLogTypes.GENERAL, log.InfoLevel, log.Fields{}, "No host staged for Uncapped") } @@ -319,7 +319,7 @@ func StartPCPLogAndProgressiveExtremaCap(quit chan struct{}, logging *bool, hiTh }(logging, hiThreshold, loThreshold) - elektronLogging.ElektronLog.Log(elekLogTypes.GENERAL, + elekLog.ElektronLog.Log(elekLogTypes.GENERAL, log.InfoLevel, log.Fields{}, "PCP logging started") if err := cmd.Start(); err != nil { @@ -330,7 +330,7 @@ func StartPCPLogAndProgressiveExtremaCap(quit chan struct{}, logging *bool, hiTh select { case <-quit: - elektronLogging.ElektronLog.Log(elekLogTypes.GENERAL, + elekLog.ElektronLog.Log(elekLogTypes.GENERAL, log.InfoLevel, log.Fields{}, "Stopping PCP logging in 5 seconds") time.Sleep(5 * time.Second) diff --git a/scheduler.go b/scheduler.go index a0d453d..76feeba 100644 --- a/scheduler.go +++ b/scheduler.go @@ -26,7 +26,7 @@ import ( sched "github.com/mesos/mesos-go/api/v0/scheduler" log "github.com/sirupsen/logrus" "github.com/spdfg/elektron/def" - "github.com/spdfg/elektron/elektronLogging" + elekLog "github.com/spdfg/elektron/elektronLogging" elekLogTypes "github.com/spdfg/elektron/elektronLogging/types" "github.com/spdfg/elektron/pcp" "github.com/spdfg/elektron/powerCap" @@ -223,7 +223,7 @@ func main() { if strings.Contains(*pcplogPrefix, "/") { log.Fatal("log file prefix should not contain '/'.") } - elektronLogging.BuildLogger(*pcplogPrefix) + elekLog.BuildLogger(*pcplogPrefix) // Starting PCP logging. if noPowercap { @@ -278,11 +278,11 @@ func main() { // Starting the scheduler driver. if status, err := driver.Run(); err != nil { - elektronLogging.ElektronLog.Log(elekLogTypes.ERROR, + elekLog.ElektronLog.Log(elekLogTypes.ERROR, log.ErrorLevel, log.Fields{"status": status.String(), "error": err.Error()}, "Framework stopped ") } - elektronLogging.ElektronLog.Log(elekLogTypes.GENERAL, + elekLog.ElektronLog.Log(elekLogTypes.GENERAL, log.InfoLevel, log.Fields{}, "Exiting...") } diff --git a/schedulers/base.go b/schedulers/base.go index decec5c..b29edbf 100644 --- a/schedulers/base.go +++ b/schedulers/base.go @@ -30,7 +30,7 @@ import ( sched "github.com/mesos/mesos-go/api/v0/scheduler" log "github.com/sirupsen/logrus" "github.com/spdfg/elektron/def" - "github.com/spdfg/elektron/elektronLogging" + elekLog "github.com/spdfg/elektron/elektronLogging" elekLogTypes "github.com/spdfg/elektron/elektronLogging/types" "github.com/spdfg/elektron/utilities" "github.com/spdfg/elektron/utilities/schedUtils" @@ -251,10 +251,10 @@ func (s *BaseScheduler) StatusUpdate(driver sched.SchedulerDriver, status *mesos func (s *BaseScheduler) LogTaskStarting(ts *def.Task, offer *mesos.Offer) { lmt := elekLogTypes.GENERAL if ts == nil { - elektronLogging.ElektronLog.Log(lmt, log.InfoLevel, + elekLog.ElektronLog.Log(lmt, log.InfoLevel, log.Fields{"host": fmt.Sprintf("%s", offer.GetHostname())}, "TASKS STARTING...") } else { - elektronLogging.ElektronLog.Log(lmt, + elekLog.ElektronLog.Log(lmt, log.InfoLevel, log.Fields{"task": fmt.Sprintf("%s", ts.Name), "Instance": fmt.Sprintf("%d", *ts.Instances), "host": fmt.Sprintf("%s", offer.GetHostname())}, @@ -264,28 +264,28 @@ func (s *BaseScheduler) LogTaskStarting(ts *def.Task, offer *mesos.Offer) { func (s *BaseScheduler) LogTaskWattsConsideration(ts def.Task, host string, wattsToConsider float64) { lmt := elekLogTypes.GENERAL - elektronLogging.ElektronLog.Log(lmt, + elekLog.ElektronLog.Log(lmt, log.InfoLevel, log.Fields{"task": ts.Name, "host": host, "Watts": fmt.Sprintf("%f", wattsToConsider)}, "Watts considered for ") } func (s *BaseScheduler) LogOffersReceived(offers []*mesos.Offer) { lmt := elekLogTypes.GENERAL - elektronLogging.ElektronLog.Log(lmt, + elekLog.ElektronLog.Log(lmt, log.InfoLevel, log.Fields{"Resource offers received": fmt.Sprintf("%d", len(offers))}, "") } func (s *BaseScheduler) LogNoPendingTasksDeclineOffers(offer *mesos.Offer) { lmt := elekLogTypes.WARNING - elektronLogging.ElektronLog.Log(lmt, + elekLog.ElektronLog.Log(lmt, log.WarnLevel, log.Fields{"DECLINING OFFER for host": fmt.Sprintf("%s", offer.GetHostname())}, "No tasks left to schedule ") } func (s *BaseScheduler) LogNumberOfRunningTasks() { lmt := elekLogTypes.GENERAL - elektronLogging.ElektronLog.Log(lmt, + elekLog.ElektronLog.Log(lmt, log.InfoLevel, log.Fields{"Number of tasks still Running": fmt.Sprintf("%d", s.tasksRunning)}, "") } @@ -298,20 +298,20 @@ func (s *BaseScheduler) LogCoLocatedTasks(slaveID string) { buffer.WriteString(fmt.Sprintln(taskName)) } s.TasksRunningMutex.Unlock() - elektronLogging.ElektronLog.Log(lmt, + elekLog.ElektronLog.Log(lmt, log.InfoLevel, log.Fields{"Colocated with": fmt.Sprintf("%s", buffer.String())}, "") } func (s *BaseScheduler) LogSchedTrace(taskToSchedule *mesos.TaskInfo, offer *mesos.Offer) { - elektronLogging.ElektronLog.Log(elekLogTypes.SCHED_TRACE, + elekLog.ElektronLog.Log(elekLogTypes.SCHED_TRACE, log.InfoLevel, log.Fields{offer.GetHostname(): fmt.Sprintf("%s", taskToSchedule.GetTaskId().GetValue())}, "") } func (s *BaseScheduler) LogTerminateScheduler() { lmt := elekLogTypes.GENERAL - elektronLogging.ElektronLog.Log(lmt, + elekLog.ElektronLog.Log(lmt, log.InfoLevel, log.Fields{}, "Done scheduling all tasks!") } @@ -321,28 +321,28 @@ func (s *BaseScheduler) LogInsufficientResourcesDeclineOffer(offer *mesos.Offer, lmt := elekLogTypes.WARNING buffer := bytes.Buffer{} buffer.WriteString(fmt.Sprintf("", offerResources...)) - elektronLogging.ElektronLog.Log(lmt, + elekLog.ElektronLog.Log(lmt, log.WarnLevel, log.Fields{"Offer Resources": fmt.Sprintf("%s", buffer.String())}, "DECLINING OFFER... Offer has insufficient resources to launch a task") } func (s *BaseScheduler) LogOfferRescinded(offerID *mesos.OfferID) { lmt := elekLogTypes.ERROR - elektronLogging.ElektronLog.Log(lmt, + elekLog.ElektronLog.Log(lmt, log.ErrorLevel, log.Fields{"OfferID": fmt.Sprintf("%s", offerID)}, "OFFER RESCINDED") } func (s *BaseScheduler) LogSlaveLost(slaveID *mesos.SlaveID) { lmt := elekLogTypes.ERROR - elektronLogging.ElektronLog.Log(lmt, + elekLog.ElektronLog.Log(lmt, log.ErrorLevel, log.Fields{"SlaveID": fmt.Sprintf("%s", slaveID)}, "SLAVE LOST") } func (s *BaseScheduler) LogExecutorLost(executorID *mesos.ExecutorID, slaveID *mesos.SlaveID) { lmt := elekLogTypes.ERROR - elektronLogging.ElektronLog.Log(lmt, + elekLog.ElektronLog.Log(lmt, log.ErrorLevel, log.Fields{"ExecutorID": fmt.Sprintf("%s", executorID), "SlaveID": fmt.Sprintf("%s", slaveID)}, "EXECUTOR LOST") } @@ -350,21 +350,21 @@ func (s *BaseScheduler) LogExecutorLost(executorID *mesos.ExecutorID, slaveID *m func (s *BaseScheduler) LogFrameworkMessage(executorID *mesos.ExecutorID, slaveID *mesos.SlaveID, message string) { lmt := elekLogTypes.GENERAL - elektronLogging.ElektronLog.Log(lmt, + elekLog.ElektronLog.Log(lmt, log.InfoLevel, log.Fields{"Received Framework message from executor": executorID}, message) } func (s *BaseScheduler) LogMesosError(err string) { lmt := elekLogTypes.ERROR - elektronLogging.ElektronLog.Log(lmt, + elekLog.ElektronLog.Log(lmt, log.ErrorLevel, log.Fields{"MESOS ERROR": fmt.Sprintf("%v", err)}, "") } func (s *BaseScheduler) LogElectronError(err error) { lmt := elekLogTypes.ERROR - elektronLogging.ElektronLog.Log(lmt, + elekLog.ElektronLog.Log(lmt, log.ErrorLevel, log.Fields{"ELECTRON ERROR": fmt.Sprintf("%v", err)}, "") } @@ -372,21 +372,21 @@ func (s *BaseScheduler) LogElectronError(err error) { func (s *BaseScheduler) LogFrameworkRegistered(frameworkID *mesos.FrameworkID, masterInfo *mesos.MasterInfo) { lmt := elekLogTypes.SUCCESS - elektronLogging.ElektronLog.Log(lmt, + elekLog.ElektronLog.Log(lmt, log.InfoLevel, log.Fields{"frameworkID": fmt.Sprintf("%s", frameworkID), "master": fmt.Sprintf("%s", masterInfo)}, "FRAMEWORK REGISTERED!") } func (s *BaseScheduler) LogFrameworkReregistered(masterInfo *mesos.MasterInfo) { lmt := elekLogTypes.GENERAL - elektronLogging.ElektronLog.Log(lmt, + elekLog.ElektronLog.Log(lmt, log.InfoLevel, log.Fields{"master": fmt.Sprintf("%s", masterInfo)}, "Framework re-registered") } func (s *BaseScheduler) LogDisconnected() { lmt := elekLogTypes.WARNING - elektronLogging.ElektronLog.Log(lmt, + elekLog.ElektronLog.Log(lmt, log.WarnLevel, log.Fields{}, "Framework disconnected with master") } @@ -402,14 +402,14 @@ func (s *BaseScheduler) LogTaskStatusUpdate(status *mesos.TaskStatus) { default: lmt = elekLogTypes.GENERAL } - elektronLogging.ElektronLog.Log(lmt, + elekLog.ElektronLog.Log(lmt, log.InfoLevel, log.Fields{"task": fmt.Sprintf("%s", *status.TaskId.Value), "state": NameFor(status.State)}, "Task Status received") } func (s *BaseScheduler) LogSchedPolicySwitch(name string, nextPolicy SchedPolicyState) { logSPS := func() { - elektronLogging.ElektronLog.Log(elekLogTypes.SPS, + elekLog.ElektronLog.Log(elekLogTypes.SPS, log.InfoLevel, log.Fields{"Name": name}, "") } @@ -420,14 +420,14 @@ func (s *BaseScheduler) LogSchedPolicySwitch(name string, nextPolicy SchedPolicy } // Logging the size of the scheduling window and the scheduling policy // that is going to schedule the tasks in the scheduling window. - elektronLogging.ElektronLog.Log(elekLogTypes.SCHED_WINDOW, + elekLog.ElektronLog.Log(elekLogTypes.SCHED_WINDOW, log.InfoLevel, log.Fields{"Window size": fmt.Sprintf("%d", s.schedWindowSize), "Name": name}, "") } func (s *BaseScheduler) LogClsfnAndTaskDistOverhead(overhead time.Duration) { // Logging the overhead in microseconds. - elektronLogging.ElektronLog.Log(elekLogTypes.CLSFN_TASKDIST_OVERHEAD, + elekLog.ElektronLog.Log(elekLogTypes.CLSFN_TASKDIST_OVERHEAD, log.InfoLevel, log.Fields{"Overhead in microseconds": fmt.Sprintf("%f", float64(overhead.Nanoseconds())/1000.0)}, "") } diff --git a/schedulers/helpers.go b/schedulers/helpers.go index 8a2f532..a8bfc2b 100644 --- a/schedulers/helpers.go +++ b/schedulers/helpers.go @@ -26,7 +26,7 @@ import ( log "github.com/sirupsen/logrus" "github.com/spdfg/elektron/constants" "github.com/spdfg/elektron/def" - "github.com/spdfg/elektron/elektronLogging" + elekLog "github.com/spdfg/elektron/elektronLogging" elekLogTypes "github.com/spdfg/elektron/elektronLogging/types" "github.com/spdfg/elektron/utilities" "github.com/spdfg/elektron/utilities/mesosUtils" @@ -35,12 +35,12 @@ import ( func coLocated(tasks map[string]bool, s BaseScheduler) { for task := range tasks { - elektronLogging.ElektronLog.Log(elekLogTypes.GENERAL, + elekLog.ElektronLog.Log(elekLogTypes.GENERAL, log.InfoLevel, log.Fields{"Task": task}, "") } - elektronLogging.ElektronLog.Log(elekLogTypes.GENERAL, + elekLog.ElektronLog.Log(elekLogTypes.GENERAL, log.InfoLevel, log.Fields{}, "---------------------") } diff --git a/schedulers/schedPolicy.go b/schedulers/schedPolicy.go index e4716d7..34f3b12 100644 --- a/schedulers/schedPolicy.go +++ b/schedulers/schedPolicy.go @@ -26,7 +26,7 @@ import ( sched "github.com/mesos/mesos-go/api/v0/scheduler" log "github.com/sirupsen/logrus" "github.com/spdfg/elektron/def" - "github.com/spdfg/elektron/elektronLogging" + elekLog "github.com/spdfg/elektron/elektronLogging" elekLogTypes "github.com/spdfg/elektron/elektronLogging/types" ) @@ -90,7 +90,7 @@ func switchTaskDistBased(baseSchedRef *BaseScheduler) string { // Determine the distribution of tasks in the new scheduling window. taskDist, err := def.GetTaskDistributionInWindow(baseSchedRef.schedWindowSize, baseSchedRef.tasks) baseSchedRef.LogClsfnAndTaskDistOverhead(time.Now().Sub(startTime)) - elektronLogging.ElektronLog.Log(elekLogTypes.GENERAL, + elekLog.ElektronLog.Log(elekLogTypes.GENERAL, log.InfoLevel, log.Fields{"Task Distribution": fmt.Sprintf("%f", taskDist)}, "Switching... ") if err != nil { diff --git a/utilities/offerUtils/offerUtils.go b/utilities/offerUtils/offerUtils.go index a3062d8..bad440a 100644 --- a/utilities/offerUtils/offerUtils.go +++ b/utilities/offerUtils/offerUtils.go @@ -23,7 +23,7 @@ import ( mesos "github.com/mesos/mesos-go/api/v0/mesosproto" log "github.com/sirupsen/logrus" "github.com/spdfg/elektron/constants" - "github.com/spdfg/elektron/elektronLogging" + elekLog "github.com/spdfg/elektron/elektronLogging" elekLogTypes "github.com/spdfg/elektron/elektronLogging/types" "strings" ) @@ -90,13 +90,13 @@ func UpdateEnvironment(offer *mesos.Offer) { var host = offer.GetHostname() // If this host is not present in the set of hosts. if _, ok := constants.Hosts[host]; !ok { - elektronLogging.ElektronLog.Log(elekLogTypes.GENERAL, log.InfoLevel, + elekLog.ElektronLog.Log(elekLogTypes.GENERAL, log.InfoLevel, log.Fields{"Adding host": fmt.Sprintf("%s", host)}, "New host detected") // Add this host. constants.Hosts[host] = struct{}{} // Get the power class of this host. class := PowerClass(offer) - elektronLogging.ElektronLog.Log(elekLogTypes.GENERAL, log.InfoLevel, + elekLog.ElektronLog.Log(elekLogTypes.GENERAL, log.InfoLevel, log.Fields{"host": fmt.Sprintf("%s", host), "PowerClass": fmt.Sprintf("%s", class)}, "Registering the power class...") // If new power class, register the power class. if _, ok := constants.PowerClasses[class]; !ok { diff --git a/utilities/schedUtils/schedUtils.go b/utilities/schedUtils/schedUtils.go index ffa3124..1734811 100644 --- a/utilities/schedUtils/schedUtils.go +++ b/utilities/schedUtils/schedUtils.go @@ -22,7 +22,7 @@ import ( "fmt" log "github.com/sirupsen/logrus" "github.com/spdfg/elektron/def" - "github.com/spdfg/elektron/elektronLogging" + elekLog "github.com/spdfg/elektron/elektronLogging" elekLogTypes "github.com/spdfg/elektron/elektronLogging/types" "github.com/spdfg/elektron/utilities" ) @@ -79,7 +79,7 @@ func (s *fillNextOfferCycle) apply(taskQueue []def.Task) (int, int) { for _, task := range taskQueue { numberOfTasksTraversed++ for i := *task.Instances; i > 0; i-- { - elektronLogging.ElektronLog.Log(elekLogTypes.GENERAL, log.InfoLevel, + elekLog.ElektronLog.Log(elekLogTypes.GENERAL, log.InfoLevel, log.Fields{}, fmt.Sprintf("Checking if Instance #%d of Task[%s] can be scheduled "+ "during the next offer cycle...", i, task.Name)) if canSchedule(task) { -- 2.47.2 From cb5df9acc896218e9c31a611882c01076eef23d5 Mon Sep 17 00:00:00 2001 From: balandi1 Date: Thu, 21 Nov 2019 14:58:14 -0500 Subject: [PATCH 14/48] Removed ERROR, GENERAL, SUCCESS, WARNING log types --- def/taskUtils.go | 4 +-- elektronLogging/types/types.go | 6 +--- pcp/pcp.go | 10 +++--- powerCap/extrema.go | 22 +++++++------- powerCap/progressiveExtrema.go | 40 ++++++++++++------------ scheduler.go | 4 +-- schedulers/base.go | 49 +++++++++++++++--------------- schedulers/helpers.go | 4 +-- schedulers/schedPolicy.go | 2 +- utilities/offerUtils/offerUtils.go | 4 +-- utilities/schedUtils/schedUtils.go | 2 +- 11 files changed, 71 insertions(+), 76 deletions(-) diff --git a/def/taskUtils.go b/def/taskUtils.go index 9556e06..ce69a53 100644 --- a/def/taskUtils.go +++ b/def/taskUtils.go @@ -52,7 +52,7 @@ func (tc TasksToClassify) taskObservationCalculator(task Task) []float64 { } else if task.Watts != 0.0 { return []float64{task.Watts} } else { - elekLog.ElektronLog.Log(elekLogTypes.ERROR, log.FatalLevel, + elekLog.ElektronLog.Log(elekLogTypes.CONSOLE, log.FatalLevel, log.Fields{}, "Unable to classify tasks. Missing Watts or ClassToWatts attribute in workload") return []float64{0.0} // Won't reach here. } @@ -108,7 +108,7 @@ func clusterSizeAvgMMMPU(tasks []Task, taskObservation func(task Task) []float64 } else { // skip this value // there is an error in the task config. - elekLog.ElektronLog.Log(elekLogTypes.ERROR, log.ErrorLevel, + elekLog.ElektronLog.Log(elekLogTypes.CONSOLE, log.ErrorLevel, log.Fields{}, fmt.Sprintf("%s", err)) } } else { diff --git a/elektronLogging/types/types.go b/elektronLogging/types/types.go index db6b624..7e99836 100644 --- a/elektronLogging/types/types.go +++ b/elektronLogging/types/types.go @@ -1,11 +1,7 @@ package elektronLogging const ( - ERROR = iota - WARNING - GENERAL - SUCCESS - CONSOLE + CONSOLE = iota PCP SCHED_TRACE SPS diff --git a/pcp/pcp.go b/pcp/pcp.go index 010cf09..cbe8170 100644 --- a/pcp/pcp.go +++ b/pcp/pcp.go @@ -26,7 +26,7 @@ import ( log "github.com/sirupsen/logrus" elekLog "github.com/spdfg/elektron/elektronLogging" - elekLogT "github.com/spdfg/elektron/elektronLogging/types" + elekLogTypes "github.com/spdfg/elektron/elektronLogging/types" ) func Start(quit chan struct{}, logging *bool, pcpConfigFile string) { @@ -47,7 +47,7 @@ func Start(quit chan struct{}, logging *bool, pcpConfigFile string) { scanner.Scan() // Write to logfile - elekLog.ElektronLog.Log(elekLogT.PCP, + elekLog.ElektronLog.Log(elekLogTypes.PCP, log.InfoLevel, log.Fields{}, scanner.Text()) @@ -60,7 +60,7 @@ func Start(quit chan struct{}, logging *bool, pcpConfigFile string) { text := scanner.Text() if *logging { - elekLog.ElektronLog.Log(elekLogT.PCP, + elekLog.ElektronLog.Log(elekLogTypes.PCP, log.InfoLevel, log.Fields{}, text) } @@ -69,7 +69,7 @@ func Start(quit chan struct{}, logging *bool, pcpConfigFile string) { } }(logging) - elekLog.ElektronLog.Log(elekLogT.GENERAL, + elekLog.ElektronLog.Log(elekLogTypes.CONSOLE, log.InfoLevel, log.Fields{}, "PCP logging started") @@ -81,7 +81,7 @@ func Start(quit chan struct{}, logging *bool, pcpConfigFile string) { select { case <-quit: - elekLog.ElektronLog.Log(elekLogT.GENERAL, + elekLog.ElektronLog.Log(elekLogTypes.CONSOLE, log.InfoLevel, log.Fields{}, "Stopping PCP logging in 5 seconds") time.Sleep(5 * time.Second) diff --git a/powerCap/extrema.go b/powerCap/extrema.go index 2e202eb..be8b158 100644 --- a/powerCap/extrema.go +++ b/powerCap/extrema.go @@ -43,7 +43,7 @@ func StartPCPLogAndExtremaDynamicCap(quit chan struct{}, logging *bool, hiThresh cmd.SysProcAttr = &syscall.SysProcAttr{Setpgid: true} if hiThreshold < loThreshold { - elekLog.ElektronLog.Log(elekLogTypes.GENERAL, + elekLog.ElektronLog.Log(elekLogTypes.CONSOLE, log.InfoLevel, log.Fields{}, "High threshold is lower than low threshold!") } @@ -99,7 +99,7 @@ func StartPCPLogAndExtremaDynamicCap(quit chan struct{}, logging *bool, hiThresh if *logging { - elekLog.ElektronLog.Log(elekLogTypes.GENERAL, + elekLog.ElektronLog.Log(elekLogTypes.CONSOLE, log.InfoLevel, log.Fields{}, "Logging PCP...") @@ -119,7 +119,7 @@ func StartPCPLogAndExtremaDynamicCap(quit chan struct{}, logging *bool, hiThresh powerHistories[host].Value = power powerHistories[host] = powerHistories[host].Next() - elekLog.ElektronLog.Log(elekLogTypes.GENERAL, + elekLog.ElektronLog.Log(elekLogTypes.CONSOLE, log.InfoLevel, log.Fields{"Host": fmt.Sprintf("%s", indexToHost[powerIndex]), "Power": fmt.Sprintf("%f", (power * pcp.RAPLUnits))}, "") @@ -133,14 +133,14 @@ func StartPCPLogAndExtremaDynamicCap(quit chan struct{}, logging *bool, hiThresh clusterMean := pcp.AverageClusterPowerHistory(clusterPowerHist) - elekLog.ElektronLog.Log(elekLogTypes.GENERAL, + elekLog.ElektronLog.Log(elekLogTypes.CONSOLE, log.InfoLevel, log.Fields{"Total power": fmt.Sprintf("%f %d", clusterPower, clusterPowerHist.Len()), "Sec Avg": fmt.Sprintf("%f", clusterMean)}, "") if clusterMean > hiThreshold { - elekLog.ElektronLog.Log(elekLogTypes.GENERAL, + elekLog.ElektronLog.Log(elekLogTypes.CONSOLE, log.InfoLevel, log.Fields{}, "Need to cap a node") // Create statics for all victims and choose one to cap @@ -163,12 +163,12 @@ func StartPCPLogAndExtremaDynamicCap(quit chan struct{}, logging *bool, hiThresh if !cappedHosts[victim.Host] { cappedHosts[victim.Host] = true orderCapped = append(orderCapped, victim.Host) - elekLog.ElektronLog.Log(elekLogTypes.GENERAL, + elekLog.ElektronLog.Log(elekLogTypes.CONSOLE, log.InfoLevel, log.Fields{"Capping Victim": fmt.Sprintf("%s", victim.Host), "Avg. Wattage": fmt.Sprintf("%f", victim.Watts*pcp.RAPLUnits)}, "") if err := rapl.Cap(victim.Host, "rapl", 50); err != nil { - elekLog.ElektronLog.Log(elekLogTypes.ERROR, + elekLog.ElektronLog.Log(elekLogTypes.CONSOLE, log.ErrorLevel, log.Fields{}, "Error capping host") } @@ -184,11 +184,11 @@ func StartPCPLogAndExtremaDynamicCap(quit chan struct{}, logging *bool, hiThresh cappedHosts[host] = false // User RAPL package to send uncap. log.Printf("Uncapping host %s", host) - elekLog.ElektronLog.Log(elekLogTypes.GENERAL, + elekLog.ElektronLog.Log(elekLogTypes.CONSOLE, log.InfoLevel, log.Fields{"Uncapped host": host}, "") if err := rapl.Cap(host, "rapl", 100); err != nil { - elekLog.ElektronLog.Log(elekLogTypes.ERROR, + elekLog.ElektronLog.Log(elekLogTypes.CONSOLE, log.ErrorLevel, log.Fields{}, "Error capping host") } @@ -200,7 +200,7 @@ func StartPCPLogAndExtremaDynamicCap(quit chan struct{}, logging *bool, hiThresh } }(logging, hiThreshold, loThreshold) - elekLog.ElektronLog.Log(elekLogTypes.GENERAL, + elekLog.ElektronLog.Log(elekLogTypes.CONSOLE, log.InfoLevel, log.Fields{}, "PCP logging started") @@ -212,7 +212,7 @@ func StartPCPLogAndExtremaDynamicCap(quit chan struct{}, logging *bool, hiThresh select { case <-quit: - elekLog.ElektronLog.Log(elekLogTypes.GENERAL, + elekLog.ElektronLog.Log(elekLogTypes.CONSOLE, log.InfoLevel, log.Fields{}, "Stopping PCP logging in 5 seconds") time.Sleep(5 * time.Second) diff --git a/powerCap/progressiveExtrema.go b/powerCap/progressiveExtrema.go index 9fba626..6cd234f 100644 --- a/powerCap/progressiveExtrema.go +++ b/powerCap/progressiveExtrema.go @@ -56,7 +56,7 @@ func StartPCPLogAndProgressiveExtremaCap(quit chan struct{}, logging *bool, hiTh cmd.SysProcAttr = &syscall.SysProcAttr{Setpgid: true} if hiThreshold < loThreshold { - elekLog.ElektronLog.Log(elekLogTypes.GENERAL, + elekLog.ElektronLog.Log(elekLogTypes.CONSOLE, log.InfoLevel, log.Fields{}, "High threshold is lower than low threshold!") } @@ -115,7 +115,7 @@ func StartPCPLogAndProgressiveExtremaCap(quit chan struct{}, logging *bool, hiTh for scanner.Scan() { if *logging { - elekLog.ElektronLog.Log(elekLogTypes.GENERAL, + elekLog.ElektronLog.Log(elekLogTypes.CONSOLE, log.InfoLevel, log.Fields{}, "Logging PCP...") split := strings.Split(scanner.Text(), ",") @@ -134,7 +134,7 @@ func StartPCPLogAndProgressiveExtremaCap(quit chan struct{}, logging *bool, hiTh powerHistories[host].Value = power powerHistories[host] = powerHistories[host].Next() - elekLog.ElektronLog.Log(elekLogTypes.GENERAL, + elekLog.ElektronLog.Log(elekLogTypes.CONSOLE, log.InfoLevel, log.Fields{"Host": fmt.Sprintf("%s", indexToHost[powerIndex]), "Power": fmt.Sprintf("%f", (power * pcp.RAPLUnits))}, "") @@ -147,22 +147,22 @@ func StartPCPLogAndProgressiveExtremaCap(quit chan struct{}, logging *bool, hiTh clusterMean := pcp.AverageClusterPowerHistory(clusterPowerHist) - elekLog.ElektronLog.Log(elekLogTypes.GENERAL, + elekLog.ElektronLog.Log(elekLogTypes.CONSOLE, log.InfoLevel, log.Fields{"Total power": fmt.Sprintf("%f %d", clusterPower, clusterPowerHist.Len()), "Sec Avg": fmt.Sprintf("%f", clusterMean)}, "") if clusterMean >= hiThreshold { - elekLog.ElektronLog.Log(elekLogTypes.GENERAL, + elekLog.ElektronLog.Log(elekLogTypes.CONSOLE, log.InfoLevel, log.Fields{}, "Need to cap a node") - elekLog.ElektronLog.Log(elekLogTypes.GENERAL, + elekLog.ElektronLog.Log(elekLogTypes.CONSOLE, log.InfoLevel, log.Fields{"Cap values of capped victims": fmt.Sprintf("%v", cappedVictims)}, "") - elekLog.ElektronLog.Log(elekLogTypes.GENERAL, + elekLog.ElektronLog.Log(elekLogTypes.CONSOLE, log.InfoLevel, log.Fields{"Cap values of victims to uncap": fmt.Sprintf("%v", orderCappedVictims)}, "") // Create statics for all victims and choose one to cap @@ -192,12 +192,12 @@ func StartPCPLogAndProgressiveExtremaCap(quit chan struct{}, logging *bool, hiTh // Need to cap this victim. if err := rapl.Cap(victims[i].Host, "rapl", 50.0); err != nil { - elekLog.ElektronLog.Log(elekLogTypes.ERROR, + elekLog.ElektronLog.Log(elekLogTypes.CONSOLE, log.ErrorLevel, log.Fields{"Error capping host": fmt.Sprintf("%s", victims[i].Host)}, "") } else { - elekLog.ElektronLog.Log(elekLogTypes.GENERAL, + elekLog.ElektronLog.Log(elekLogTypes.CONSOLE, log.InfoLevel, log.Fields{}, fmt.Sprintf("Capped host[%s] at %f", victims[i].Host, 50.0)) // Keeping track of this victim and it's cap value @@ -223,12 +223,12 @@ func StartPCPLogAndProgressiveExtremaCap(quit chan struct{}, logging *bool, hiTh newCapValue := getNextCapValue(capValue, 2) if err := rapl.Cap(alreadyCappedHosts[i], "rapl", newCapValue); err != nil { - elekLog.ElektronLog.Log(elekLogTypes.ERROR, + elekLog.ElektronLog.Log(elekLogTypes.CONSOLE, log.ErrorLevel, log.Fields{"Error capping host": fmt.Sprintf("%s", alreadyCappedHosts[i])}, "") } else { // Successful cap - elekLog.ElektronLog.Log(elekLogTypes.GENERAL, + elekLog.ElektronLog.Log(elekLogTypes.CONSOLE, log.InfoLevel, log.Fields{}, fmt.Sprintf("Capped host[%s] at %f", alreadyCappedHosts[i], newCapValue)) // Checking whether this victim can be capped further @@ -253,7 +253,7 @@ func StartPCPLogAndProgressiveExtremaCap(quit chan struct{}, logging *bool, hiTh } } if !canCapAlreadyCappedVictim { - elekLog.ElektronLog.Log(elekLogTypes.GENERAL, + elekLog.ElektronLog.Log(elekLogTypes.CONSOLE, log.InfoLevel, log.Fields{}, "No Victim left to cap") } @@ -261,13 +261,13 @@ func StartPCPLogAndProgressiveExtremaCap(quit chan struct{}, logging *bool, hiTh } else if clusterMean < loThreshold { - elekLog.ElektronLog.Log(elekLogTypes.GENERAL, + elekLog.ElektronLog.Log(elekLogTypes.CONSOLE, log.InfoLevel, log.Fields{}, "Need to uncap a node") - elekLog.ElektronLog.Log(elekLogTypes.GENERAL, + elekLog.ElektronLog.Log(elekLogTypes.CONSOLE, log.InfoLevel, log.Fields{"Cap values of capped victims": fmt.Sprintf("%v", cappedVictims)}, "") - elekLog.ElektronLog.Log(elekLogTypes.GENERAL, + elekLog.ElektronLog.Log(elekLogTypes.CONSOLE, log.InfoLevel, log.Fields{"Cap values of victims to uncap": fmt.Sprintf("%v", orderCappedVictims)}, "") if len(orderCapped) > 0 { @@ -280,12 +280,12 @@ func StartPCPLogAndProgressiveExtremaCap(quit chan struct{}, logging *bool, hiTh newUncapValue := orderCappedVictims[hostToUncap] * 2.0 if err := rapl.Cap(hostToUncap, "rapl", newUncapValue); err != nil { - elekLog.ElektronLog.Log(elekLogTypes.ERROR, + elekLog.ElektronLog.Log(elekLogTypes.CONSOLE, log.ErrorLevel, log.Fields{"Error uncapping host": fmt.Sprintf("%s", hostToUncap)}, "") } else { // Successful uncap - elekLog.ElektronLog.Log(elekLogTypes.GENERAL, + elekLog.ElektronLog.Log(elekLogTypes.CONSOLE, log.InfoLevel, log.Fields{}, fmt.Sprintf("Uncapped host[%s] to %f", hostToUncap, newUncapValue)) // Can we uncap this host further. If not, then we remove its entry from orderCapped @@ -308,7 +308,7 @@ func StartPCPLogAndProgressiveExtremaCap(quit chan struct{}, logging *bool, hiTh } } } else { - elekLog.ElektronLog.Log(elekLogTypes.GENERAL, + elekLog.ElektronLog.Log(elekLogTypes.CONSOLE, log.InfoLevel, log.Fields{}, "No host staged for Uncapped") } @@ -319,7 +319,7 @@ func StartPCPLogAndProgressiveExtremaCap(quit chan struct{}, logging *bool, hiTh }(logging, hiThreshold, loThreshold) - elekLog.ElektronLog.Log(elekLogTypes.GENERAL, + elekLog.ElektronLog.Log(elekLogTypes.CONSOLE, log.InfoLevel, log.Fields{}, "PCP logging started") if err := cmd.Start(); err != nil { @@ -330,7 +330,7 @@ func StartPCPLogAndProgressiveExtremaCap(quit chan struct{}, logging *bool, hiTh select { case <-quit: - elekLog.ElektronLog.Log(elekLogTypes.GENERAL, + elekLog.ElektronLog.Log(elekLogTypes.CONSOLE, log.InfoLevel, log.Fields{}, "Stopping PCP logging in 5 seconds") time.Sleep(5 * time.Second) diff --git a/scheduler.go b/scheduler.go index 76feeba..5ec6bc5 100644 --- a/scheduler.go +++ b/scheduler.go @@ -278,11 +278,11 @@ func main() { // Starting the scheduler driver. if status, err := driver.Run(); err != nil { - elekLog.ElektronLog.Log(elekLogTypes.ERROR, + elekLog.ElektronLog.Log(elekLogTypes.CONSOLE, log.ErrorLevel, log.Fields{"status": status.String(), "error": err.Error()}, "Framework stopped ") } - elekLog.ElektronLog.Log(elekLogTypes.GENERAL, + elekLog.ElektronLog.Log(elekLogTypes.CONSOLE, log.InfoLevel, log.Fields{}, "Exiting...") } diff --git a/schedulers/base.go b/schedulers/base.go index b29edbf..1238602 100644 --- a/schedulers/base.go +++ b/schedulers/base.go @@ -249,7 +249,7 @@ func (s *BaseScheduler) StatusUpdate(driver sched.SchedulerDriver, status *mesos } func (s *BaseScheduler) LogTaskStarting(ts *def.Task, offer *mesos.Offer) { - lmt := elekLogTypes.GENERAL + lmt := elekLogTypes.CONSOLE if ts == nil { elekLog.ElektronLog.Log(lmt, log.InfoLevel, log.Fields{"host": fmt.Sprintf("%s", offer.GetHostname())}, "TASKS STARTING...") @@ -263,35 +263,35 @@ func (s *BaseScheduler) LogTaskStarting(ts *def.Task, offer *mesos.Offer) { } func (s *BaseScheduler) LogTaskWattsConsideration(ts def.Task, host string, wattsToConsider float64) { - lmt := elekLogTypes.GENERAL + lmt := elekLogTypes.CONSOLE elekLog.ElektronLog.Log(lmt, log.InfoLevel, log.Fields{"task": ts.Name, "host": host, "Watts": fmt.Sprintf("%f", wattsToConsider)}, "Watts considered for ") } func (s *BaseScheduler) LogOffersReceived(offers []*mesos.Offer) { - lmt := elekLogTypes.GENERAL + lmt := elekLogTypes.CONSOLE elekLog.ElektronLog.Log(lmt, log.InfoLevel, log.Fields{"Resource offers received": fmt.Sprintf("%d", len(offers))}, "") } func (s *BaseScheduler) LogNoPendingTasksDeclineOffers(offer *mesos.Offer) { - lmt := elekLogTypes.WARNING + lmt := elekLogTypes.CONSOLE elekLog.ElektronLog.Log(lmt, log.WarnLevel, log.Fields{"DECLINING OFFER for host": fmt.Sprintf("%s", offer.GetHostname())}, "No tasks left to schedule ") } func (s *BaseScheduler) LogNumberOfRunningTasks() { - lmt := elekLogTypes.GENERAL + lmt := elekLogTypes.CONSOLE elekLog.ElektronLog.Log(lmt, log.InfoLevel, log.Fields{"Number of tasks still Running": fmt.Sprintf("%d", s.tasksRunning)}, "") } func (s *BaseScheduler) LogCoLocatedTasks(slaveID string) { - lmt := elekLogTypes.GENERAL + lmt := elekLogTypes.CONSOLE buffer := bytes.Buffer{} s.TasksRunningMutex.Lock() for taskName := range s.Running[slaveID] { @@ -310,7 +310,7 @@ func (s *BaseScheduler) LogSchedTrace(taskToSchedule *mesos.TaskInfo, offer *mes } func (s *BaseScheduler) LogTerminateScheduler() { - lmt := elekLogTypes.GENERAL + lmt := elekLogTypes.CONSOLE elekLog.ElektronLog.Log(lmt, log.InfoLevel, log.Fields{}, "Done scheduling all tasks!") @@ -318,7 +318,7 @@ func (s *BaseScheduler) LogTerminateScheduler() { func (s *BaseScheduler) LogInsufficientResourcesDeclineOffer(offer *mesos.Offer, offerResources ...interface{}) { - lmt := elekLogTypes.WARNING + lmt := elekLogTypes.CONSOLE buffer := bytes.Buffer{} buffer.WriteString(fmt.Sprintf("", offerResources...)) elekLog.ElektronLog.Log(lmt, @@ -327,21 +327,21 @@ func (s *BaseScheduler) LogInsufficientResourcesDeclineOffer(offer *mesos.Offer, } func (s *BaseScheduler) LogOfferRescinded(offerID *mesos.OfferID) { - lmt := elekLogTypes.ERROR + lmt := elekLogTypes.CONSOLE elekLog.ElektronLog.Log(lmt, log.ErrorLevel, log.Fields{"OfferID": fmt.Sprintf("%s", offerID)}, "OFFER RESCINDED") } func (s *BaseScheduler) LogSlaveLost(slaveID *mesos.SlaveID) { - lmt := elekLogTypes.ERROR + lmt := elekLogTypes.CONSOLE elekLog.ElektronLog.Log(lmt, log.ErrorLevel, log.Fields{"SlaveID": fmt.Sprintf("%s", slaveID)}, "SLAVE LOST") } func (s *BaseScheduler) LogExecutorLost(executorID *mesos.ExecutorID, slaveID *mesos.SlaveID) { - lmt := elekLogTypes.ERROR + lmt := elekLogTypes.CONSOLE elekLog.ElektronLog.Log(lmt, log.ErrorLevel, log.Fields{"ExecutorID": fmt.Sprintf("%s", executorID), "SlaveID": fmt.Sprintf("%s", slaveID)}, "EXECUTOR LOST") @@ -349,61 +349,60 @@ func (s *BaseScheduler) LogExecutorLost(executorID *mesos.ExecutorID, slaveID *m func (s *BaseScheduler) LogFrameworkMessage(executorID *mesos.ExecutorID, slaveID *mesos.SlaveID, message string) { - lmt := elekLogTypes.GENERAL + lmt := elekLogTypes.CONSOLE elekLog.ElektronLog.Log(lmt, log.InfoLevel, log.Fields{"Received Framework message from executor": executorID}, message) } func (s *BaseScheduler) LogMesosError(err string) { - lmt := elekLogTypes.ERROR + lmt := elekLogTypes.CONSOLE elekLog.ElektronLog.Log(lmt, log.ErrorLevel, - log.Fields{"MESOS ERROR": fmt.Sprintf("%v", err)}, "") + log.Fields{"MESOS CONSOLE": fmt.Sprintf("%v", err)}, "") } func (s *BaseScheduler) LogElectronError(err error) { - lmt := elekLogTypes.ERROR + lmt := elekLogTypes.CONSOLE elekLog.ElektronLog.Log(lmt, log.ErrorLevel, - log.Fields{"ELECTRON ERROR": fmt.Sprintf("%v", err)}, "") + log.Fields{"ELECTRON CONSOLE": fmt.Sprintf("%v", err)}, "") } func (s *BaseScheduler) LogFrameworkRegistered(frameworkID *mesos.FrameworkID, masterInfo *mesos.MasterInfo) { - lmt := elekLogTypes.SUCCESS + lmt := elekLogTypes.CONSOLE elekLog.ElektronLog.Log(lmt, log.InfoLevel, log.Fields{"frameworkID": fmt.Sprintf("%s", frameworkID), "master": fmt.Sprintf("%s", masterInfo)}, "FRAMEWORK REGISTERED!") } func (s *BaseScheduler) LogFrameworkReregistered(masterInfo *mesos.MasterInfo) { - lmt := elekLogTypes.GENERAL + lmt := elekLogTypes.CONSOLE elekLog.ElektronLog.Log(lmt, log.InfoLevel, log.Fields{"master": fmt.Sprintf("%s", masterInfo)}, "Framework re-registered") } func (s *BaseScheduler) LogDisconnected() { - lmt := elekLogTypes.WARNING + lmt := elekLogTypes.CONSOLE elekLog.ElektronLog.Log(lmt, log.WarnLevel, log.Fields{}, "Framework disconnected with master") } func (s *BaseScheduler) LogTaskStatusUpdate(status *mesos.TaskStatus) { - lmt := elekLogTypes.GENERAL + lmt := elekLogTypes.CONSOLE + level := log.InfoLevel switch *status.State { case mesos.TaskState_TASK_ERROR, mesos.TaskState_TASK_FAILED, mesos.TaskState_TASK_KILLED, mesos.TaskState_TASK_LOST: - lmt = elekLogTypes.ERROR - case mesos.TaskState_TASK_FINISHED: - lmt = elekLogTypes.SUCCESS + level = log.ErrorLevel default: - lmt = elekLogTypes.GENERAL + level = log.InfoLevel } elekLog.ElektronLog.Log(lmt, - log.InfoLevel, + level, log.Fields{"task": fmt.Sprintf("%s", *status.TaskId.Value), "state": NameFor(status.State)}, "Task Status received") } diff --git a/schedulers/helpers.go b/schedulers/helpers.go index a8bfc2b..252190e 100644 --- a/schedulers/helpers.go +++ b/schedulers/helpers.go @@ -35,12 +35,12 @@ import ( func coLocated(tasks map[string]bool, s BaseScheduler) { for task := range tasks { - elekLog.ElektronLog.Log(elekLogTypes.GENERAL, + elekLog.ElektronLog.Log(elekLogTypes.CONSOLE, log.InfoLevel, log.Fields{"Task": task}, "") } - elekLog.ElektronLog.Log(elekLogTypes.GENERAL, + elekLog.ElektronLog.Log(elekLogTypes.CONSOLE, log.InfoLevel, log.Fields{}, "---------------------") } diff --git a/schedulers/schedPolicy.go b/schedulers/schedPolicy.go index 34f3b12..eb98176 100644 --- a/schedulers/schedPolicy.go +++ b/schedulers/schedPolicy.go @@ -90,7 +90,7 @@ func switchTaskDistBased(baseSchedRef *BaseScheduler) string { // Determine the distribution of tasks in the new scheduling window. taskDist, err := def.GetTaskDistributionInWindow(baseSchedRef.schedWindowSize, baseSchedRef.tasks) baseSchedRef.LogClsfnAndTaskDistOverhead(time.Now().Sub(startTime)) - elekLog.ElektronLog.Log(elekLogTypes.GENERAL, + elekLog.ElektronLog.Log(elekLogTypes.CONSOLE, log.InfoLevel, log.Fields{"Task Distribution": fmt.Sprintf("%f", taskDist)}, "Switching... ") if err != nil { diff --git a/utilities/offerUtils/offerUtils.go b/utilities/offerUtils/offerUtils.go index bad440a..db512d2 100644 --- a/utilities/offerUtils/offerUtils.go +++ b/utilities/offerUtils/offerUtils.go @@ -90,13 +90,13 @@ func UpdateEnvironment(offer *mesos.Offer) { var host = offer.GetHostname() // If this host is not present in the set of hosts. if _, ok := constants.Hosts[host]; !ok { - elekLog.ElektronLog.Log(elekLogTypes.GENERAL, log.InfoLevel, + elekLog.ElektronLog.Log(elekLogTypes.CONSOLE, log.InfoLevel, log.Fields{"Adding host": fmt.Sprintf("%s", host)}, "New host detected") // Add this host. constants.Hosts[host] = struct{}{} // Get the power class of this host. class := PowerClass(offer) - elekLog.ElektronLog.Log(elekLogTypes.GENERAL, log.InfoLevel, + elekLog.ElektronLog.Log(elekLogTypes.CONSOLE, log.InfoLevel, log.Fields{"host": fmt.Sprintf("%s", host), "PowerClass": fmt.Sprintf("%s", class)}, "Registering the power class...") // If new power class, register the power class. if _, ok := constants.PowerClasses[class]; !ok { diff --git a/utilities/schedUtils/schedUtils.go b/utilities/schedUtils/schedUtils.go index 1734811..98631ca 100644 --- a/utilities/schedUtils/schedUtils.go +++ b/utilities/schedUtils/schedUtils.go @@ -79,7 +79,7 @@ func (s *fillNextOfferCycle) apply(taskQueue []def.Task) (int, int) { for _, task := range taskQueue { numberOfTasksTraversed++ for i := *task.Instances; i > 0; i-- { - elekLog.ElektronLog.Log(elekLogTypes.GENERAL, log.InfoLevel, + elekLog.ElektronLog.Log(elekLogTypes.CONSOLE, log.InfoLevel, log.Fields{}, fmt.Sprintf("Checking if Instance #%d of Task[%s] can be scheduled "+ "during the next offer cycle...", i, task.Name)) if canSchedule(task) { -- 2.47.2 From eaac82ceb916c00142253ba61388d4d1125151d3 Mon Sep 17 00:00:00 2001 From: balandi1 Date: Thu, 21 Nov 2019 15:26:57 -0500 Subject: [PATCH 15/48] Few code improvements and refactoring --- def/taskUtils.go | 2 +- elektronLogging/clsfnTaskDistOverheadLogger.go | 13 +++++++------ elektronLogging/consoleLogger.go | 3 ++- elektronLogging/logger.go | 2 +- elektronLogging/pcpLogger.go | 3 ++- elektronLogging/schedPolicySwitchLogger.go | 3 ++- elektronLogging/schedTraceLogger.go | 3 ++- elektronLogging/schedWindowLogger.go | 3 ++- 8 files changed, 19 insertions(+), 13 deletions(-) diff --git a/def/taskUtils.go b/def/taskUtils.go index ce69a53..c358a27 100644 --- a/def/taskUtils.go +++ b/def/taskUtils.go @@ -109,7 +109,7 @@ func clusterSizeAvgMMMPU(tasks []Task, taskObservation func(task Task) []float64 // skip this value // there is an error in the task config. elekLog.ElektronLog.Log(elekLogTypes.CONSOLE, log.ErrorLevel, - log.Fields{}, fmt.Sprintf("%s", err)) + log.Fields{}, err.Error()) } } else { // There is only one observation for the task. diff --git a/elektronLogging/clsfnTaskDistOverheadLogger.go b/elektronLogging/clsfnTaskDistOverheadLogger.go index 8216c71..7bd62a1 100644 --- a/elektronLogging/clsfnTaskDistOverheadLogger.go +++ b/elektronLogging/clsfnTaskDistOverheadLogger.go @@ -3,21 +3,22 @@ package elektronLogging import ( log "github.com/sirupsen/logrus" "os" + "path/filepath" "strings" ) -type ClsfnTaskDistOverheadLogger struct { +type ClsfnTaskDistrOverheadLogger struct { LoggerImpl } -func NewClsfnTaskDistOverheadLogger(logType int, prefix string) *ClsfnTaskDistOverheadLogger { - cLog := &ClsfnTaskDistOverheadLogger{} +func NewClsfnTaskDistrOverheadLogger(logType int, prefix string) *ClsfnTaskDistrOverheadLogger { + cLog := &ClsfnTaskDistrOverheadLogger{} cLog.Type = logType cLog.SetLogFile(prefix) return cLog } -func (cLog *ClsfnTaskDistOverheadLogger) Log(logType int, level log.Level, logData log.Fields, message string) { +func (cLog *ClsfnTaskDistrOverheadLogger) Log(logType int, level log.Level, logData log.Fields, message string) { if cLog.Type == logType { logger.SetLevel(level) @@ -35,12 +36,12 @@ func (cLog *ClsfnTaskDistOverheadLogger) Log(logType int, level log.Level, logDa } } -func (cLog *ClsfnTaskDistOverheadLogger) SetLogFile(prefix string) { +func (cLog *ClsfnTaskDistrOverheadLogger) SetLogFile(prefix string) { tskDistLogPrefix := strings.Join([]string{prefix, config.TaskDistConfig.FilenameExtension}, "") dirName := logDir.getDirName() if dirName != "" { - tskDistLogPrefix = strings.Join([]string{dirName, tskDistLogPrefix}, "/") + tskDistLogPrefix = filepath.Join(dirName, tskDistLogPrefix) } if logFile, err := os.Create(tskDistLogPrefix); err != nil { log.Fatal("Unable to create logFile: ", err) diff --git a/elektronLogging/consoleLogger.go b/elektronLogging/consoleLogger.go index c142a7a..00e30e7 100644 --- a/elektronLogging/consoleLogger.go +++ b/elektronLogging/consoleLogger.go @@ -3,6 +3,7 @@ package elektronLogging import ( log "github.com/sirupsen/logrus" "os" + "path/filepath" "strings" ) @@ -37,7 +38,7 @@ func (cLog *ConsoleLogger) SetLogFile(prefix string) { consoleLogPrefix := strings.Join([]string{prefix, config.ConsoleConfig.FilenameExtension}, "") dirName := logDir.getDirName() if dirName != "" { - consoleLogPrefix = strings.Join([]string{dirName, consoleLogPrefix}, "/") + consoleLogPrefix = filepath.Join(dirName, consoleLogPrefix) } if logFile, err := os.Create(consoleLogPrefix); err != nil { log.Fatal("Unable to create logFile: ", err) diff --git a/elektronLogging/logger.go b/elektronLogging/logger.go index 1818536..72d32d7 100644 --- a/elektronLogging/logger.go +++ b/elektronLogging/logger.go @@ -39,7 +39,7 @@ func BuildLogger(prefix string) { schedTraceLog := NewSchedTraceLogger(SCHED_TRACE, prefix) spsLog := NewSchedPolicySwitchLogger(SPS, prefix) schedWindowLog := NewSchedWindowLogger(SCHED_WINDOW, prefix) - tskDistLog := NewClsfnTaskDistOverheadLogger(CLSFN_TASKDIST_OVERHEAD, prefix) + tskDistLog := NewClsfnTaskDistrOverheadLogger(CLSFN_TASKDIST_OVERHEAD, prefix) head.SetNext(cLog) cLog.SetNext(pLog) diff --git a/elektronLogging/pcpLogger.go b/elektronLogging/pcpLogger.go index 594ae95..e31369a 100644 --- a/elektronLogging/pcpLogger.go +++ b/elektronLogging/pcpLogger.go @@ -3,6 +3,7 @@ package elektronLogging import ( log "github.com/sirupsen/logrus" "os" + "path/filepath" "strings" ) @@ -40,7 +41,7 @@ func (plog *PcpLogger) SetLogFile(prefix string) { pcpLogPrefix := strings.Join([]string{prefix, config.PCPConfig.FilenameExtension}, "") dirName := logDir.getDirName() if dirName != "" { - pcpLogPrefix = strings.Join([]string{dirName, pcpLogPrefix}, "/") + pcpLogPrefix = filepath.Join(dirName, pcpLogPrefix) } if logFile, err := os.Create(pcpLogPrefix); err != nil { log.Fatal("Unable to create logFile: ", err) diff --git a/elektronLogging/schedPolicySwitchLogger.go b/elektronLogging/schedPolicySwitchLogger.go index ee72240..b6c7477 100644 --- a/elektronLogging/schedPolicySwitchLogger.go +++ b/elektronLogging/schedPolicySwitchLogger.go @@ -3,6 +3,7 @@ package elektronLogging import ( log "github.com/sirupsen/logrus" "os" + "path/filepath" "strings" ) @@ -40,7 +41,7 @@ func (sLog *SchedPolicySwitchLogger) SetLogFile(prefix string) { spsLogPrefix := strings.Join([]string{prefix, config.SPSConfig.FilenameExtension}, "") dirName := logDir.getDirName() if dirName != "" { - spsLogPrefix = strings.Join([]string{dirName, spsLogPrefix}, "/") + spsLogPrefix = filepath.Join(dirName, spsLogPrefix) } if logFile, err := os.Create(spsLogPrefix); err != nil { log.Fatal("Unable to create logFile: ", err) diff --git a/elektronLogging/schedTraceLogger.go b/elektronLogging/schedTraceLogger.go index 87ae4ec..91b06a9 100644 --- a/elektronLogging/schedTraceLogger.go +++ b/elektronLogging/schedTraceLogger.go @@ -3,6 +3,7 @@ package elektronLogging import ( log "github.com/sirupsen/logrus" "os" + "path/filepath" "strings" ) @@ -40,7 +41,7 @@ func (sLog *SchedTraceLogger) SetLogFile(prefix string) { schedTraceLogPrefix := strings.Join([]string{prefix, config.SchedTraceConfig.FilenameExtension}, "") dirName := logDir.getDirName() if dirName != "" { - schedTraceLogPrefix = strings.Join([]string{dirName, schedTraceLogPrefix}, "/") + schedTraceLogPrefix = filepath.Join(dirName, schedTraceLogPrefix) } if logFile, err := os.Create(schedTraceLogPrefix); err != nil { log.Fatal("Unable to create logFile: ", err) diff --git a/elektronLogging/schedWindowLogger.go b/elektronLogging/schedWindowLogger.go index ae55f95..6297c44 100644 --- a/elektronLogging/schedWindowLogger.go +++ b/elektronLogging/schedWindowLogger.go @@ -3,6 +3,7 @@ package elektronLogging import ( log "github.com/sirupsen/logrus" "os" + "path/filepath" "strings" ) @@ -40,7 +41,7 @@ func (sLog *SchedWindowLogger) SetLogFile(prefix string) { schedWindowLogPrefix := strings.Join([]string{prefix, config.SchedWindowConfig.FilenameExtension}, "") dirName := logDir.getDirName() if dirName != "" { - schedWindowLogPrefix = strings.Join([]string{dirName, schedWindowLogPrefix}, "/") + schedWindowLogPrefix = filepath.Join(dirName, schedWindowLogPrefix) } if logFile, err := os.Create(schedWindowLogPrefix); err != nil { log.Fatal("Unable to create logFile: ", err) -- 2.47.2 From 370a4906435004b5ef4f8239a02f530081ee1f95 Mon Sep 17 00:00:00 2001 From: balandi1 Date: Thu, 21 Nov 2019 18:04:59 -0500 Subject: [PATCH 16/48] Code Refactoring and modifications --- .../clsfnTaskDistOverheadLogger.go | 17 +++---- elektronLogging/consoleLogger.go | 17 +++---- elektronLogging/createLogDir.go | 1 + elektronLogging/loggerConfig.go | 51 +++++++++---------- elektronLogging/pcpLogger.go | 19 ++++--- elektronLogging/schedPolicySwitchLogger.go | 17 +++---- elektronLogging/schedTraceLogger.go | 17 +++---- elektronLogging/schedWindowLogger.go | 17 +++---- logConfig.yaml | 10 +--- 9 files changed, 75 insertions(+), 91 deletions(-) diff --git a/elektronLogging/clsfnTaskDistOverheadLogger.go b/elektronLogging/clsfnTaskDistOverheadLogger.go index 7bd62a1..d674233 100644 --- a/elektronLogging/clsfnTaskDistOverheadLogger.go +++ b/elektronLogging/clsfnTaskDistOverheadLogger.go @@ -18,7 +18,7 @@ func NewClsfnTaskDistrOverheadLogger(logType int, prefix string) *ClsfnTaskDistr return cLog } -func (cLog *ClsfnTaskDistrOverheadLogger) Log(logType int, level log.Level, logData log.Fields, message string) { +func (cLog ClsfnTaskDistrOverheadLogger) Log(logType int, level log.Level, logData log.Fields, message string) { if cLog.Type == logType { logger.SetLevel(level) @@ -38,15 +38,14 @@ func (cLog *ClsfnTaskDistrOverheadLogger) Log(logType int, level log.Level, logD func (cLog *ClsfnTaskDistrOverheadLogger) SetLogFile(prefix string) { - tskDistLogPrefix := strings.Join([]string{prefix, config.TaskDistConfig.FilenameExtension}, "") + filename := strings.Join([]string{prefix, config.TaskDistrConfig.FilenameExtension}, "") dirName := logDir.getDirName() if dirName != "" { - tskDistLogPrefix = filepath.Join(dirName, tskDistLogPrefix) - } - if logFile, err := os.Create(tskDistLogPrefix); err != nil { - log.Fatal("Unable to create logFile: ", err) - } else { - cLog.LogFileName = logFile - cLog.AllowOnConsole = config.TaskDistConfig.AllowOnConsole + if logFile, err := os.Create(filepath.Join(dirName, filename)); err != nil { + log.Fatal("Unable to create logFile: ", err) + } else { + cLog.LogFileName = logFile + cLog.AllowOnConsole = config.TaskDistrConfig.AllowOnConsole + } } } diff --git a/elektronLogging/consoleLogger.go b/elektronLogging/consoleLogger.go index 00e30e7..a213003 100644 --- a/elektronLogging/consoleLogger.go +++ b/elektronLogging/consoleLogger.go @@ -17,7 +17,7 @@ func NewConsoleLogger(logType int, prefix string) *ConsoleLogger { cLog.SetLogFile(prefix) return cLog } -func (cLog *ConsoleLogger) Log(logType int, level log.Level, logData log.Fields, message string) { +func (cLog ConsoleLogger) Log(logType int, level log.Level, logData log.Fields, message string) { if logType <= cLog.Type { logger.SetLevel(level) @@ -35,15 +35,14 @@ func (cLog *ConsoleLogger) Log(logType int, level log.Level, logData log.Fields, func (cLog *ConsoleLogger) SetLogFile(prefix string) { - consoleLogPrefix := strings.Join([]string{prefix, config.ConsoleConfig.FilenameExtension}, "") + filename := strings.Join([]string{prefix, config.ConsoleConfig.FilenameExtension}, "") dirName := logDir.getDirName() if dirName != "" { - consoleLogPrefix = filepath.Join(dirName, consoleLogPrefix) - } - if logFile, err := os.Create(consoleLogPrefix); err != nil { - log.Fatal("Unable to create logFile: ", err) - } else { - cLog.LogFileName = logFile - cLog.AllowOnConsole = true + if logFile, err := os.Create(filepath.Join(dirName, filename)); err != nil { + log.Fatal("Unable to create logFile: ", err) + } else { + cLog.LogFileName = logFile + cLog.AllowOnConsole = config.ConsoleConfig.AllowOnConsole + } } } diff --git a/elektronLogging/createLogDir.go b/elektronLogging/createLogDir.go index 8b9a148..8d82024 100644 --- a/elektronLogging/createLogDir.go +++ b/elektronLogging/createLogDir.go @@ -20,6 +20,7 @@ func (logD *logDirectory) createLogDir(prefix string, startTime time.Time) { if logD.name == "" { // Creating directory to store all logs for this run + // directory name format - 2019-November-21_14-33-0 logDirName := strings.Join([]string{"./", prefix, strconv.Itoa(startTime.Year())}, "") logDirName = strings.Join([]string{logDirName, startTime.Month().String(), strconv.Itoa(startTime.Day())}, "-") logDirName = strings.Join([]string{logDirName, strconv.Itoa(startTime.Hour())}, "_") diff --git a/elektronLogging/loggerConfig.go b/elektronLogging/loggerConfig.go index 790669e..a4f57ec 100644 --- a/elektronLogging/loggerConfig.go +++ b/elektronLogging/loggerConfig.go @@ -9,45 +9,40 @@ import ( type LoggerConfig struct { SchedTraceConfig struct { - Enabled bool `yaml:"enabled"` - FilenameExtension string `yaml:"filenameExtension"` - EnableColumnHeaders bool `yaml:"enableColumnHeaders"` - AllowOnConsole bool `yaml:"allowOnConsole"` + Enabled bool `yaml:"enabled"` + FilenameExtension string `yaml:"filenameExtension"` + AllowOnConsole bool `yaml:"allowOnConsole"` } `yaml:"schedTrace"` PCPConfig struct { - Enabled bool `yaml:"enabled"` - FilenameExtension string `yaml:"filenameExtension"` - EnableColumnHeaders bool `yaml:"enableColumnHeaders"` - AllowOnConsole bool `yaml:"allowOnConsole"` + Enabled bool `yaml:"enabled"` + FilenameExtension string `yaml:"filenameExtension"` + AllowOnConsole bool `yaml:"allowOnConsole"` } `yaml:"pcp"` ConsoleConfig struct { - Enabled bool `yaml:"enabled"` - FilenameExtension string `yaml:"filenameExtension"` - EnableColumnHeaders bool `yaml:"enableColumnHeaders"` - MinLogLevel string `yaml:"minLogLevel"` + Enabled bool `yaml:"enabled"` + FilenameExtension string `yaml:"filenameExtension"` + MinLogLevel string `yaml:"minLogLevel"` + AllowOnConsole bool `yaml:"allowOnConsole"` } `yaml:"console"` SPSConfig struct { - Enabled bool `yaml:"enabled"` - FilenameExtension string `yaml:"filenameExtension"` - EnableColumnHeaders bool `yaml:"enableColumnHeaders"` - AllowOnConsole bool `yaml:"allowOnConsole"` + Enabled bool `yaml:"enabled"` + FilenameExtension string `yaml:"filenameExtension"` + AllowOnConsole bool `yaml:"allowOnConsole"` } `yaml:"sps"` - TaskDistConfig struct { - Enabled bool `yaml:"enabled"` - FilenameExtension string `yaml:"filenameExtension"` - EnableColumnHeaders bool `yaml:"enableColumnHeaders"` - AllowOnConsole bool `yaml:"allowOnConsole"` - } `yaml:"clsfnTaskDistOverhead"` + TaskDistrConfig struct { + Enabled bool `yaml:"enabled"` + FilenameExtension string `yaml:"filenameExtension"` + AllowOnConsole bool `yaml:"allowOnConsole"` + } `yaml:"clsfnTaskDistrOverhead"` SchedWindowConfig struct { - Enabled bool `yaml:"enabled"` - FilenameExtension string `yaml:"filenameExtension"` - EnableColumnHeaders bool `yaml:"enableColumnHeaders"` - AllowOnConsole bool `yaml:"allowOnConsole"` + Enabled bool `yaml:"enabled"` + FilenameExtension string `yaml:"filenameExtension"` + AllowOnConsole bool `yaml:"allowOnConsole"` } `yaml:"schedWindow"` Format []string `yaml:"format"` @@ -57,11 +52,11 @@ func (c *LoggerConfig) GetConfig() *LoggerConfig { yamlFile, err := ioutil.ReadFile(elekEnv.LogConfigYaml) if err != nil { - log.Printf("yamlFile.Get err #%v ", err) + log.Printf("Error in reading yaml file #%v ", err) } err = yaml.Unmarshal(yamlFile, c) if err != nil { - log.Fatalf("Unmarshal: %v", err) + log.Fatalf("Error in yaml unmarshal: %v", err) } return c diff --git a/elektronLogging/pcpLogger.go b/elektronLogging/pcpLogger.go index e31369a..c6e7692 100644 --- a/elektronLogging/pcpLogger.go +++ b/elektronLogging/pcpLogger.go @@ -18,7 +18,7 @@ func NewPcpLogger(logType int, prefix string) *PcpLogger { return pLog } -func (pLog *PcpLogger) Log(logType int, level log.Level, logData log.Fields, message string) { +func (pLog PcpLogger) Log(logType int, level log.Level, logData log.Fields, message string) { if pLog.Type == logType { logger.SetLevel(level) @@ -36,17 +36,16 @@ func (pLog *PcpLogger) Log(logType int, level log.Level, logData log.Fields, mes } } -func (plog *PcpLogger) SetLogFile(prefix string) { +func (pLog *PcpLogger) SetLogFile(prefix string) { - pcpLogPrefix := strings.Join([]string{prefix, config.PCPConfig.FilenameExtension}, "") + filename := strings.Join([]string{prefix, config.PCPConfig.FilenameExtension}, "") dirName := logDir.getDirName() if dirName != "" { - pcpLogPrefix = filepath.Join(dirName, pcpLogPrefix) - } - if logFile, err := os.Create(pcpLogPrefix); err != nil { - log.Fatal("Unable to create logFile: ", err) - } else { - plog.LogFileName = logFile - plog.AllowOnConsole = config.PCPConfig.AllowOnConsole + if logFile, err := os.Create(filepath.Join(dirName, filename)); err != nil { + log.Fatal("Unable to create logFile: ", err) + } else { + pLog.LogFileName = logFile + pLog.AllowOnConsole = config.PCPConfig.AllowOnConsole + } } } diff --git a/elektronLogging/schedPolicySwitchLogger.go b/elektronLogging/schedPolicySwitchLogger.go index b6c7477..7275871 100644 --- a/elektronLogging/schedPolicySwitchLogger.go +++ b/elektronLogging/schedPolicySwitchLogger.go @@ -18,7 +18,7 @@ func NewSchedPolicySwitchLogger(logType int, prefix string) *SchedPolicySwitchLo return sLog } -func (sLog *SchedPolicySwitchLogger) Log(logType int, level log.Level, logData log.Fields, message string) { +func (sLog SchedPolicySwitchLogger) Log(logType int, level log.Level, logData log.Fields, message string) { if sLog.Type == logType { logger.SetLevel(level) @@ -38,15 +38,14 @@ func (sLog *SchedPolicySwitchLogger) Log(logType int, level log.Level, logData l func (sLog *SchedPolicySwitchLogger) SetLogFile(prefix string) { - spsLogPrefix := strings.Join([]string{prefix, config.SPSConfig.FilenameExtension}, "") + filename := strings.Join([]string{prefix, config.SPSConfig.FilenameExtension}, "") dirName := logDir.getDirName() if dirName != "" { - spsLogPrefix = filepath.Join(dirName, spsLogPrefix) - } - if logFile, err := os.Create(spsLogPrefix); err != nil { - log.Fatal("Unable to create logFile: ", err) - } else { - sLog.LogFileName = logFile - sLog.AllowOnConsole = config.SPSConfig.AllowOnConsole + if logFile, err := os.Create(filepath.Join(dirName, filename)); err != nil { + log.Fatal("Unable to create logFile: ", err) + } else { + sLog.LogFileName = logFile + sLog.AllowOnConsole = config.SPSConfig.AllowOnConsole + } } } diff --git a/elektronLogging/schedTraceLogger.go b/elektronLogging/schedTraceLogger.go index 91b06a9..da3df7c 100644 --- a/elektronLogging/schedTraceLogger.go +++ b/elektronLogging/schedTraceLogger.go @@ -18,7 +18,7 @@ func NewSchedTraceLogger(logType int, prefix string) *SchedTraceLogger { return sLog } -func (sLog *SchedTraceLogger) Log(logType int, level log.Level, logData log.Fields, message string) { +func (sLog SchedTraceLogger) Log(logType int, level log.Level, logData log.Fields, message string) { if sLog.Type == logType { logger.SetLevel(level) @@ -38,15 +38,14 @@ func (sLog *SchedTraceLogger) Log(logType int, level log.Level, logData log.Fiel func (sLog *SchedTraceLogger) SetLogFile(prefix string) { - schedTraceLogPrefix := strings.Join([]string{prefix, config.SchedTraceConfig.FilenameExtension}, "") + filename := strings.Join([]string{prefix, config.SchedTraceConfig.FilenameExtension}, "") dirName := logDir.getDirName() if dirName != "" { - schedTraceLogPrefix = filepath.Join(dirName, schedTraceLogPrefix) - } - if logFile, err := os.Create(schedTraceLogPrefix); err != nil { - log.Fatal("Unable to create logFile: ", err) - } else { - sLog.LogFileName = logFile - sLog.AllowOnConsole = config.SchedTraceConfig.AllowOnConsole + if logFile, err := os.Create(filepath.Join(dirName, filename)); err != nil { + log.Fatal("Unable to create logFile: ", err) + } else { + sLog.LogFileName = logFile + sLog.AllowOnConsole = config.SchedTraceConfig.AllowOnConsole + } } } diff --git a/elektronLogging/schedWindowLogger.go b/elektronLogging/schedWindowLogger.go index 6297c44..e51677c 100644 --- a/elektronLogging/schedWindowLogger.go +++ b/elektronLogging/schedWindowLogger.go @@ -18,7 +18,7 @@ func NewSchedWindowLogger(logType int, prefix string) *SchedWindowLogger { return sLog } -func (sLog *SchedWindowLogger) Log(logType int, level log.Level, logData log.Fields, message string) { +func (sLog SchedWindowLogger) Log(logType int, level log.Level, logData log.Fields, message string) { if sLog.Type == logType { logger.SetLevel(level) @@ -38,15 +38,14 @@ func (sLog *SchedWindowLogger) Log(logType int, level log.Level, logData log.Fie func (sLog *SchedWindowLogger) SetLogFile(prefix string) { - schedWindowLogPrefix := strings.Join([]string{prefix, config.SchedWindowConfig.FilenameExtension}, "") + filename := strings.Join([]string{prefix, config.SchedWindowConfig.FilenameExtension}, "") dirName := logDir.getDirName() if dirName != "" { - schedWindowLogPrefix = filepath.Join(dirName, schedWindowLogPrefix) - } - if logFile, err := os.Create(schedWindowLogPrefix); err != nil { - log.Fatal("Unable to create logFile: ", err) - } else { - sLog.LogFileName = logFile - sLog.AllowOnConsole = config.SchedWindowConfig.AllowOnConsole + if logFile, err := os.Create(filepath.Join(dirName, filename)); err != nil { + log.Fatal("Unable to create logFile: ", err) + } else { + sLog.LogFileName = logFile + sLog.AllowOnConsole = config.SchedWindowConfig.AllowOnConsole + } } } diff --git a/logConfig.yaml b/logConfig.yaml index 24be410..9c4302b 100644 --- a/logConfig.yaml +++ b/logConfig.yaml @@ -1,36 +1,30 @@ schedTrace: enabled: true filenameExtension: _schedTrace.log - enablecolumnheaders: true allowOnConsole: true sps: enabled: false filenameExtension: _schedPolicySwitch.log - enableColumnHeaders: true allowOnConsole: true console: enabled: true filenameExtension: _console.log minLogLevel: debug - enableColumnHeaders: true + allowOnConsole: true pcp: enabled: true filenameExtension: .pcplog - enableColumnHeaders: true allowOnConsole: false schedWindow: enabled: true filenameExtension: _schedWindow.log - enableColumnHeaders: true allowOnConsole: true -clsfnTaskDistOverhead: +clsfnTaskDistrOverhead: enabled: true filenameExtension: _classificationOverhead.log - enableColumnHeaders: true allowOnConsole: true -# format. format: - level - timestamp -- 2.47.2 From ef6d154d062360a9b487efd4dcaf3f4e03d84462 Mon Sep 17 00:00:00 2001 From: balandi1 Date: Tue, 26 Nov 2019 12:48:48 -0500 Subject: [PATCH 17/48] Refactoring Code Renamed PcpLogger, SetLogFile(), LogFileName. Changed error messages in loggerConfig. --- elektronLogging/clsfnTaskDistOverheadLogger.go | 8 ++++---- elektronLogging/consoleLogger.go | 8 ++++---- elektronLogging/logger.go | 2 +- elektronLogging/loggerChain.go | 4 ++-- elektronLogging/loggerConfig.go | 2 +- elektronLogging/pcpLogger.go | 16 ++++++++-------- elektronLogging/schedPolicySwitchLogger.go | 8 ++++---- elektronLogging/schedTraceLogger.go | 8 ++++---- elektronLogging/schedWindowLogger.go | 8 ++++---- 9 files changed, 32 insertions(+), 32 deletions(-) diff --git a/elektronLogging/clsfnTaskDistOverheadLogger.go b/elektronLogging/clsfnTaskDistOverheadLogger.go index d674233..2b70b62 100644 --- a/elektronLogging/clsfnTaskDistOverheadLogger.go +++ b/elektronLogging/clsfnTaskDistOverheadLogger.go @@ -14,7 +14,7 @@ type ClsfnTaskDistrOverheadLogger struct { func NewClsfnTaskDistrOverheadLogger(logType int, prefix string) *ClsfnTaskDistrOverheadLogger { cLog := &ClsfnTaskDistrOverheadLogger{} cLog.Type = logType - cLog.SetLogFile(prefix) + cLog.CreateLogFile(prefix) return cLog } @@ -28,7 +28,7 @@ func (cLog ClsfnTaskDistrOverheadLogger) Log(logType int, level log.Level, logDa logger.WithFields(logData).Println(message) } - logger.SetOutput(cLog.LogFileName) + logger.SetOutput(cLog.LogFile) logger.WithFields(logData).Println(message) } if cLog.next != nil { @@ -36,7 +36,7 @@ func (cLog ClsfnTaskDistrOverheadLogger) Log(logType int, level log.Level, logDa } } -func (cLog *ClsfnTaskDistrOverheadLogger) SetLogFile(prefix string) { +func (cLog *ClsfnTaskDistrOverheadLogger) CreateLogFile(prefix string) { filename := strings.Join([]string{prefix, config.TaskDistrConfig.FilenameExtension}, "") dirName := logDir.getDirName() @@ -44,7 +44,7 @@ func (cLog *ClsfnTaskDistrOverheadLogger) SetLogFile(prefix string) { if logFile, err := os.Create(filepath.Join(dirName, filename)); err != nil { log.Fatal("Unable to create logFile: ", err) } else { - cLog.LogFileName = logFile + cLog.LogFile = logFile cLog.AllowOnConsole = config.TaskDistrConfig.AllowOnConsole } } diff --git a/elektronLogging/consoleLogger.go b/elektronLogging/consoleLogger.go index a213003..fd2d079 100644 --- a/elektronLogging/consoleLogger.go +++ b/elektronLogging/consoleLogger.go @@ -14,7 +14,7 @@ type ConsoleLogger struct { func NewConsoleLogger(logType int, prefix string) *ConsoleLogger { cLog := &ConsoleLogger{} cLog.Type = logType - cLog.SetLogFile(prefix) + cLog.CreateLogFile(prefix) return cLog } func (cLog ConsoleLogger) Log(logType int, level log.Level, logData log.Fields, message string) { @@ -25,7 +25,7 @@ func (cLog ConsoleLogger) Log(logType int, level log.Level, logData log.Fields, logger.SetOutput(os.Stdout) logger.WithFields(logData).Println(message) - logger.SetOutput(cLog.LogFileName) + logger.SetOutput(cLog.LogFile) logger.WithFields(logData).Println(message) } if cLog.next != nil { @@ -33,7 +33,7 @@ func (cLog ConsoleLogger) Log(logType int, level log.Level, logData log.Fields, } } -func (cLog *ConsoleLogger) SetLogFile(prefix string) { +func (cLog *ConsoleLogger) CreateLogFile(prefix string) { filename := strings.Join([]string{prefix, config.ConsoleConfig.FilenameExtension}, "") dirName := logDir.getDirName() @@ -41,7 +41,7 @@ func (cLog *ConsoleLogger) SetLogFile(prefix string) { if logFile, err := os.Create(filepath.Join(dirName, filename)); err != nil { log.Fatal("Unable to create logFile: ", err) } else { - cLog.LogFileName = logFile + cLog.LogFile = logFile cLog.AllowOnConsole = config.ConsoleConfig.AllowOnConsole } } diff --git a/elektronLogging/logger.go b/elektronLogging/logger.go index 72d32d7..9178c39 100644 --- a/elektronLogging/logger.go +++ b/elektronLogging/logger.go @@ -35,7 +35,7 @@ func BuildLogger(prefix string) { // create a chain of loggers head := &LoggerImpl{} cLog := NewConsoleLogger(CONSOLE, prefix) - pLog := NewPcpLogger(PCP, prefix) + pLog := NewPCPLogger(PCP, prefix) schedTraceLog := NewSchedTraceLogger(SCHED_TRACE, prefix) spsLog := NewSchedPolicySwitchLogger(SPS, prefix) schedWindowLog := NewSchedWindowLogger(SCHED_WINDOW, prefix) diff --git a/elektronLogging/loggerChain.go b/elektronLogging/loggerChain.go index 8a8207a..b92904c 100644 --- a/elektronLogging/loggerChain.go +++ b/elektronLogging/loggerChain.go @@ -8,12 +8,12 @@ import ( type Logger interface { SetNext(logType Logger) Log(logType int, level log.Level, logData log.Fields, message string) - SetLogFile(prefix string) + CreateLogFile(prefix string) } type LoggerImpl struct { Type int AllowOnConsole bool - LogFileName *os.File + LogFile *os.File next Logger } diff --git a/elektronLogging/loggerConfig.go b/elektronLogging/loggerConfig.go index a4f57ec..344540e 100644 --- a/elektronLogging/loggerConfig.go +++ b/elektronLogging/loggerConfig.go @@ -56,7 +56,7 @@ func (c *LoggerConfig) GetConfig() *LoggerConfig { } err = yaml.Unmarshal(yamlFile, c) if err != nil { - log.Fatalf("Error in yaml unmarshal: %v", err) + log.Fatalf("Error in unmarshalling yaml: %v", err) } return c diff --git a/elektronLogging/pcpLogger.go b/elektronLogging/pcpLogger.go index c6e7692..db1e432 100644 --- a/elektronLogging/pcpLogger.go +++ b/elektronLogging/pcpLogger.go @@ -7,18 +7,18 @@ import ( "strings" ) -type PcpLogger struct { +type PCPLogger struct { LoggerImpl } -func NewPcpLogger(logType int, prefix string) *PcpLogger { - pLog := &PcpLogger{} +func NewPCPLogger(logType int, prefix string) *PCPLogger { + pLog := &PCPLogger{} pLog.Type = logType - pLog.SetLogFile(prefix) + pLog.CreateLogFile(prefix) return pLog } -func (pLog PcpLogger) Log(logType int, level log.Level, logData log.Fields, message string) { +func (pLog PCPLogger) Log(logType int, level log.Level, logData log.Fields, message string) { if pLog.Type == logType { logger.SetLevel(level) @@ -28,7 +28,7 @@ func (pLog PcpLogger) Log(logType int, level log.Level, logData log.Fields, mess logger.WithFields(logData).Println(message) } - logger.SetOutput(pLog.LogFileName) + logger.SetOutput(pLog.LogFile) logger.WithFields(logData).Println(message) } if pLog.next != nil { @@ -36,7 +36,7 @@ func (pLog PcpLogger) Log(logType int, level log.Level, logData log.Fields, mess } } -func (pLog *PcpLogger) SetLogFile(prefix string) { +func (pLog *PCPLogger) CreateLogFile(prefix string) { filename := strings.Join([]string{prefix, config.PCPConfig.FilenameExtension}, "") dirName := logDir.getDirName() @@ -44,7 +44,7 @@ func (pLog *PcpLogger) SetLogFile(prefix string) { if logFile, err := os.Create(filepath.Join(dirName, filename)); err != nil { log.Fatal("Unable to create logFile: ", err) } else { - pLog.LogFileName = logFile + pLog.LogFile = logFile pLog.AllowOnConsole = config.PCPConfig.AllowOnConsole } } diff --git a/elektronLogging/schedPolicySwitchLogger.go b/elektronLogging/schedPolicySwitchLogger.go index 7275871..bae2c3e 100644 --- a/elektronLogging/schedPolicySwitchLogger.go +++ b/elektronLogging/schedPolicySwitchLogger.go @@ -14,7 +14,7 @@ type SchedPolicySwitchLogger struct { func NewSchedPolicySwitchLogger(logType int, prefix string) *SchedPolicySwitchLogger { sLog := &SchedPolicySwitchLogger{} sLog.Type = logType - sLog.SetLogFile(prefix) + sLog.CreateLogFile(prefix) return sLog } @@ -28,7 +28,7 @@ func (sLog SchedPolicySwitchLogger) Log(logType int, level log.Level, logData lo logger.WithFields(logData).Println(message) } - logger.SetOutput(sLog.LogFileName) + logger.SetOutput(sLog.LogFile) logger.WithFields(logData).Println(message) } if sLog.next != nil { @@ -36,7 +36,7 @@ func (sLog SchedPolicySwitchLogger) Log(logType int, level log.Level, logData lo } } -func (sLog *SchedPolicySwitchLogger) SetLogFile(prefix string) { +func (sLog *SchedPolicySwitchLogger) CreateLogFile(prefix string) { filename := strings.Join([]string{prefix, config.SPSConfig.FilenameExtension}, "") dirName := logDir.getDirName() @@ -44,7 +44,7 @@ func (sLog *SchedPolicySwitchLogger) SetLogFile(prefix string) { if logFile, err := os.Create(filepath.Join(dirName, filename)); err != nil { log.Fatal("Unable to create logFile: ", err) } else { - sLog.LogFileName = logFile + sLog.LogFile = logFile sLog.AllowOnConsole = config.SPSConfig.AllowOnConsole } } diff --git a/elektronLogging/schedTraceLogger.go b/elektronLogging/schedTraceLogger.go index da3df7c..8a4c5ba 100644 --- a/elektronLogging/schedTraceLogger.go +++ b/elektronLogging/schedTraceLogger.go @@ -14,7 +14,7 @@ type SchedTraceLogger struct { func NewSchedTraceLogger(logType int, prefix string) *SchedTraceLogger { sLog := &SchedTraceLogger{} sLog.Type = logType - sLog.SetLogFile(prefix) + sLog.CreateLogFile(prefix) return sLog } @@ -28,7 +28,7 @@ func (sLog SchedTraceLogger) Log(logType int, level log.Level, logData log.Field logger.WithFields(logData).Println(message) } - logger.SetOutput(sLog.LogFileName) + logger.SetOutput(sLog.LogFile) logger.WithFields(logData).Println(message) } if sLog.next != nil { @@ -36,7 +36,7 @@ func (sLog SchedTraceLogger) Log(logType int, level log.Level, logData log.Field } } -func (sLog *SchedTraceLogger) SetLogFile(prefix string) { +func (sLog *SchedTraceLogger) CreateLogFile(prefix string) { filename := strings.Join([]string{prefix, config.SchedTraceConfig.FilenameExtension}, "") dirName := logDir.getDirName() @@ -44,7 +44,7 @@ func (sLog *SchedTraceLogger) SetLogFile(prefix string) { if logFile, err := os.Create(filepath.Join(dirName, filename)); err != nil { log.Fatal("Unable to create logFile: ", err) } else { - sLog.LogFileName = logFile + sLog.LogFile = logFile sLog.AllowOnConsole = config.SchedTraceConfig.AllowOnConsole } } diff --git a/elektronLogging/schedWindowLogger.go b/elektronLogging/schedWindowLogger.go index e51677c..09fc633 100644 --- a/elektronLogging/schedWindowLogger.go +++ b/elektronLogging/schedWindowLogger.go @@ -14,7 +14,7 @@ type SchedWindowLogger struct { func NewSchedWindowLogger(logType int, prefix string) *SchedWindowLogger { sLog := &SchedWindowLogger{} sLog.Type = logType - sLog.SetLogFile(prefix) + sLog.CreateLogFile(prefix) return sLog } @@ -28,7 +28,7 @@ func (sLog SchedWindowLogger) Log(logType int, level log.Level, logData log.Fiel logger.WithFields(logData).Println(message) } - logger.SetOutput(sLog.LogFileName) + logger.SetOutput(sLog.LogFile) logger.WithFields(logData).Println(message) } if sLog.next != nil { @@ -36,7 +36,7 @@ func (sLog SchedWindowLogger) Log(logType int, level log.Level, logData log.Fiel } } -func (sLog *SchedWindowLogger) SetLogFile(prefix string) { +func (sLog *SchedWindowLogger) CreateLogFile(prefix string) { filename := strings.Join([]string{prefix, config.SchedWindowConfig.FilenameExtension}, "") dirName := logDir.getDirName() @@ -44,7 +44,7 @@ func (sLog *SchedWindowLogger) SetLogFile(prefix string) { if logFile, err := os.Create(filepath.Join(dirName, filename)); err != nil { log.Fatal("Unable to create logFile: ", err) } else { - sLog.LogFileName = logFile + sLog.LogFile = logFile sLog.AllowOnConsole = config.SchedWindowConfig.AllowOnConsole } } -- 2.47.2 From 24dbbb208fd9be533c917b102e67e3e80675aba3 Mon Sep 17 00:00:00 2001 From: balandi1 Date: Tue, 26 Nov 2019 13:08:45 -0500 Subject: [PATCH 18/48] Flag for Logger Config yaml file name Removed yaml filename from env.go and added its flag to scheduler.go --- elektronLogging/logger.go | 4 ++-- elektronLogging/loggerChain.go | 2 +- elektronLogging/loggerConfig.go | 5 ++--- environment/env.go | 2 -- scheduler.go | 4 +++- 5 files changed, 8 insertions(+), 9 deletions(-) diff --git a/elektronLogging/logger.go b/elektronLogging/logger.go index 9178c39..9c30bed 100644 --- a/elektronLogging/logger.go +++ b/elektronLogging/logger.go @@ -14,10 +14,10 @@ var formatter ElektronFormatter var ElektronLog *LoggerImpl var logDir logDirectory -func BuildLogger(prefix string) { +func BuildLogger(prefix string, logConfigFilename string) { // read configuration from yaml - config.GetConfig() + config.GetConfig(logConfigFilename) // create the log directory startTime := time.Now() diff --git a/elektronLogging/loggerChain.go b/elektronLogging/loggerChain.go index b92904c..3cd2ff3 100644 --- a/elektronLogging/loggerChain.go +++ b/elektronLogging/loggerChain.go @@ -13,7 +13,7 @@ type Logger interface { type LoggerImpl struct { Type int AllowOnConsole bool - LogFile *os.File + LogFile *os.File next Logger } diff --git a/elektronLogging/loggerConfig.go b/elektronLogging/loggerConfig.go index 344540e..06ac247 100644 --- a/elektronLogging/loggerConfig.go +++ b/elektronLogging/loggerConfig.go @@ -2,7 +2,6 @@ package elektronLogging import ( log "github.com/sirupsen/logrus" - elekEnv "github.com/spdfg/elektron/environment" "gopkg.in/yaml.v2" "io/ioutil" ) @@ -48,9 +47,9 @@ type LoggerConfig struct { Format []string `yaml:"format"` } -func (c *LoggerConfig) GetConfig() *LoggerConfig { +func (c *LoggerConfig) GetConfig(logConfigFilename string) *LoggerConfig { - yamlFile, err := ioutil.ReadFile(elekEnv.LogConfigYaml) + yamlFile, err := ioutil.ReadFile(logConfigFilename) if err != nil { log.Printf("Error in reading yaml file #%v ", err) } diff --git a/environment/env.go b/environment/env.go index c1abed1..239e104 100644 --- a/environment/env.go +++ b/environment/env.go @@ -26,5 +26,3 @@ var RaplPassword = "RAPL_PSSWD" // Location of the script that sets the powercap value for a host. var RaplThrottleScriptLocation = "RAPL_PKG_THROTTLE_SCRIPT_LOCATION" - -var LogConfigYaml = "logConfig.yaml" diff --git a/scheduler.go b/scheduler.go index 5ec6bc5..299dfca 100644 --- a/scheduler.go +++ b/scheduler.go @@ -55,6 +55,7 @@ var fixFirstSchedPol = flag.String("fixFirstSchedPol", "", "Name of the scheduli var fixSchedWindow = flag.Bool("fixSchedWindow", false, "Fix the size of the scheduling window that every deployed scheduling policy should schedule, provided switching is enabled.") var schedWindowSize = flag.Int("schedWindowSize", 200, "Size of the scheduling window if fixSchedWindow is set.") var schedPolSwitchCriteria = flag.String("schedPolSwitchCriteria", "taskDist", "Scheduling policy switching criteria.") +var logConfigFilename = flag.String("logConfigFilename", "logConfig.yaml", "Log Configuration file name") // Short hand args func init() { @@ -76,6 +77,7 @@ func init() { flag.BoolVar(fixSchedWindow, "fixSw", false, "Fix the size of the scheduling window that every deployed scheduling policy should schedule, provided switching is enabled (shorthand).") flag.IntVar(schedWindowSize, "swSize", 200, "Size of the scheduling window if fixSchedWindow is set (shorthand).") flag.StringVar(schedPolSwitchCriteria, "spsCriteria", "taskDist", "Scheduling policy switching criteria (shorthand).") + flag.StringVar(logConfigFilename, "lgConfigName", "logConfig.yaml", "Log Configuration file name (shorthand).") } func listAllSchedulingPolicies() { @@ -223,7 +225,7 @@ func main() { if strings.Contains(*pcplogPrefix, "/") { log.Fatal("log file prefix should not contain '/'.") } - elekLog.BuildLogger(*pcplogPrefix) + elekLog.BuildLogger(*pcplogPrefix, *logConfigFilename) // Starting PCP logging. if noPowercap { -- 2.47.2 From bb8c0a79d6b5a38ebf4e37d0fb90407b27220876 Mon Sep 17 00:00:00 2001 From: balandi1 Date: Tue, 26 Nov 2019 13:19:15 -0500 Subject: [PATCH 19/48] Minor code improvements Removed commented code. Resolved spacing issue in yaml. --- elektronLogging/ElektronFormatter.go | 3 +-- logConfig.yaml | 18 +++++++++--------- schedulers/helpers.go | 8 -------- 3 files changed, 10 insertions(+), 19 deletions(-) diff --git a/elektronLogging/ElektronFormatter.go b/elektronLogging/ElektronFormatter.go index c54fc6a..066cb95 100644 --- a/elektronLogging/ElektronFormatter.go +++ b/elektronLogging/ElektronFormatter.go @@ -40,8 +40,7 @@ func (f ElektronFormatter) Format(entry *log.Entry) ([]byte, error) { var formattedFields []string for key, value := range entry.Data { - formattedFields = append(formattedFields, - strings.Join([]string{key, value.(string)}, "=")) + formattedFields = append(formattedFields, strings.Join([]string{key, value.(string)}, "=")) } b.WriteString(message) diff --git a/logConfig.yaml b/logConfig.yaml index 9c4302b..70d5260 100644 --- a/logConfig.yaml +++ b/logConfig.yaml @@ -12,17 +12,17 @@ console: minLogLevel: debug allowOnConsole: true pcp: - enabled: true - filenameExtension: .pcplog - allowOnConsole: false + enabled: true + filenameExtension: .pcplog + allowOnConsole: false schedWindow: - enabled: true - filenameExtension: _schedWindow.log - allowOnConsole: true + enabled: true + filenameExtension: _schedWindow.log + allowOnConsole: true clsfnTaskDistrOverhead: - enabled: true - filenameExtension: _classificationOverhead.log - allowOnConsole: true + enabled: true + filenameExtension: _classificationOverhead.log + allowOnConsole: true format: diff --git a/schedulers/helpers.go b/schedulers/helpers.go index 252190e..f69375d 100644 --- a/schedulers/helpers.go +++ b/schedulers/helpers.go @@ -134,14 +134,6 @@ func WithPCPLog(pcpLog chan struct{}) SchedulerOptions { } } -/*func WithLoggingChannels(lmt chan elekLogDef.LogMessageType, msg chan string) SchedulerOptions { - return func(s ElectronScheduler) error { - s.(*BaseScheduler).logMsgType = lmt - s.(*BaseScheduler).logMsg = msg - return nil - } -}*/ - func WithSchedPolSwitchEnabled(enableSchedPolicySwitch bool, switchingCriteria string) SchedulerOptions { return func(s ElectronScheduler) error { s.(*BaseScheduler).schedPolSwitchEnabled = enableSchedPolicySwitch -- 2.47.2 From c66afa62b2e0e11cf7fbff7828408f76f1600c8c Mon Sep 17 00:00:00 2001 From: balandi1 Date: Tue, 26 Nov 2019 13:40:37 -0500 Subject: [PATCH 20/48] Code refactoring Removed lmt usage in base.go. Removed unneccessary fmt.Sprintf() usage. --- schedulers/base.go | 74 ++++++++++-------------------- schedulers/helpers.go | 10 ++-- utilities/offerUtils/offerUtils.go | 8 ++-- 3 files changed, 31 insertions(+), 61 deletions(-) diff --git a/schedulers/base.go b/schedulers/base.go index 1238602..31c0d34 100644 --- a/schedulers/base.go +++ b/schedulers/base.go @@ -249,12 +249,11 @@ func (s *BaseScheduler) StatusUpdate(driver sched.SchedulerDriver, status *mesos } func (s *BaseScheduler) LogTaskStarting(ts *def.Task, offer *mesos.Offer) { - lmt := elekLogTypes.CONSOLE if ts == nil { - elekLog.ElektronLog.Log(lmt, log.InfoLevel, + elekLog.ElektronLog.Log(elekLogTypes.CONSOLE, log.InfoLevel, log.Fields{"host": fmt.Sprintf("%s", offer.GetHostname())}, "TASKS STARTING...") } else { - elekLog.ElektronLog.Log(lmt, + elekLog.ElektronLog.Log(elekLogTypes.CONSOLE, log.InfoLevel, log.Fields{"task": fmt.Sprintf("%s", ts.Name), "Instance": fmt.Sprintf("%d", *ts.Instances), "host": fmt.Sprintf("%s", offer.GetHostname())}, @@ -263,42 +262,37 @@ func (s *BaseScheduler) LogTaskStarting(ts *def.Task, offer *mesos.Offer) { } func (s *BaseScheduler) LogTaskWattsConsideration(ts def.Task, host string, wattsToConsider float64) { - lmt := elekLogTypes.CONSOLE - elekLog.ElektronLog.Log(lmt, + elekLog.ElektronLog.Log(elekLogTypes.CONSOLE, log.InfoLevel, log.Fields{"task": ts.Name, "host": host, "Watts": fmt.Sprintf("%f", wattsToConsider)}, "Watts considered for ") } func (s *BaseScheduler) LogOffersReceived(offers []*mesos.Offer) { - lmt := elekLogTypes.CONSOLE - elekLog.ElektronLog.Log(lmt, + elekLog.ElektronLog.Log(elekLogTypes.CONSOLE, log.InfoLevel, log.Fields{"Resource offers received": fmt.Sprintf("%d", len(offers))}, "") } func (s *BaseScheduler) LogNoPendingTasksDeclineOffers(offer *mesos.Offer) { - lmt := elekLogTypes.CONSOLE - elekLog.ElektronLog.Log(lmt, + elekLog.ElektronLog.Log(elekLogTypes.CONSOLE, log.WarnLevel, log.Fields{"DECLINING OFFER for host": fmt.Sprintf("%s", offer.GetHostname())}, "No tasks left to schedule ") } func (s *BaseScheduler) LogNumberOfRunningTasks() { - lmt := elekLogTypes.CONSOLE - elekLog.ElektronLog.Log(lmt, + elekLog.ElektronLog.Log(elekLogTypes.CONSOLE, log.InfoLevel, log.Fields{"Number of tasks still Running": fmt.Sprintf("%d", s.tasksRunning)}, "") } func (s *BaseScheduler) LogCoLocatedTasks(slaveID string) { - lmt := elekLogTypes.CONSOLE buffer := bytes.Buffer{} s.TasksRunningMutex.Lock() for taskName := range s.Running[slaveID] { buffer.WriteString(fmt.Sprintln(taskName)) } s.TasksRunningMutex.Unlock() - elekLog.ElektronLog.Log(lmt, + elekLog.ElektronLog.Log(elekLogTypes.CONSOLE, log.InfoLevel, log.Fields{"Colocated with": fmt.Sprintf("%s", buffer.String())}, "") } @@ -310,89 +304,72 @@ func (s *BaseScheduler) LogSchedTrace(taskToSchedule *mesos.TaskInfo, offer *mes } func (s *BaseScheduler) LogTerminateScheduler() { - lmt := elekLogTypes.CONSOLE - elekLog.ElektronLog.Log(lmt, - log.InfoLevel, - log.Fields{}, "Done scheduling all tasks!") + elekLog.ElektronLog.Log(elekLogTypes.CONSOLE, log.InfoLevel, log.Fields{}, "Done scheduling all tasks!") } func (s *BaseScheduler) LogInsufficientResourcesDeclineOffer(offer *mesos.Offer, offerResources ...interface{}) { - lmt := elekLogTypes.CONSOLE buffer := bytes.Buffer{} buffer.WriteString(fmt.Sprintf("", offerResources...)) - elekLog.ElektronLog.Log(lmt, + elekLog.ElektronLog.Log(elekLogTypes.CONSOLE, log.WarnLevel, log.Fields{"Offer Resources": fmt.Sprintf("%s", buffer.String())}, "DECLINING OFFER... Offer has insufficient resources to launch a task") } func (s *BaseScheduler) LogOfferRescinded(offerID *mesos.OfferID) { - lmt := elekLogTypes.CONSOLE - elekLog.ElektronLog.Log(lmt, + elekLog.ElektronLog.Log(elekLogTypes.CONSOLE, log.ErrorLevel, log.Fields{"OfferID": fmt.Sprintf("%s", offerID)}, "OFFER RESCINDED") } func (s *BaseScheduler) LogSlaveLost(slaveID *mesos.SlaveID) { - lmt := elekLogTypes.CONSOLE - elekLog.ElektronLog.Log(lmt, + elekLog.ElektronLog.Log(elekLogTypes.CONSOLE, log.ErrorLevel, log.Fields{"SlaveID": fmt.Sprintf("%s", slaveID)}, "SLAVE LOST") } func (s *BaseScheduler) LogExecutorLost(executorID *mesos.ExecutorID, slaveID *mesos.SlaveID) { - lmt := elekLogTypes.CONSOLE - elekLog.ElektronLog.Log(lmt, + elekLog.ElektronLog.Log(elekLogTypes.CONSOLE, log.ErrorLevel, log.Fields{"ExecutorID": fmt.Sprintf("%s", executorID), "SlaveID": fmt.Sprintf("%s", slaveID)}, "EXECUTOR LOST") } func (s *BaseScheduler) LogFrameworkMessage(executorID *mesos.ExecutorID, slaveID *mesos.SlaveID, message string) { - lmt := elekLogTypes.CONSOLE - elekLog.ElektronLog.Log(lmt, + elekLog.ElektronLog.Log(elekLogTypes.CONSOLE, log.InfoLevel, log.Fields{"Received Framework message from executor": executorID}, message) } func (s *BaseScheduler) LogMesosError(err string) { - lmt := elekLogTypes.CONSOLE - elekLog.ElektronLog.Log(lmt, + elekLog.ElektronLog.Log(elekLogTypes.CONSOLE, log.ErrorLevel, log.Fields{"MESOS CONSOLE": fmt.Sprintf("%v", err)}, "") } func (s *BaseScheduler) LogElectronError(err error) { - lmt := elekLogTypes.CONSOLE - elekLog.ElektronLog.Log(lmt, - log.ErrorLevel, - log.Fields{"ELECTRON CONSOLE": fmt.Sprintf("%v", err)}, "") + elekLog.ElektronLog.Log(elekLogTypes.CONSOLE, + log.ErrorLevel, log.Fields{"ELECTRON CONSOLE": fmt.Sprintf("%v", err)}, "") } func (s *BaseScheduler) LogFrameworkRegistered(frameworkID *mesos.FrameworkID, masterInfo *mesos.MasterInfo) { - lmt := elekLogTypes.CONSOLE - elekLog.ElektronLog.Log(lmt, + elekLog.ElektronLog.Log(elekLogTypes.CONSOLE, log.InfoLevel, - log.Fields{"frameworkID": fmt.Sprintf("%s", frameworkID), "master": fmt.Sprintf("%s", masterInfo)}, "FRAMEWORK REGISTERED!") + log.Fields{"frameworkID": fmt.Sprintf("%s", frameworkID), "master": fmt.Sprintf("%v", masterInfo)}, "FRAMEWORK REGISTERED!") } func (s *BaseScheduler) LogFrameworkReregistered(masterInfo *mesos.MasterInfo) { - lmt := elekLogTypes.CONSOLE - elekLog.ElektronLog.Log(lmt, + elekLog.ElektronLog.Log(elekLogTypes.CONSOLE, log.InfoLevel, - log.Fields{"master": fmt.Sprintf("%s", masterInfo)}, "Framework re-registered") + log.Fields{"master": fmt.Sprintf("%v", masterInfo)}, "Framework re-registered") } func (s *BaseScheduler) LogDisconnected() { - lmt := elekLogTypes.CONSOLE - elekLog.ElektronLog.Log(lmt, - log.WarnLevel, - log.Fields{}, "Framework disconnected with master") + elekLog.ElektronLog.Log(elekLogTypes.CONSOLE, log.WarnLevel, log.Fields{}, "Framework disconnected with master") } func (s *BaseScheduler) LogTaskStatusUpdate(status *mesos.TaskStatus) { - lmt := elekLogTypes.CONSOLE level := log.InfoLevel switch *status.State { case mesos.TaskState_TASK_ERROR, mesos.TaskState_TASK_FAILED, @@ -401,16 +378,13 @@ func (s *BaseScheduler) LogTaskStatusUpdate(status *mesos.TaskStatus) { default: level = log.InfoLevel } - elekLog.ElektronLog.Log(lmt, - level, - log.Fields{"task": fmt.Sprintf("%s", *status.TaskId.Value), "state": NameFor(status.State)}, "Task Status received") + elekLog.ElektronLog.Log(elekLogTypes.CONSOLE, + level, log.Fields{"task": fmt.Sprintf("%s", *status.TaskId.Value), "state": NameFor(status.State)}, "Task Status received") } func (s *BaseScheduler) LogSchedPolicySwitch(name string, nextPolicy SchedPolicyState) { logSPS := func() { - elekLog.ElektronLog.Log(elekLogTypes.SPS, - log.InfoLevel, - log.Fields{"Name": name}, "") + elekLog.ElektronLog.Log(elekLogTypes.SPS, log.InfoLevel, log.Fields{"Name": name}, "") } if s.hasReceivedResourceOffers && (s.curSchedPolicy != nextPolicy) { logSPS() diff --git a/schedulers/helpers.go b/schedulers/helpers.go index f69375d..3cb81b3 100644 --- a/schedulers/helpers.go +++ b/schedulers/helpers.go @@ -34,15 +34,11 @@ import ( func coLocated(tasks map[string]bool, s BaseScheduler) { - for task := range tasks { - elekLog.ElektronLog.Log(elekLogTypes.CONSOLE, - log.InfoLevel, - log.Fields{"Task": task}, "") + for _, task := range tasks { + elekLog.ElektronLog.Log(elekLogTypes.CONSOLE, log.InfoLevel, log.Fields{"Task": task}, "") } - elekLog.ElektronLog.Log(elekLogTypes.CONSOLE, - log.InfoLevel, - log.Fields{}, "---------------------") + elekLog.ElektronLog.Log(elekLogTypes.CONSOLE, log.InfoLevel, log.Fields{}, "---------------------") } // Get the powerClass of the given hostname. diff --git a/utilities/offerUtils/offerUtils.go b/utilities/offerUtils/offerUtils.go index db512d2..05f1465 100644 --- a/utilities/offerUtils/offerUtils.go +++ b/utilities/offerUtils/offerUtils.go @@ -19,13 +19,13 @@ package offerUtils import ( - "fmt" + "strings" + mesos "github.com/mesos/mesos-go/api/v0/mesosproto" log "github.com/sirupsen/logrus" "github.com/spdfg/elektron/constants" elekLog "github.com/spdfg/elektron/elektronLogging" elekLogTypes "github.com/spdfg/elektron/elektronLogging/types" - "strings" ) func OfferAgg(offer *mesos.Offer) (float64, float64, float64) { @@ -91,13 +91,13 @@ func UpdateEnvironment(offer *mesos.Offer) { // If this host is not present in the set of hosts. if _, ok := constants.Hosts[host]; !ok { elekLog.ElektronLog.Log(elekLogTypes.CONSOLE, log.InfoLevel, - log.Fields{"Adding host": fmt.Sprintf("%s", host)}, "New host detected") + log.Fields{"Adding host": host}, "New host detected") // Add this host. constants.Hosts[host] = struct{}{} // Get the power class of this host. class := PowerClass(offer) elekLog.ElektronLog.Log(elekLogTypes.CONSOLE, log.InfoLevel, - log.Fields{"host": fmt.Sprintf("%s", host), "PowerClass": fmt.Sprintf("%s", class)}, "Registering the power class...") + log.Fields{"host": host, "PowerClass": class}, "Registering the power class...") // If new power class, register the power class. if _, ok := constants.PowerClasses[class]; !ok { constants.PowerClasses[class] = make(map[string]struct{}) -- 2.47.2 From 2fa3bebaa692d59b6eb18d4d67892f744a988a2c Mon Sep 17 00:00:00 2001 From: balandi1 Date: Tue, 26 Nov 2019 13:54:02 -0500 Subject: [PATCH 21/48] Removed dummy head logger Replaced dummy head logger instance with ConsoleLogger instance in the chain. --- elektronLogging/logger.go | 8 ++++---- 1 file changed, 4 insertions(+), 4 deletions(-) diff --git a/elektronLogging/logger.go b/elektronLogging/logger.go index 9c30bed..191cde6 100644 --- a/elektronLogging/logger.go +++ b/elektronLogging/logger.go @@ -11,7 +11,7 @@ import ( var config LoggerConfig var logger *log.Logger var formatter ElektronFormatter -var ElektronLog *LoggerImpl +var ElektronLog *ConsoleLogger var logDir logDirectory func BuildLogger(prefix string, logConfigFilename string) { @@ -33,7 +33,7 @@ func BuildLogger(prefix string, logConfigFilename string) { } // create a chain of loggers - head := &LoggerImpl{} + //head := &LoggerImpl{} cLog := NewConsoleLogger(CONSOLE, prefix) pLog := NewPCPLogger(PCP, prefix) schedTraceLog := NewSchedTraceLogger(SCHED_TRACE, prefix) @@ -41,12 +41,12 @@ func BuildLogger(prefix string, logConfigFilename string) { schedWindowLog := NewSchedWindowLogger(SCHED_WINDOW, prefix) tskDistLog := NewClsfnTaskDistrOverheadLogger(CLSFN_TASKDIST_OVERHEAD, prefix) - head.SetNext(cLog) + //head.SetNext(cLog) cLog.SetNext(pLog) pLog.SetNext(schedTraceLog) schedTraceLog.SetNext(spsLog) spsLog.SetNext(schedWindowLog) schedWindowLog.SetNext(tskDistLog) - ElektronLog = head + ElektronLog = cLog } -- 2.47.2 From 0c0361e2095cc71943d43f5c18e9aaeebc5b72dd Mon Sep 17 00:00:00 2001 From: balandi1 Date: Tue, 26 Nov 2019 14:24:20 -0500 Subject: [PATCH 22/48] Code Refactoring Modified comments. Organized imports. --- def/taskUtils.go | 4 +- def/task_test.go | 5 +- elektronLogging/ElektronFormatter.go | 3 +- .../clsfnTaskDistOverheadLogger.go | 3 +- elektronLogging/consoleLogger.go | 3 +- elektronLogging/createLogDir.go | 6 +-- elektronLogging/logger.go | 20 ++++---- elektronLogging/pcpLogger.go | 3 +- elektronLogging/schedPolicySwitchLogger.go | 3 +- elektronLogging/schedTraceLogger.go | 3 +- elektronLogging/schedWindowLogger.go | 3 +- pcp/pcp.go | 8 ++-- powerCap/extrema.go | 26 +++++------ powerCap/progressiveExtrema.go | 44 +++++++++--------- rapl/cap.go | 2 +- scheduler.go | 14 +++--- schedulers/MaxGreedyMins.go | 3 +- schedulers/MaxMin.go | 3 +- schedulers/base.go | 46 +++++++++---------- schedulers/bin-packing.go | 3 +- schedulers/helpers.go | 5 +- schedulers/schedPolicy.go | 2 +- utilities/offerUtils/offerUtils.go | 4 +- utilities/schedUtils/schedUtils.go | 3 +- 24 files changed, 114 insertions(+), 105 deletions(-) diff --git a/def/taskUtils.go b/def/taskUtils.go index c358a27..0259de2 100644 --- a/def/taskUtils.go +++ b/def/taskUtils.go @@ -52,7 +52,7 @@ func (tc TasksToClassify) taskObservationCalculator(task Task) []float64 { } else if task.Watts != 0.0 { return []float64{task.Watts} } else { - elekLog.ElektronLog.Log(elekLogTypes.CONSOLE, log.FatalLevel, + elekLog.ElektronLogger.Log(elekLogTypes.CONSOLE, log.FatalLevel, log.Fields{}, "Unable to classify tasks. Missing Watts or ClassToWatts attribute in workload") return []float64{0.0} // Won't reach here. } @@ -108,7 +108,7 @@ func clusterSizeAvgMMMPU(tasks []Task, taskObservation func(task Task) []float64 } else { // skip this value // there is an error in the task config. - elekLog.ElektronLog.Log(elekLogTypes.CONSOLE, log.ErrorLevel, + elekLog.ElektronLogger.Log(elekLogTypes.CONSOLE, log.ErrorLevel, log.Fields{}, err.Error()) } } else { diff --git a/def/task_test.go b/def/task_test.go index 80ff2d2..28b77f4 100644 --- a/def/task_test.go +++ b/def/task_test.go @@ -20,11 +20,12 @@ package def import ( "fmt" + "reflect" + "testing" + mesos "github.com/mesos/mesos-go/api/v0/mesosproto" "github.com/spdfg/elektron/constants" "github.com/stretchr/testify/assert" - "reflect" - "testing" ) func TestTasksFromJSON(t *testing.T) { diff --git a/elektronLogging/ElektronFormatter.go b/elektronLogging/ElektronFormatter.go index 066cb95..97d609e 100644 --- a/elektronLogging/ElektronFormatter.go +++ b/elektronLogging/ElektronFormatter.go @@ -3,8 +3,9 @@ package elektronLogging import ( "bytes" "github.com/fatih/color" - log "github.com/sirupsen/logrus" "strings" + + log "github.com/sirupsen/logrus" ) type ElektronFormatter struct { diff --git a/elektronLogging/clsfnTaskDistOverheadLogger.go b/elektronLogging/clsfnTaskDistOverheadLogger.go index 2b70b62..db1dbee 100644 --- a/elektronLogging/clsfnTaskDistOverheadLogger.go +++ b/elektronLogging/clsfnTaskDistOverheadLogger.go @@ -1,10 +1,11 @@ package elektronLogging import ( - log "github.com/sirupsen/logrus" "os" "path/filepath" "strings" + + log "github.com/sirupsen/logrus" ) type ClsfnTaskDistrOverheadLogger struct { diff --git a/elektronLogging/consoleLogger.go b/elektronLogging/consoleLogger.go index fd2d079..52a62a6 100644 --- a/elektronLogging/consoleLogger.go +++ b/elektronLogging/consoleLogger.go @@ -1,10 +1,11 @@ package elektronLogging import ( - log "github.com/sirupsen/logrus" "os" "path/filepath" "strings" + + log "github.com/sirupsen/logrus" ) type ConsoleLogger struct { diff --git a/elektronLogging/createLogDir.go b/elektronLogging/createLogDir.go index 8d82024..c40abbc 100644 --- a/elektronLogging/createLogDir.go +++ b/elektronLogging/createLogDir.go @@ -1,11 +1,12 @@ package elektronLogging import ( - log "github.com/sirupsen/logrus" "os" "strconv" "strings" "time" + + log "github.com/sirupsen/logrus" ) type logDirectory struct { @@ -19,8 +20,7 @@ func (logD *logDirectory) getDirName() string { func (logD *logDirectory) createLogDir(prefix string, startTime time.Time) { if logD.name == "" { - // Creating directory to store all logs for this run - // directory name format - 2019-November-21_14-33-0 + // Creating directory to store all logs for this run. Directory name format - 2019-November-21_14-33-0. logDirName := strings.Join([]string{"./", prefix, strconv.Itoa(startTime.Year())}, "") logDirName = strings.Join([]string{logDirName, startTime.Month().String(), strconv.Itoa(startTime.Day())}, "-") logDirName = strings.Join([]string{logDirName, strconv.Itoa(startTime.Hour())}, "_") diff --git a/elektronLogging/logger.go b/elektronLogging/logger.go index 191cde6..7eae26e 100644 --- a/elektronLogging/logger.go +++ b/elektronLogging/logger.go @@ -1,30 +1,32 @@ package elektronLogging import ( - log "github.com/sirupsen/logrus" - . "github.com/spdfg/elektron/elektronLogging/types" "os" "strings" "time" + + log "github.com/sirupsen/logrus" + . "github.com/spdfg/elektron/elektronLogging/types" ) var config LoggerConfig var logger *log.Logger var formatter ElektronFormatter -var ElektronLog *ConsoleLogger +var ElektronLogger *ConsoleLogger var logDir logDirectory func BuildLogger(prefix string, logConfigFilename string) { - // read configuration from yaml + // Read configuration from yaml. config.GetConfig(logConfigFilename) - // create the log directory + // Create the log directory. startTime := time.Now() formatter.TimestampFormat = "2006-01-02 15:04:05" formattedStartTime := startTime.Format("20060102150405") - logDir.createLogDir(prefix, startTime) + + // Instantiate the logrus instance. prefix = strings.Join([]string{prefix, formattedStartTime}, "_") logger = &log.Logger{ Out: os.Stderr, @@ -32,8 +34,7 @@ func BuildLogger(prefix string, logConfigFilename string) { Formatter: &formatter, } - // create a chain of loggers - //head := &LoggerImpl{} + // Create a chain of loggers. cLog := NewConsoleLogger(CONSOLE, prefix) pLog := NewPCPLogger(PCP, prefix) schedTraceLog := NewSchedTraceLogger(SCHED_TRACE, prefix) @@ -41,12 +42,11 @@ func BuildLogger(prefix string, logConfigFilename string) { schedWindowLog := NewSchedWindowLogger(SCHED_WINDOW, prefix) tskDistLog := NewClsfnTaskDistrOverheadLogger(CLSFN_TASKDIST_OVERHEAD, prefix) - //head.SetNext(cLog) cLog.SetNext(pLog) pLog.SetNext(schedTraceLog) schedTraceLog.SetNext(spsLog) spsLog.SetNext(schedWindowLog) schedWindowLog.SetNext(tskDistLog) - ElektronLog = cLog + ElektronLogger = cLog } diff --git a/elektronLogging/pcpLogger.go b/elektronLogging/pcpLogger.go index db1e432..fd9c39c 100644 --- a/elektronLogging/pcpLogger.go +++ b/elektronLogging/pcpLogger.go @@ -1,10 +1,11 @@ package elektronLogging import ( - log "github.com/sirupsen/logrus" "os" "path/filepath" "strings" + + log "github.com/sirupsen/logrus" ) type PCPLogger struct { diff --git a/elektronLogging/schedPolicySwitchLogger.go b/elektronLogging/schedPolicySwitchLogger.go index bae2c3e..8e7b887 100644 --- a/elektronLogging/schedPolicySwitchLogger.go +++ b/elektronLogging/schedPolicySwitchLogger.go @@ -1,10 +1,11 @@ package elektronLogging import ( - log "github.com/sirupsen/logrus" "os" "path/filepath" "strings" + + log "github.com/sirupsen/logrus" ) type SchedPolicySwitchLogger struct { diff --git a/elektronLogging/schedTraceLogger.go b/elektronLogging/schedTraceLogger.go index 8a4c5ba..9b692b9 100644 --- a/elektronLogging/schedTraceLogger.go +++ b/elektronLogging/schedTraceLogger.go @@ -1,10 +1,11 @@ package elektronLogging import ( - log "github.com/sirupsen/logrus" "os" "path/filepath" "strings" + + log "github.com/sirupsen/logrus" ) type SchedTraceLogger struct { diff --git a/elektronLogging/schedWindowLogger.go b/elektronLogging/schedWindowLogger.go index 09fc633..b5e94da 100644 --- a/elektronLogging/schedWindowLogger.go +++ b/elektronLogging/schedWindowLogger.go @@ -1,10 +1,11 @@ package elektronLogging import ( - log "github.com/sirupsen/logrus" "os" "path/filepath" "strings" + + log "github.com/sirupsen/logrus" ) type SchedWindowLogger struct { diff --git a/pcp/pcp.go b/pcp/pcp.go index cbe8170..8781651 100644 --- a/pcp/pcp.go +++ b/pcp/pcp.go @@ -47,7 +47,7 @@ func Start(quit chan struct{}, logging *bool, pcpConfigFile string) { scanner.Scan() // Write to logfile - elekLog.ElektronLog.Log(elekLogTypes.PCP, + elekLog.ElektronLogger.Log(elekLogTypes.PCP, log.InfoLevel, log.Fields{}, scanner.Text()) @@ -60,7 +60,7 @@ func Start(quit chan struct{}, logging *bool, pcpConfigFile string) { text := scanner.Text() if *logging { - elekLog.ElektronLog.Log(elekLogTypes.PCP, + elekLog.ElektronLogger.Log(elekLogTypes.PCP, log.InfoLevel, log.Fields{}, text) } @@ -69,7 +69,7 @@ func Start(quit chan struct{}, logging *bool, pcpConfigFile string) { } }(logging) - elekLog.ElektronLog.Log(elekLogTypes.CONSOLE, + elekLog.ElektronLogger.Log(elekLogTypes.CONSOLE, log.InfoLevel, log.Fields{}, "PCP logging started") @@ -81,7 +81,7 @@ func Start(quit chan struct{}, logging *bool, pcpConfigFile string) { select { case <-quit: - elekLog.ElektronLog.Log(elekLogTypes.CONSOLE, + elekLog.ElektronLogger.Log(elekLogTypes.CONSOLE, log.InfoLevel, log.Fields{}, "Stopping PCP logging in 5 seconds") time.Sleep(5 * time.Second) diff --git a/powerCap/extrema.go b/powerCap/extrema.go index be8b158..67b00b9 100644 --- a/powerCap/extrema.go +++ b/powerCap/extrema.go @@ -43,7 +43,7 @@ func StartPCPLogAndExtremaDynamicCap(quit chan struct{}, logging *bool, hiThresh cmd.SysProcAttr = &syscall.SysProcAttr{Setpgid: true} if hiThreshold < loThreshold { - elekLog.ElektronLog.Log(elekLogTypes.CONSOLE, + elekLog.ElektronLogger.Log(elekLogTypes.CONSOLE, log.InfoLevel, log.Fields{}, "High threshold is lower than low threshold!") } @@ -61,7 +61,7 @@ func StartPCPLogAndExtremaDynamicCap(quit chan struct{}, logging *bool, hiThresh scanner.Scan() // Write to logfile - elekLog.ElektronLog.Log(elekLogTypes.PCP, + elekLog.ElektronLogger.Log(elekLogTypes.PCP, log.InfoLevel, log.Fields{}, scanner.Text()) @@ -99,14 +99,14 @@ func StartPCPLogAndExtremaDynamicCap(quit chan struct{}, logging *bool, hiThresh if *logging { - elekLog.ElektronLog.Log(elekLogTypes.CONSOLE, + elekLog.ElektronLogger.Log(elekLogTypes.CONSOLE, log.InfoLevel, log.Fields{}, "Logging PCP...") text := scanner.Text() split := strings.Split(text, ",") - elekLog.ElektronLog.Log(elekLogTypes.PCP, + elekLog.ElektronLogger.Log(elekLogTypes.PCP, log.InfoLevel, log.Fields{}, text) @@ -119,7 +119,7 @@ func StartPCPLogAndExtremaDynamicCap(quit chan struct{}, logging *bool, hiThresh powerHistories[host].Value = power powerHistories[host] = powerHistories[host].Next() - elekLog.ElektronLog.Log(elekLogTypes.CONSOLE, + elekLog.ElektronLogger.Log(elekLogTypes.CONSOLE, log.InfoLevel, log.Fields{"Host": fmt.Sprintf("%s", indexToHost[powerIndex]), "Power": fmt.Sprintf("%f", (power * pcp.RAPLUnits))}, "") @@ -133,14 +133,14 @@ func StartPCPLogAndExtremaDynamicCap(quit chan struct{}, logging *bool, hiThresh clusterMean := pcp.AverageClusterPowerHistory(clusterPowerHist) - elekLog.ElektronLog.Log(elekLogTypes.CONSOLE, + elekLog.ElektronLogger.Log(elekLogTypes.CONSOLE, log.InfoLevel, log.Fields{"Total power": fmt.Sprintf("%f %d", clusterPower, clusterPowerHist.Len()), "Sec Avg": fmt.Sprintf("%f", clusterMean)}, "") if clusterMean > hiThreshold { - elekLog.ElektronLog.Log(elekLogTypes.CONSOLE, + elekLog.ElektronLogger.Log(elekLogTypes.CONSOLE, log.InfoLevel, log.Fields{}, "Need to cap a node") // Create statics for all victims and choose one to cap @@ -163,12 +163,12 @@ func StartPCPLogAndExtremaDynamicCap(quit chan struct{}, logging *bool, hiThresh if !cappedHosts[victim.Host] { cappedHosts[victim.Host] = true orderCapped = append(orderCapped, victim.Host) - elekLog.ElektronLog.Log(elekLogTypes.CONSOLE, + elekLog.ElektronLogger.Log(elekLogTypes.CONSOLE, log.InfoLevel, log.Fields{"Capping Victim": fmt.Sprintf("%s", victim.Host), "Avg. Wattage": fmt.Sprintf("%f", victim.Watts*pcp.RAPLUnits)}, "") if err := rapl.Cap(victim.Host, "rapl", 50); err != nil { - elekLog.ElektronLog.Log(elekLogTypes.CONSOLE, + elekLog.ElektronLogger.Log(elekLogTypes.CONSOLE, log.ErrorLevel, log.Fields{}, "Error capping host") } @@ -184,11 +184,11 @@ func StartPCPLogAndExtremaDynamicCap(quit chan struct{}, logging *bool, hiThresh cappedHosts[host] = false // User RAPL package to send uncap. log.Printf("Uncapping host %s", host) - elekLog.ElektronLog.Log(elekLogTypes.CONSOLE, + elekLog.ElektronLogger.Log(elekLogTypes.CONSOLE, log.InfoLevel, log.Fields{"Uncapped host": host}, "") if err := rapl.Cap(host, "rapl", 100); err != nil { - elekLog.ElektronLog.Log(elekLogTypes.CONSOLE, + elekLog.ElektronLogger.Log(elekLogTypes.CONSOLE, log.ErrorLevel, log.Fields{}, "Error capping host") } @@ -200,7 +200,7 @@ func StartPCPLogAndExtremaDynamicCap(quit chan struct{}, logging *bool, hiThresh } }(logging, hiThreshold, loThreshold) - elekLog.ElektronLog.Log(elekLogTypes.CONSOLE, + elekLog.ElektronLogger.Log(elekLogTypes.CONSOLE, log.InfoLevel, log.Fields{}, "PCP logging started") @@ -212,7 +212,7 @@ func StartPCPLogAndExtremaDynamicCap(quit chan struct{}, logging *bool, hiThresh select { case <-quit: - elekLog.ElektronLog.Log(elekLogTypes.CONSOLE, + elekLog.ElektronLogger.Log(elekLogTypes.CONSOLE, log.InfoLevel, log.Fields{}, "Stopping PCP logging in 5 seconds") time.Sleep(5 * time.Second) diff --git a/powerCap/progressiveExtrema.go b/powerCap/progressiveExtrema.go index 6cd234f..1362f7a 100644 --- a/powerCap/progressiveExtrema.go +++ b/powerCap/progressiveExtrema.go @@ -56,7 +56,7 @@ func StartPCPLogAndProgressiveExtremaCap(quit chan struct{}, logging *bool, hiTh cmd.SysProcAttr = &syscall.SysProcAttr{Setpgid: true} if hiThreshold < loThreshold { - elekLog.ElektronLog.Log(elekLogTypes.CONSOLE, + elekLog.ElektronLogger.Log(elekLogTypes.CONSOLE, log.InfoLevel, log.Fields{}, "High threshold is lower than low threshold!") } @@ -74,7 +74,7 @@ func StartPCPLogAndProgressiveExtremaCap(quit chan struct{}, logging *bool, hiTh scanner.Scan() // Write to logfile - elekLog.ElektronLog.Log(elekLogTypes.PCP, + elekLog.ElektronLogger.Log(elekLogTypes.PCP, log.InfoLevel, log.Fields{}, scanner.Text()) @@ -115,13 +115,13 @@ func StartPCPLogAndProgressiveExtremaCap(quit chan struct{}, logging *bool, hiTh for scanner.Scan() { if *logging { - elekLog.ElektronLog.Log(elekLogTypes.CONSOLE, + elekLog.ElektronLogger.Log(elekLogTypes.CONSOLE, log.InfoLevel, log.Fields{}, "Logging PCP...") split := strings.Split(scanner.Text(), ",") text := scanner.Text() - elekLog.ElektronLog.Log(elekLogTypes.PCP, + elekLog.ElektronLogger.Log(elekLogTypes.PCP, log.InfoLevel, log.Fields{}, text) @@ -134,7 +134,7 @@ func StartPCPLogAndProgressiveExtremaCap(quit chan struct{}, logging *bool, hiTh powerHistories[host].Value = power powerHistories[host] = powerHistories[host].Next() - elekLog.ElektronLog.Log(elekLogTypes.CONSOLE, + elekLog.ElektronLogger.Log(elekLogTypes.CONSOLE, log.InfoLevel, log.Fields{"Host": fmt.Sprintf("%s", indexToHost[powerIndex]), "Power": fmt.Sprintf("%f", (power * pcp.RAPLUnits))}, "") @@ -147,22 +147,22 @@ func StartPCPLogAndProgressiveExtremaCap(quit chan struct{}, logging *bool, hiTh clusterMean := pcp.AverageClusterPowerHistory(clusterPowerHist) - elekLog.ElektronLog.Log(elekLogTypes.CONSOLE, + elekLog.ElektronLogger.Log(elekLogTypes.CONSOLE, log.InfoLevel, log.Fields{"Total power": fmt.Sprintf("%f %d", clusterPower, clusterPowerHist.Len()), "Sec Avg": fmt.Sprintf("%f", clusterMean)}, "") if clusterMean >= hiThreshold { - elekLog.ElektronLog.Log(elekLogTypes.CONSOLE, + elekLog.ElektronLogger.Log(elekLogTypes.CONSOLE, log.InfoLevel, log.Fields{}, "Need to cap a node") - elekLog.ElektronLog.Log(elekLogTypes.CONSOLE, + elekLog.ElektronLogger.Log(elekLogTypes.CONSOLE, log.InfoLevel, log.Fields{"Cap values of capped victims": fmt.Sprintf("%v", cappedVictims)}, "") - elekLog.ElektronLog.Log(elekLogTypes.CONSOLE, + elekLog.ElektronLogger.Log(elekLogTypes.CONSOLE, log.InfoLevel, log.Fields{"Cap values of victims to uncap": fmt.Sprintf("%v", orderCappedVictims)}, "") // Create statics for all victims and choose one to cap @@ -192,12 +192,12 @@ func StartPCPLogAndProgressiveExtremaCap(quit chan struct{}, logging *bool, hiTh // Need to cap this victim. if err := rapl.Cap(victims[i].Host, "rapl", 50.0); err != nil { - elekLog.ElektronLog.Log(elekLogTypes.CONSOLE, + elekLog.ElektronLogger.Log(elekLogTypes.CONSOLE, log.ErrorLevel, log.Fields{"Error capping host": fmt.Sprintf("%s", victims[i].Host)}, "") } else { - elekLog.ElektronLog.Log(elekLogTypes.CONSOLE, + elekLog.ElektronLogger.Log(elekLogTypes.CONSOLE, log.InfoLevel, log.Fields{}, fmt.Sprintf("Capped host[%s] at %f", victims[i].Host, 50.0)) // Keeping track of this victim and it's cap value @@ -223,12 +223,12 @@ func StartPCPLogAndProgressiveExtremaCap(quit chan struct{}, logging *bool, hiTh newCapValue := getNextCapValue(capValue, 2) if err := rapl.Cap(alreadyCappedHosts[i], "rapl", newCapValue); err != nil { - elekLog.ElektronLog.Log(elekLogTypes.CONSOLE, + elekLog.ElektronLogger.Log(elekLogTypes.CONSOLE, log.ErrorLevel, log.Fields{"Error capping host": fmt.Sprintf("%s", alreadyCappedHosts[i])}, "") } else { // Successful cap - elekLog.ElektronLog.Log(elekLogTypes.CONSOLE, + elekLog.ElektronLogger.Log(elekLogTypes.CONSOLE, log.InfoLevel, log.Fields{}, fmt.Sprintf("Capped host[%s] at %f", alreadyCappedHosts[i], newCapValue)) // Checking whether this victim can be capped further @@ -253,7 +253,7 @@ func StartPCPLogAndProgressiveExtremaCap(quit chan struct{}, logging *bool, hiTh } } if !canCapAlreadyCappedVictim { - elekLog.ElektronLog.Log(elekLogTypes.CONSOLE, + elekLog.ElektronLogger.Log(elekLogTypes.CONSOLE, log.InfoLevel, log.Fields{}, "No Victim left to cap") } @@ -261,13 +261,13 @@ func StartPCPLogAndProgressiveExtremaCap(quit chan struct{}, logging *bool, hiTh } else if clusterMean < loThreshold { - elekLog.ElektronLog.Log(elekLogTypes.CONSOLE, + elekLog.ElektronLogger.Log(elekLogTypes.CONSOLE, log.InfoLevel, log.Fields{}, "Need to uncap a node") - elekLog.ElektronLog.Log(elekLogTypes.CONSOLE, + elekLog.ElektronLogger.Log(elekLogTypes.CONSOLE, log.InfoLevel, log.Fields{"Cap values of capped victims": fmt.Sprintf("%v", cappedVictims)}, "") - elekLog.ElektronLog.Log(elekLogTypes.CONSOLE, + elekLog.ElektronLogger.Log(elekLogTypes.CONSOLE, log.InfoLevel, log.Fields{"Cap values of victims to uncap": fmt.Sprintf("%v", orderCappedVictims)}, "") if len(orderCapped) > 0 { @@ -280,12 +280,12 @@ func StartPCPLogAndProgressiveExtremaCap(quit chan struct{}, logging *bool, hiTh newUncapValue := orderCappedVictims[hostToUncap] * 2.0 if err := rapl.Cap(hostToUncap, "rapl", newUncapValue); err != nil { - elekLog.ElektronLog.Log(elekLogTypes.CONSOLE, + elekLog.ElektronLogger.Log(elekLogTypes.CONSOLE, log.ErrorLevel, log.Fields{"Error uncapping host": fmt.Sprintf("%s", hostToUncap)}, "") } else { // Successful uncap - elekLog.ElektronLog.Log(elekLogTypes.CONSOLE, + elekLog.ElektronLogger.Log(elekLogTypes.CONSOLE, log.InfoLevel, log.Fields{}, fmt.Sprintf("Uncapped host[%s] to %f", hostToUncap, newUncapValue)) // Can we uncap this host further. If not, then we remove its entry from orderCapped @@ -308,7 +308,7 @@ func StartPCPLogAndProgressiveExtremaCap(quit chan struct{}, logging *bool, hiTh } } } else { - elekLog.ElektronLog.Log(elekLogTypes.CONSOLE, + elekLog.ElektronLogger.Log(elekLogTypes.CONSOLE, log.InfoLevel, log.Fields{}, "No host staged for Uncapped") } @@ -319,7 +319,7 @@ func StartPCPLogAndProgressiveExtremaCap(quit chan struct{}, logging *bool, hiTh }(logging, hiThreshold, loThreshold) - elekLog.ElektronLog.Log(elekLogTypes.CONSOLE, + elekLog.ElektronLogger.Log(elekLogTypes.CONSOLE, log.InfoLevel, log.Fields{}, "PCP logging started") if err := cmd.Start(); err != nil { @@ -330,7 +330,7 @@ func StartPCPLogAndProgressiveExtremaCap(quit chan struct{}, logging *bool, hiTh select { case <-quit: - elekLog.ElektronLog.Log(elekLogTypes.CONSOLE, + elekLog.ElektronLogger.Log(elekLogTypes.CONSOLE, log.InfoLevel, log.Fields{}, "Stopping PCP logging in 5 seconds") time.Sleep(5 * time.Second) diff --git a/rapl/cap.go b/rapl/cap.go index 42f94f6..2b36e9d 100644 --- a/rapl/cap.go +++ b/rapl/cap.go @@ -21,11 +21,11 @@ package rapl import ( "os" "strconv" + "strings" "github.com/pkg/errors" elekEnv "github.com/spdfg/elektron/environment" "golang.org/x/crypto/ssh" - "strings" ) func Cap(host, username string, percentage float64) error { diff --git a/scheduler.go b/scheduler.go index 299dfca..d171870 100644 --- a/scheduler.go +++ b/scheduler.go @@ -21,6 +21,11 @@ package main // import github.com/spdfg/elektron import ( "flag" "fmt" + "os" + "os/signal" + "strings" + "time" + "github.com/golang/protobuf/proto" mesos "github.com/mesos/mesos-go/api/v0/mesosproto" sched "github.com/mesos/mesos-go/api/v0/scheduler" @@ -31,10 +36,6 @@ import ( "github.com/spdfg/elektron/pcp" "github.com/spdfg/elektron/powerCap" "github.com/spdfg/elektron/schedulers" - "os" - "os/signal" - "strings" - "time" ) var master = flag.String("master", "", "Location of leading Mesos master -- :") @@ -225,6 +226,7 @@ func main() { if strings.Contains(*pcplogPrefix, "/") { log.Fatal("log file prefix should not contain '/'.") } + // Build Logger for elektron. elekLog.BuildLogger(*pcplogPrefix, *logConfigFilename) // Starting PCP logging. @@ -280,11 +282,11 @@ func main() { // Starting the scheduler driver. if status, err := driver.Run(); err != nil { - elekLog.ElektronLog.Log(elekLogTypes.CONSOLE, + elekLog.ElektronLogger.Log(elekLogTypes.CONSOLE, log.ErrorLevel, log.Fields{"status": status.String(), "error": err.Error()}, "Framework stopped ") } - elekLog.ElektronLog.Log(elekLogTypes.CONSOLE, + elekLog.ElektronLogger.Log(elekLogTypes.CONSOLE, log.InfoLevel, log.Fields{}, "Exiting...") } diff --git a/schedulers/MaxGreedyMins.go b/schedulers/MaxGreedyMins.go index b4b250d..12adfcb 100644 --- a/schedulers/MaxGreedyMins.go +++ b/schedulers/MaxGreedyMins.go @@ -19,10 +19,9 @@ package schedulers import ( - log "github.com/sirupsen/logrus" - mesos "github.com/mesos/mesos-go/api/v0/mesosproto" sched "github.com/mesos/mesos-go/api/v0/scheduler" + log "github.com/sirupsen/logrus" "github.com/spdfg/elektron/def" "github.com/spdfg/elektron/utilities/mesosUtils" "github.com/spdfg/elektron/utilities/offerUtils" diff --git a/schedulers/MaxMin.go b/schedulers/MaxMin.go index a7ba29e..7901698 100644 --- a/schedulers/MaxMin.go +++ b/schedulers/MaxMin.go @@ -19,10 +19,9 @@ package schedulers import ( - log "github.com/sirupsen/logrus" - mesos "github.com/mesos/mesos-go/api/v0/mesosproto" sched "github.com/mesos/mesos-go/api/v0/scheduler" + log "github.com/sirupsen/logrus" "github.com/spdfg/elektron/def" "github.com/spdfg/elektron/utilities/mesosUtils" "github.com/spdfg/elektron/utilities/offerUtils" diff --git a/schedulers/base.go b/schedulers/base.go index 31c0d34..5844281 100644 --- a/schedulers/base.go +++ b/schedulers/base.go @@ -250,10 +250,10 @@ func (s *BaseScheduler) StatusUpdate(driver sched.SchedulerDriver, status *mesos func (s *BaseScheduler) LogTaskStarting(ts *def.Task, offer *mesos.Offer) { if ts == nil { - elekLog.ElektronLog.Log(elekLogTypes.CONSOLE, log.InfoLevel, + elekLog.ElektronLogger.Log(elekLogTypes.CONSOLE, log.InfoLevel, log.Fields{"host": fmt.Sprintf("%s", offer.GetHostname())}, "TASKS STARTING...") } else { - elekLog.ElektronLog.Log(elekLogTypes.CONSOLE, + elekLog.ElektronLogger.Log(elekLogTypes.CONSOLE, log.InfoLevel, log.Fields{"task": fmt.Sprintf("%s", ts.Name), "Instance": fmt.Sprintf("%d", *ts.Instances), "host": fmt.Sprintf("%s", offer.GetHostname())}, @@ -262,25 +262,25 @@ func (s *BaseScheduler) LogTaskStarting(ts *def.Task, offer *mesos.Offer) { } func (s *BaseScheduler) LogTaskWattsConsideration(ts def.Task, host string, wattsToConsider float64) { - elekLog.ElektronLog.Log(elekLogTypes.CONSOLE, + elekLog.ElektronLogger.Log(elekLogTypes.CONSOLE, log.InfoLevel, log.Fields{"task": ts.Name, "host": host, "Watts": fmt.Sprintf("%f", wattsToConsider)}, "Watts considered for ") } func (s *BaseScheduler) LogOffersReceived(offers []*mesos.Offer) { - elekLog.ElektronLog.Log(elekLogTypes.CONSOLE, + elekLog.ElektronLogger.Log(elekLogTypes.CONSOLE, log.InfoLevel, log.Fields{"Resource offers received": fmt.Sprintf("%d", len(offers))}, "") } func (s *BaseScheduler) LogNoPendingTasksDeclineOffers(offer *mesos.Offer) { - elekLog.ElektronLog.Log(elekLogTypes.CONSOLE, + elekLog.ElektronLogger.Log(elekLogTypes.CONSOLE, log.WarnLevel, log.Fields{"DECLINING OFFER for host": fmt.Sprintf("%s", offer.GetHostname())}, "No tasks left to schedule ") } func (s *BaseScheduler) LogNumberOfRunningTasks() { - elekLog.ElektronLog.Log(elekLogTypes.CONSOLE, + elekLog.ElektronLogger.Log(elekLogTypes.CONSOLE, log.InfoLevel, log.Fields{"Number of tasks still Running": fmt.Sprintf("%d", s.tasksRunning)}, "") } @@ -292,81 +292,81 @@ func (s *BaseScheduler) LogCoLocatedTasks(slaveID string) { buffer.WriteString(fmt.Sprintln(taskName)) } s.TasksRunningMutex.Unlock() - elekLog.ElektronLog.Log(elekLogTypes.CONSOLE, + elekLog.ElektronLogger.Log(elekLogTypes.CONSOLE, log.InfoLevel, log.Fields{"Colocated with": fmt.Sprintf("%s", buffer.String())}, "") } func (s *BaseScheduler) LogSchedTrace(taskToSchedule *mesos.TaskInfo, offer *mesos.Offer) { - elekLog.ElektronLog.Log(elekLogTypes.SCHED_TRACE, + elekLog.ElektronLogger.Log(elekLogTypes.SCHED_TRACE, log.InfoLevel, log.Fields{offer.GetHostname(): fmt.Sprintf("%s", taskToSchedule.GetTaskId().GetValue())}, "") } func (s *BaseScheduler) LogTerminateScheduler() { - elekLog.ElektronLog.Log(elekLogTypes.CONSOLE, log.InfoLevel, log.Fields{}, "Done scheduling all tasks!") + elekLog.ElektronLogger.Log(elekLogTypes.CONSOLE, log.InfoLevel, log.Fields{}, "Done scheduling all tasks!") } func (s *BaseScheduler) LogInsufficientResourcesDeclineOffer(offer *mesos.Offer, offerResources ...interface{}) { buffer := bytes.Buffer{} buffer.WriteString(fmt.Sprintf("", offerResources...)) - elekLog.ElektronLog.Log(elekLogTypes.CONSOLE, + elekLog.ElektronLogger.Log(elekLogTypes.CONSOLE, log.WarnLevel, log.Fields{"Offer Resources": fmt.Sprintf("%s", buffer.String())}, "DECLINING OFFER... Offer has insufficient resources to launch a task") } func (s *BaseScheduler) LogOfferRescinded(offerID *mesos.OfferID) { - elekLog.ElektronLog.Log(elekLogTypes.CONSOLE, + elekLog.ElektronLogger.Log(elekLogTypes.CONSOLE, log.ErrorLevel, log.Fields{"OfferID": fmt.Sprintf("%s", offerID)}, "OFFER RESCINDED") } func (s *BaseScheduler) LogSlaveLost(slaveID *mesos.SlaveID) { - elekLog.ElektronLog.Log(elekLogTypes.CONSOLE, + elekLog.ElektronLogger.Log(elekLogTypes.CONSOLE, log.ErrorLevel, log.Fields{"SlaveID": fmt.Sprintf("%s", slaveID)}, "SLAVE LOST") } func (s *BaseScheduler) LogExecutorLost(executorID *mesos.ExecutorID, slaveID *mesos.SlaveID) { - elekLog.ElektronLog.Log(elekLogTypes.CONSOLE, + elekLog.ElektronLogger.Log(elekLogTypes.CONSOLE, log.ErrorLevel, log.Fields{"ExecutorID": fmt.Sprintf("%s", executorID), "SlaveID": fmt.Sprintf("%s", slaveID)}, "EXECUTOR LOST") } func (s *BaseScheduler) LogFrameworkMessage(executorID *mesos.ExecutorID, slaveID *mesos.SlaveID, message string) { - elekLog.ElektronLog.Log(elekLogTypes.CONSOLE, + elekLog.ElektronLogger.Log(elekLogTypes.CONSOLE, log.InfoLevel, log.Fields{"Received Framework message from executor": executorID}, message) } func (s *BaseScheduler) LogMesosError(err string) { - elekLog.ElektronLog.Log(elekLogTypes.CONSOLE, + elekLog.ElektronLogger.Log(elekLogTypes.CONSOLE, log.ErrorLevel, log.Fields{"MESOS CONSOLE": fmt.Sprintf("%v", err)}, "") } func (s *BaseScheduler) LogElectronError(err error) { - elekLog.ElektronLog.Log(elekLogTypes.CONSOLE, + elekLog.ElektronLogger.Log(elekLogTypes.CONSOLE, log.ErrorLevel, log.Fields{"ELECTRON CONSOLE": fmt.Sprintf("%v", err)}, "") } func (s *BaseScheduler) LogFrameworkRegistered(frameworkID *mesos.FrameworkID, masterInfo *mesos.MasterInfo) { - elekLog.ElektronLog.Log(elekLogTypes.CONSOLE, + elekLog.ElektronLogger.Log(elekLogTypes.CONSOLE, log.InfoLevel, log.Fields{"frameworkID": fmt.Sprintf("%s", frameworkID), "master": fmt.Sprintf("%v", masterInfo)}, "FRAMEWORK REGISTERED!") } func (s *BaseScheduler) LogFrameworkReregistered(masterInfo *mesos.MasterInfo) { - elekLog.ElektronLog.Log(elekLogTypes.CONSOLE, + elekLog.ElektronLogger.Log(elekLogTypes.CONSOLE, log.InfoLevel, log.Fields{"master": fmt.Sprintf("%v", masterInfo)}, "Framework re-registered") } func (s *BaseScheduler) LogDisconnected() { - elekLog.ElektronLog.Log(elekLogTypes.CONSOLE, log.WarnLevel, log.Fields{}, "Framework disconnected with master") + elekLog.ElektronLogger.Log(elekLogTypes.CONSOLE, log.WarnLevel, log.Fields{}, "Framework disconnected with master") } func (s *BaseScheduler) LogTaskStatusUpdate(status *mesos.TaskStatus) { @@ -378,13 +378,13 @@ func (s *BaseScheduler) LogTaskStatusUpdate(status *mesos.TaskStatus) { default: level = log.InfoLevel } - elekLog.ElektronLog.Log(elekLogTypes.CONSOLE, + elekLog.ElektronLogger.Log(elekLogTypes.CONSOLE, level, log.Fields{"task": fmt.Sprintf("%s", *status.TaskId.Value), "state": NameFor(status.State)}, "Task Status received") } func (s *BaseScheduler) LogSchedPolicySwitch(name string, nextPolicy SchedPolicyState) { logSPS := func() { - elekLog.ElektronLog.Log(elekLogTypes.SPS, log.InfoLevel, log.Fields{"Name": name}, "") + elekLog.ElektronLogger.Log(elekLogTypes.SPS, log.InfoLevel, log.Fields{"Name": name}, "") } if s.hasReceivedResourceOffers && (s.curSchedPolicy != nextPolicy) { logSPS() @@ -393,14 +393,14 @@ func (s *BaseScheduler) LogSchedPolicySwitch(name string, nextPolicy SchedPolicy } // Logging the size of the scheduling window and the scheduling policy // that is going to schedule the tasks in the scheduling window. - elekLog.ElektronLog.Log(elekLogTypes.SCHED_WINDOW, + elekLog.ElektronLogger.Log(elekLogTypes.SCHED_WINDOW, log.InfoLevel, log.Fields{"Window size": fmt.Sprintf("%d", s.schedWindowSize), "Name": name}, "") } func (s *BaseScheduler) LogClsfnAndTaskDistOverhead(overhead time.Duration) { // Logging the overhead in microseconds. - elekLog.ElektronLog.Log(elekLogTypes.CLSFN_TASKDIST_OVERHEAD, + elekLog.ElektronLogger.Log(elekLogTypes.CLSFN_TASKDIST_OVERHEAD, log.InfoLevel, log.Fields{"Overhead in microseconds": fmt.Sprintf("%f", float64(overhead.Nanoseconds())/1000.0)}, "") } diff --git a/schedulers/bin-packing.go b/schedulers/bin-packing.go index 8bd90fb..edd40e3 100644 --- a/schedulers/bin-packing.go +++ b/schedulers/bin-packing.go @@ -19,10 +19,9 @@ package schedulers import ( - log "github.com/sirupsen/logrus" - mesos "github.com/mesos/mesos-go/api/v0/mesosproto" sched "github.com/mesos/mesos-go/api/v0/scheduler" + log "github.com/sirupsen/logrus" "github.com/spdfg/elektron/def" "github.com/spdfg/elektron/utilities/mesosUtils" "github.com/spdfg/elektron/utilities/offerUtils" diff --git a/schedulers/helpers.go b/schedulers/helpers.go index 3cb81b3..2bf0cd3 100644 --- a/schedulers/helpers.go +++ b/schedulers/helpers.go @@ -20,6 +20,7 @@ package schedulers import ( "fmt" + mesos "github.com/mesos/mesos-go/api/v0/mesosproto" sched "github.com/mesos/mesos-go/api/v0/scheduler" "github.com/pkg/errors" @@ -35,10 +36,10 @@ import ( func coLocated(tasks map[string]bool, s BaseScheduler) { for _, task := range tasks { - elekLog.ElektronLog.Log(elekLogTypes.CONSOLE, log.InfoLevel, log.Fields{"Task": task}, "") + elekLog.ElektronLogger.Log(elekLogTypes.CONSOLE, log.InfoLevel, log.Fields{"Task": task}, "") } - elekLog.ElektronLog.Log(elekLogTypes.CONSOLE, log.InfoLevel, log.Fields{}, "---------------------") + elekLog.ElektronLogger.Log(elekLogTypes.CONSOLE, log.InfoLevel, log.Fields{}, "---------------------") } // Get the powerClass of the given hostname. diff --git a/schedulers/schedPolicy.go b/schedulers/schedPolicy.go index eb98176..dd0c58f 100644 --- a/schedulers/schedPolicy.go +++ b/schedulers/schedPolicy.go @@ -90,7 +90,7 @@ func switchTaskDistBased(baseSchedRef *BaseScheduler) string { // Determine the distribution of tasks in the new scheduling window. taskDist, err := def.GetTaskDistributionInWindow(baseSchedRef.schedWindowSize, baseSchedRef.tasks) baseSchedRef.LogClsfnAndTaskDistOverhead(time.Now().Sub(startTime)) - elekLog.ElektronLog.Log(elekLogTypes.CONSOLE, + elekLog.ElektronLogger.Log(elekLogTypes.CONSOLE, log.InfoLevel, log.Fields{"Task Distribution": fmt.Sprintf("%f", taskDist)}, "Switching... ") if err != nil { diff --git a/utilities/offerUtils/offerUtils.go b/utilities/offerUtils/offerUtils.go index 05f1465..7aaf30d 100644 --- a/utilities/offerUtils/offerUtils.go +++ b/utilities/offerUtils/offerUtils.go @@ -90,13 +90,13 @@ func UpdateEnvironment(offer *mesos.Offer) { var host = offer.GetHostname() // If this host is not present in the set of hosts. if _, ok := constants.Hosts[host]; !ok { - elekLog.ElektronLog.Log(elekLogTypes.CONSOLE, log.InfoLevel, + elekLog.ElektronLogger.Log(elekLogTypes.CONSOLE, log.InfoLevel, log.Fields{"Adding host": host}, "New host detected") // Add this host. constants.Hosts[host] = struct{}{} // Get the power class of this host. class := PowerClass(offer) - elekLog.ElektronLog.Log(elekLogTypes.CONSOLE, log.InfoLevel, + elekLog.ElektronLogger.Log(elekLogTypes.CONSOLE, log.InfoLevel, log.Fields{"host": host, "PowerClass": class}, "Registering the power class...") // If new power class, register the power class. if _, ok := constants.PowerClasses[class]; !ok { diff --git a/utilities/schedUtils/schedUtils.go b/utilities/schedUtils/schedUtils.go index 98631ca..6f50334 100644 --- a/utilities/schedUtils/schedUtils.go +++ b/utilities/schedUtils/schedUtils.go @@ -20,6 +20,7 @@ package schedUtils import ( "fmt" + log "github.com/sirupsen/logrus" "github.com/spdfg/elektron/def" elekLog "github.com/spdfg/elektron/elektronLogging" @@ -79,7 +80,7 @@ func (s *fillNextOfferCycle) apply(taskQueue []def.Task) (int, int) { for _, task := range taskQueue { numberOfTasksTraversed++ for i := *task.Instances; i > 0; i-- { - elekLog.ElektronLog.Log(elekLogTypes.CONSOLE, log.InfoLevel, + elekLog.ElektronLogger.Log(elekLogTypes.CONSOLE, log.InfoLevel, log.Fields{}, fmt.Sprintf("Checking if Instance #%d of Task[%s] can be scheduled "+ "during the next offer cycle...", i, task.Name)) if canSchedule(task) { -- 2.47.2 From d0e989136ef223fb501ee159955380fe45f301e7 Mon Sep 17 00:00:00 2001 From: balandi1 Date: Tue, 26 Nov 2019 18:02:24 -0500 Subject: [PATCH 23/48] Handled ennabling/disabling log types Added enabled check while creating log files and logging. Do not allow to create log file or log if the log type is disabled. --- .../clsfnTaskDistOverheadLogger.go | 40 ++++++++++-------- elektronLogging/consoleLogger.go | 38 +++++++++-------- elektronLogging/pcpLogger.go | 41 ++++++++++--------- elektronLogging/schedPolicySwitchLogger.go | 41 ++++++++++--------- elektronLogging/schedTraceLogger.go | 41 ++++++++++--------- elektronLogging/schedWindowLogger.go | 41 ++++++++++--------- 6 files changed, 131 insertions(+), 111 deletions(-) diff --git a/elektronLogging/clsfnTaskDistOverheadLogger.go b/elektronLogging/clsfnTaskDistOverheadLogger.go index db1dbee..e23f43d 100644 --- a/elektronLogging/clsfnTaskDistOverheadLogger.go +++ b/elektronLogging/clsfnTaskDistOverheadLogger.go @@ -20,33 +20,37 @@ func NewClsfnTaskDistrOverheadLogger(logType int, prefix string) *ClsfnTaskDistr } func (cLog ClsfnTaskDistrOverheadLogger) Log(logType int, level log.Level, logData log.Fields, message string) { - if cLog.Type == logType { + if config.TaskDistrConfig.Enabled { + if cLog.Type == logType { - logger.SetLevel(level) + logger.SetLevel(level) - if cLog.AllowOnConsole { - logger.SetOutput(os.Stdout) + if cLog.AllowOnConsole { + logger.SetOutput(os.Stdout) + logger.WithFields(logData).Println(message) + } + + logger.SetOutput(cLog.LogFile) logger.WithFields(logData).Println(message) } - - logger.SetOutput(cLog.LogFile) - logger.WithFields(logData).Println(message) - } - if cLog.next != nil { - cLog.next.Log(logType, level, logData, message) + if cLog.next != nil { + cLog.next.Log(logType, level, logData, message) + } } } func (cLog *ClsfnTaskDistrOverheadLogger) CreateLogFile(prefix string) { - filename := strings.Join([]string{prefix, config.TaskDistrConfig.FilenameExtension}, "") - dirName := logDir.getDirName() - if dirName != "" { - if logFile, err := os.Create(filepath.Join(dirName, filename)); err != nil { - log.Fatal("Unable to create logFile: ", err) - } else { - cLog.LogFile = logFile - cLog.AllowOnConsole = config.TaskDistrConfig.AllowOnConsole + if config.TaskDistrConfig.Enabled { + filename := strings.Join([]string{prefix, config.TaskDistrConfig.FilenameExtension}, "") + dirName := logDir.getDirName() + if dirName != "" { + if logFile, err := os.Create(filepath.Join(dirName, filename)); err != nil { + log.Fatal("Unable to create logFile: ", err) + } else { + cLog.LogFile = logFile + cLog.AllowOnConsole = config.TaskDistrConfig.AllowOnConsole + } } } } diff --git a/elektronLogging/consoleLogger.go b/elektronLogging/consoleLogger.go index 52a62a6..d48cd22 100644 --- a/elektronLogging/consoleLogger.go +++ b/elektronLogging/consoleLogger.go @@ -19,31 +19,35 @@ func NewConsoleLogger(logType int, prefix string) *ConsoleLogger { return cLog } func (cLog ConsoleLogger) Log(logType int, level log.Level, logData log.Fields, message string) { - if logType <= cLog.Type { + if config.ConsoleConfig.Enabled { + if logType <= cLog.Type { - logger.SetLevel(level) + logger.SetLevel(level) - logger.SetOutput(os.Stdout) - logger.WithFields(logData).Println(message) + logger.SetOutput(os.Stdout) + logger.WithFields(logData).Println(message) - logger.SetOutput(cLog.LogFile) - logger.WithFields(logData).Println(message) - } - if cLog.next != nil { - cLog.next.Log(logType, level, logData, message) + logger.SetOutput(cLog.LogFile) + logger.WithFields(logData).Println(message) + } + if cLog.next != nil { + cLog.next.Log(logType, level, logData, message) + } } } func (cLog *ConsoleLogger) CreateLogFile(prefix string) { - filename := strings.Join([]string{prefix, config.ConsoleConfig.FilenameExtension}, "") - dirName := logDir.getDirName() - if dirName != "" { - if logFile, err := os.Create(filepath.Join(dirName, filename)); err != nil { - log.Fatal("Unable to create logFile: ", err) - } else { - cLog.LogFile = logFile - cLog.AllowOnConsole = config.ConsoleConfig.AllowOnConsole + if config.ConsoleConfig.Enabled { + filename := strings.Join([]string{prefix, config.ConsoleConfig.FilenameExtension}, "") + dirName := logDir.getDirName() + if dirName != "" { + if logFile, err := os.Create(filepath.Join(dirName, filename)); err != nil { + log.Fatal("Unable to create logFile: ", err) + } else { + cLog.LogFile = logFile + cLog.AllowOnConsole = config.ConsoleConfig.AllowOnConsole + } } } } diff --git a/elektronLogging/pcpLogger.go b/elektronLogging/pcpLogger.go index fd9c39c..ff68838 100644 --- a/elektronLogging/pcpLogger.go +++ b/elektronLogging/pcpLogger.go @@ -20,33 +20,36 @@ func NewPCPLogger(logType int, prefix string) *PCPLogger { } func (pLog PCPLogger) Log(logType int, level log.Level, logData log.Fields, message string) { - if pLog.Type == logType { + if config.PCPConfig.Enabled { + if pLog.Type == logType { - logger.SetLevel(level) + logger.SetLevel(level) - if pLog.AllowOnConsole { - logger.SetOutput(os.Stdout) + if pLog.AllowOnConsole { + logger.SetOutput(os.Stdout) + logger.WithFields(logData).Println(message) + } + + logger.SetOutput(pLog.LogFile) logger.WithFields(logData).Println(message) } - - logger.SetOutput(pLog.LogFile) - logger.WithFields(logData).Println(message) - } - if pLog.next != nil { - pLog.next.Log(logType, level, logData, message) + if pLog.next != nil { + pLog.next.Log(logType, level, logData, message) + } } } func (pLog *PCPLogger) CreateLogFile(prefix string) { - - filename := strings.Join([]string{prefix, config.PCPConfig.FilenameExtension}, "") - dirName := logDir.getDirName() - if dirName != "" { - if logFile, err := os.Create(filepath.Join(dirName, filename)); err != nil { - log.Fatal("Unable to create logFile: ", err) - } else { - pLog.LogFile = logFile - pLog.AllowOnConsole = config.PCPConfig.AllowOnConsole + if config.PCPConfig.Enabled { + filename := strings.Join([]string{prefix, config.PCPConfig.FilenameExtension}, "") + dirName := logDir.getDirName() + if dirName != "" { + if logFile, err := os.Create(filepath.Join(dirName, filename)); err != nil { + log.Fatal("Unable to create logFile: ", err) + } else { + pLog.LogFile = logFile + pLog.AllowOnConsole = config.PCPConfig.AllowOnConsole + } } } } diff --git a/elektronLogging/schedPolicySwitchLogger.go b/elektronLogging/schedPolicySwitchLogger.go index 8e7b887..74a1e31 100644 --- a/elektronLogging/schedPolicySwitchLogger.go +++ b/elektronLogging/schedPolicySwitchLogger.go @@ -20,33 +20,36 @@ func NewSchedPolicySwitchLogger(logType int, prefix string) *SchedPolicySwitchLo } func (sLog SchedPolicySwitchLogger) Log(logType int, level log.Level, logData log.Fields, message string) { - if sLog.Type == logType { + if config.SPSConfig.Enabled { + if sLog.Type == logType { - logger.SetLevel(level) + logger.SetLevel(level) - if sLog.AllowOnConsole { - logger.SetOutput(os.Stdout) + if sLog.AllowOnConsole { + logger.SetOutput(os.Stdout) + logger.WithFields(logData).Println(message) + } + + logger.SetOutput(sLog.LogFile) logger.WithFields(logData).Println(message) } - - logger.SetOutput(sLog.LogFile) - logger.WithFields(logData).Println(message) - } - if sLog.next != nil { - sLog.next.Log(logType, level, logData, message) + if sLog.next != nil { + sLog.next.Log(logType, level, logData, message) + } } } func (sLog *SchedPolicySwitchLogger) CreateLogFile(prefix string) { - - filename := strings.Join([]string{prefix, config.SPSConfig.FilenameExtension}, "") - dirName := logDir.getDirName() - if dirName != "" { - if logFile, err := os.Create(filepath.Join(dirName, filename)); err != nil { - log.Fatal("Unable to create logFile: ", err) - } else { - sLog.LogFile = logFile - sLog.AllowOnConsole = config.SPSConfig.AllowOnConsole + if config.SPSConfig.Enabled { + filename := strings.Join([]string{prefix, config.SPSConfig.FilenameExtension}, "") + dirName := logDir.getDirName() + if dirName != "" { + if logFile, err := os.Create(filepath.Join(dirName, filename)); err != nil { + log.Fatal("Unable to create logFile: ", err) + } else { + sLog.LogFile = logFile + sLog.AllowOnConsole = config.SPSConfig.AllowOnConsole + } } } } diff --git a/elektronLogging/schedTraceLogger.go b/elektronLogging/schedTraceLogger.go index 9b692b9..208bf2a 100644 --- a/elektronLogging/schedTraceLogger.go +++ b/elektronLogging/schedTraceLogger.go @@ -20,33 +20,36 @@ func NewSchedTraceLogger(logType int, prefix string) *SchedTraceLogger { } func (sLog SchedTraceLogger) Log(logType int, level log.Level, logData log.Fields, message string) { - if sLog.Type == logType { + if config.SchedTraceConfig.Enabled { + if sLog.Type == logType { - logger.SetLevel(level) + logger.SetLevel(level) - if sLog.AllowOnConsole { - logger.SetOutput(os.Stdout) + if sLog.AllowOnConsole { + logger.SetOutput(os.Stdout) + logger.WithFields(logData).Println(message) + } + + logger.SetOutput(sLog.LogFile) logger.WithFields(logData).Println(message) } - - logger.SetOutput(sLog.LogFile) - logger.WithFields(logData).Println(message) - } - if sLog.next != nil { - sLog.next.Log(logType, level, logData, message) + if sLog.next != nil { + sLog.next.Log(logType, level, logData, message) + } } } func (sLog *SchedTraceLogger) CreateLogFile(prefix string) { - - filename := strings.Join([]string{prefix, config.SchedTraceConfig.FilenameExtension}, "") - dirName := logDir.getDirName() - if dirName != "" { - if logFile, err := os.Create(filepath.Join(dirName, filename)); err != nil { - log.Fatal("Unable to create logFile: ", err) - } else { - sLog.LogFile = logFile - sLog.AllowOnConsole = config.SchedTraceConfig.AllowOnConsole + if config.SchedTraceConfig.Enabled { + filename := strings.Join([]string{prefix, config.SchedTraceConfig.FilenameExtension}, "") + dirName := logDir.getDirName() + if dirName != "" { + if logFile, err := os.Create(filepath.Join(dirName, filename)); err != nil { + log.Fatal("Unable to create logFile: ", err) + } else { + sLog.LogFile = logFile + sLog.AllowOnConsole = config.SchedTraceConfig.AllowOnConsole + } } } } diff --git a/elektronLogging/schedWindowLogger.go b/elektronLogging/schedWindowLogger.go index b5e94da..44184d0 100644 --- a/elektronLogging/schedWindowLogger.go +++ b/elektronLogging/schedWindowLogger.go @@ -20,33 +20,36 @@ func NewSchedWindowLogger(logType int, prefix string) *SchedWindowLogger { } func (sLog SchedWindowLogger) Log(logType int, level log.Level, logData log.Fields, message string) { - if sLog.Type == logType { + if config.SchedWindowConfig.Enabled { + if sLog.Type == logType { - logger.SetLevel(level) + logger.SetLevel(level) - if sLog.AllowOnConsole { - logger.SetOutput(os.Stdout) + if sLog.AllowOnConsole { + logger.SetOutput(os.Stdout) + logger.WithFields(logData).Println(message) + } + + logger.SetOutput(sLog.LogFile) logger.WithFields(logData).Println(message) } - - logger.SetOutput(sLog.LogFile) - logger.WithFields(logData).Println(message) - } - if sLog.next != nil { - sLog.next.Log(logType, level, logData, message) + if sLog.next != nil { + sLog.next.Log(logType, level, logData, message) + } } } func (sLog *SchedWindowLogger) CreateLogFile(prefix string) { - - filename := strings.Join([]string{prefix, config.SchedWindowConfig.FilenameExtension}, "") - dirName := logDir.getDirName() - if dirName != "" { - if logFile, err := os.Create(filepath.Join(dirName, filename)); err != nil { - log.Fatal("Unable to create logFile: ", err) - } else { - sLog.LogFile = logFile - sLog.AllowOnConsole = config.SchedWindowConfig.AllowOnConsole + if config.SchedWindowConfig.Enabled { + filename := strings.Join([]string{prefix, config.SchedWindowConfig.FilenameExtension}, "") + dirName := logDir.getDirName() + if dirName != "" { + if logFile, err := os.Create(filepath.Join(dirName, filename)); err != nil { + log.Fatal("Unable to create logFile: ", err) + } else { + sLog.LogFile = logFile + sLog.AllowOnConsole = config.SchedWindowConfig.AllowOnConsole + } } } } -- 2.47.2 From b9592ed31c16fec8acdd246f4a0e0561634cd64e Mon Sep 17 00:00:00 2001 From: balandi1 Date: Tue, 26 Nov 2019 18:12:55 -0500 Subject: [PATCH 24/48] Removed Log Color Codes Since the color codes were displayed in an inappropriate manner, removed them from all logs . --- elektronLogging/ElektronFormatter.go | 19 ++----------------- 1 file changed, 2 insertions(+), 17 deletions(-) diff --git a/elektronLogging/ElektronFormatter.go b/elektronLogging/ElektronFormatter.go index 97d609e..a0b1ff0 100644 --- a/elektronLogging/ElektronFormatter.go +++ b/elektronLogging/ElektronFormatter.go @@ -2,7 +2,7 @@ package elektronLogging import ( "bytes" - "github.com/fatih/color" + "fmt" "strings" log "github.com/sirupsen/logrus" @@ -12,20 +12,6 @@ type ElektronFormatter struct { TimestampFormat string } -func (f ElektronFormatter) getColor(entry *log.Entry) *color.Color { - switch entry.Level { - case log.InfoLevel: - return color.New(color.FgGreen, color.Bold) - case log.WarnLevel: - return color.New(color.FgYellow, color.Bold) - case log.ErrorLevel: - return color.New(color.FgRed, color.Bold) - case log.FatalLevel: - return color.New(color.FgRed, color.Bold) - default: - return color.New(color.FgWhite, color.Bold) - } -} func (f ElektronFormatter) Format(entry *log.Entry) ([]byte, error) { var b *bytes.Buffer @@ -35,8 +21,7 @@ func (f ElektronFormatter) Format(entry *log.Entry) ([]byte, error) { b = &bytes.Buffer{} } - levelColor := f.getColor(entry) - level := levelColor.Sprintf("[%s]:", strings.ToUpper(entry.Level.String())) + level := fmt.Sprintf("[%s]:", strings.ToUpper(entry.Level.String())) message := strings.Join([]string{level, entry.Time.Format(f.TimestampFormat), entry.Message, " "}, " ") var formattedFields []string -- 2.47.2 From bedfa52d7aa1ccc044c01adb2b4ae885f997f99e Mon Sep 17 00:00:00 2001 From: balandi1 Date: Wed, 4 Dec 2019 13:16:48 -0500 Subject: [PATCH 25/48] Added functions to logging library Added Logf() and WithFields() functions. Logf() for logging formatted messages. WithFields() for handling optional log fields. --- def/taskUtils.go | 6 +- .../clsfnTaskDistOverheadLogger.go | 38 ++++++-- elektronLogging/consoleLogger.go | 36 +++++-- elektronLogging/logger.go | 19 ++-- elektronLogging/loggerChain.go | 32 +++++- elektronLogging/pcpLogger.go | 38 ++++++-- elektronLogging/schedPolicySwitchLogger.go | 38 ++++++-- elektronLogging/schedTraceLogger.go | 38 ++++++-- elektronLogging/schedWindowLogger.go | 38 ++++++-- pcp/pcp.go | 16 +-- powerCap/extrema.go | 56 +++-------- powerCap/progressiveExtrema.go | 94 +++++------------- scheduler.go | 9 +- schedulers/base.go | 97 +++++++------------ schedulers/helpers.go | 4 +- schedulers/schedPolicy.go | 5 +- utilities/offerUtils/offerUtils.go | 7 +- utilities/schedUtils/schedUtils.go | 8 +- 18 files changed, 319 insertions(+), 260 deletions(-) diff --git a/def/taskUtils.go b/def/taskUtils.go index 0259de2..0d203eb 100644 --- a/def/taskUtils.go +++ b/def/taskUtils.go @@ -52,8 +52,7 @@ func (tc TasksToClassify) taskObservationCalculator(task Task) []float64 { } else if task.Watts != 0.0 { return []float64{task.Watts} } else { - elekLog.ElektronLogger.Log(elekLogTypes.CONSOLE, log.FatalLevel, - log.Fields{}, "Unable to classify tasks. Missing Watts or ClassToWatts attribute in workload") + elekLog.ElektronLogger.Log(elekLogTypes.CONSOLE, log.FatalLevel, "Unable to classify tasks. Missing Watts or ClassToWatts attribute in workload") return []float64{0.0} // Won't reach here. } } @@ -108,8 +107,7 @@ func clusterSizeAvgMMMPU(tasks []Task, taskObservation func(task Task) []float64 } else { // skip this value // there is an error in the task config. - elekLog.ElektronLogger.Log(elekLogTypes.CONSOLE, log.ErrorLevel, - log.Fields{}, err.Error()) + elekLog.ElektronLogger.Log(elekLogTypes.CONSOLE, log.ErrorLevel, err.Error()) } } else { // There is only one observation for the task. diff --git a/elektronLogging/clsfnTaskDistOverheadLogger.go b/elektronLogging/clsfnTaskDistOverheadLogger.go index e23f43d..6d0823f 100644 --- a/elektronLogging/clsfnTaskDistOverheadLogger.go +++ b/elektronLogging/clsfnTaskDistOverheadLogger.go @@ -12,29 +12,53 @@ type ClsfnTaskDistrOverheadLogger struct { LoggerImpl } -func NewClsfnTaskDistrOverheadLogger(logType int, prefix string) *ClsfnTaskDistrOverheadLogger { +func NewClsfnTaskDistrOverheadLogger(b *baseLogData, logType int, prefix string) *ClsfnTaskDistrOverheadLogger { cLog := &ClsfnTaskDistrOverheadLogger{} cLog.Type = logType cLog.CreateLogFile(prefix) + cLog.next = nil + cLog.baseLogData = b return cLog } -func (cLog ClsfnTaskDistrOverheadLogger) Log(logType int, level log.Level, logData log.Fields, message string) { +func (cLog ClsfnTaskDistrOverheadLogger) Log(logType int, level log.Level, message string) { if config.TaskDistrConfig.Enabled { if cLog.Type == logType { - logger.SetLevel(level) - if cLog.AllowOnConsole { logger.SetOutput(os.Stdout) - logger.WithFields(logData).Println(message) + logger.WithFields(cLog.data).Log(level, message) } logger.SetOutput(cLog.LogFile) - logger.WithFields(logData).Println(message) + logger.WithFields(cLog.data).Log(level, message) } if cLog.next != nil { - cLog.next.Log(logType, level, logData, message) + cLog.next.Log(logType, level, message) + } else { + // Clearing the fields. + cLog.resetFields() + } + } +} + +func (cLog ClsfnTaskDistrOverheadLogger) Logf(logType int, level log.Level, msgFmtString string, args ...interface{}) { + if config.TaskDistrConfig.Enabled { + if cLog.Type == logType { + + if cLog.AllowOnConsole { + logger.SetOutput(os.Stdout) + logger.WithFields(cLog.data).Logf(level, msgFmtString, args...) + } + + logger.SetOutput(cLog.LogFile) + logger.WithFields(cLog.data).Logf(level, msgFmtString, args...) + } + if cLog.next != nil { + cLog.next.Logf(logType, level, msgFmtString, args...) + } else { + // Clearing the fields. + cLog.resetFields() } } } diff --git a/elektronLogging/consoleLogger.go b/elektronLogging/consoleLogger.go index d48cd22..b1b9eda 100644 --- a/elektronLogging/consoleLogger.go +++ b/elektronLogging/consoleLogger.go @@ -12,26 +12,48 @@ type ConsoleLogger struct { LoggerImpl } -func NewConsoleLogger(logType int, prefix string) *ConsoleLogger { +func NewConsoleLogger(b *baseLogData, logType int, prefix string) *ConsoleLogger { cLog := &ConsoleLogger{} cLog.Type = logType cLog.CreateLogFile(prefix) + cLog.next = nil + cLog.baseLogData = b return cLog } -func (cLog ConsoleLogger) Log(logType int, level log.Level, logData log.Fields, message string) { +func (cLog ConsoleLogger) Log(logType int, level log.Level, message string) { if config.ConsoleConfig.Enabled { if logType <= cLog.Type { - logger.SetLevel(level) - logger.SetOutput(os.Stdout) - logger.WithFields(logData).Println(message) + logger.WithFields(cLog.data).Log(level, message) logger.SetOutput(cLog.LogFile) - logger.WithFields(logData).Println(message) + logger.WithFields(cLog.data).Log(level, message) } if cLog.next != nil { - cLog.next.Log(logType, level, logData, message) + cLog.next.Log(logType, level, message) + } else { + // Clearing the fields. + cLog.resetFields() + } + } +} + +func (cLog ConsoleLogger) Logf(logType int, level log.Level, msgFmtString string, args ...interface{}) { + if config.ConsoleConfig.Enabled { + if logType <= cLog.Type { + + logger.SetOutput(os.Stdout) + logger.WithFields(cLog.data).Logf(level, msgFmtString, args...) + + logger.SetOutput(cLog.LogFile) + logger.WithFields(cLog.data).Logf(level, msgFmtString, args...) + } + if cLog.next != nil { + cLog.next.Logf(logType, level, msgFmtString, args...) + } else { + // Clearing the fields. + cLog.resetFields() } } } diff --git a/elektronLogging/logger.go b/elektronLogging/logger.go index 7eae26e..44f70ee 100644 --- a/elektronLogging/logger.go +++ b/elektronLogging/logger.go @@ -12,7 +12,7 @@ import ( var config LoggerConfig var logger *log.Logger var formatter ElektronFormatter -var ElektronLogger *ConsoleLogger +var ElektronLogger *LoggerImpl var logDir logDirectory func BuildLogger(prefix string, logConfigFilename string) { @@ -35,18 +35,21 @@ func BuildLogger(prefix string, logConfigFilename string) { } // Create a chain of loggers. - cLog := NewConsoleLogger(CONSOLE, prefix) - pLog := NewPCPLogger(PCP, prefix) - schedTraceLog := NewSchedTraceLogger(SCHED_TRACE, prefix) - spsLog := NewSchedPolicySwitchLogger(SPS, prefix) - schedWindowLog := NewSchedWindowLogger(SCHED_WINDOW, prefix) - tskDistLog := NewClsfnTaskDistrOverheadLogger(CLSFN_TASKDIST_OVERHEAD, prefix) + b := &baseLogData{data: log.Fields{}} + head := &LoggerImpl{baseLogData: b} + cLog := NewConsoleLogger(b, CONSOLE, prefix) + pLog := NewPCPLogger(b, PCP, prefix) + schedTraceLog := NewSchedTraceLogger(b, SCHED_TRACE, prefix) + spsLog := NewSchedPolicySwitchLogger(b, SPS, prefix) + schedWindowLog := NewSchedWindowLogger(b, SCHED_WINDOW, prefix) + tskDistLog := NewClsfnTaskDistrOverheadLogger(b, CLSFN_TASKDIST_OVERHEAD, prefix) + head.SetNext(cLog) cLog.SetNext(pLog) pLog.SetNext(schedTraceLog) schedTraceLog.SetNext(spsLog) spsLog.SetNext(schedWindowLog) schedWindowLog.SetNext(tskDistLog) - ElektronLogger = cLog + ElektronLogger = head } diff --git a/elektronLogging/loggerChain.go b/elektronLogging/loggerChain.go index 3cd2ff3..bbf41fc 100644 --- a/elektronLogging/loggerChain.go +++ b/elektronLogging/loggerChain.go @@ -7,22 +7,48 @@ import ( type Logger interface { SetNext(logType Logger) - Log(logType int, level log.Level, logData log.Fields, message string) + Log(logType int, level log.Level, message string) + Logf(logType int, level log.Level, msgFmtString string, args ...interface{}) CreateLogFile(prefix string) } +type baseLogData struct { + data log.Fields +} type LoggerImpl struct { + *baseLogData Type int AllowOnConsole bool LogFile *os.File next Logger } +func (l *LoggerImpl) WithFields(logData log.Fields) *LoggerImpl { + l.data = logData + return l +} + +func (l *LoggerImpl) WithField(key string, value string) *LoggerImpl { + l.data[key] = value + return l +} + func (l *LoggerImpl) SetNext(logType Logger) { l.next = logType } -func (l *LoggerImpl) Log(logType int, level log.Level, logData log.Fields, message string) { +func (l LoggerImpl) Log(logType int, level log.Level, message string) { if l.next != nil { - l.next.Log(logType, level, logData, message) + l.next.Log(logType, level, message) } } + +func (l LoggerImpl) Logf(logType int, level log.Level, msgFmtString string, args ...interface{}) { + if l.next != nil { + l.next.Logf(logType, level, msgFmtString, args...) + } +} + +func (l *LoggerImpl) resetFields() { + l.data = nil + l.data = log.Fields{} +} diff --git a/elektronLogging/pcpLogger.go b/elektronLogging/pcpLogger.go index ff68838..022e885 100644 --- a/elektronLogging/pcpLogger.go +++ b/elektronLogging/pcpLogger.go @@ -12,29 +12,53 @@ type PCPLogger struct { LoggerImpl } -func NewPCPLogger(logType int, prefix string) *PCPLogger { +func NewPCPLogger(b *baseLogData, logType int, prefix string) *PCPLogger { pLog := &PCPLogger{} pLog.Type = logType pLog.CreateLogFile(prefix) + pLog.next = nil + pLog.baseLogData = b return pLog } -func (pLog PCPLogger) Log(logType int, level log.Level, logData log.Fields, message string) { +func (pLog PCPLogger) Log(logType int, level log.Level, message string) { if config.PCPConfig.Enabled { if pLog.Type == logType { - logger.SetLevel(level) - if pLog.AllowOnConsole { logger.SetOutput(os.Stdout) - logger.WithFields(logData).Println(message) + logger.WithFields(pLog.data).Log(level, message) } logger.SetOutput(pLog.LogFile) - logger.WithFields(logData).Println(message) + logger.WithFields(pLog.data).Log(level, message) } if pLog.next != nil { - pLog.next.Log(logType, level, logData, message) + pLog.next.Log(logType, level, message) + } else { + // Clearing the fields. + pLog.resetFields() + } + } +} + +func (pLog PCPLogger) Logf(logType int, level log.Level, msgFmtString string, args ...interface{}) { + if config.PCPConfig.Enabled { + if pLog.Type == logType { + + if pLog.AllowOnConsole { + logger.SetOutput(os.Stdout) + logger.WithFields(pLog.data).Logf(level, msgFmtString, args...) + } + + logger.SetOutput(pLog.LogFile) + logger.WithFields(pLog.data).Logf(level, msgFmtString, args...) + } + if pLog.next != nil { + pLog.next.Logf(logType, level, msgFmtString, args...) + } else { + // Clearing the fields. + pLog.resetFields() } } } diff --git a/elektronLogging/schedPolicySwitchLogger.go b/elektronLogging/schedPolicySwitchLogger.go index 74a1e31..b13cc5b 100644 --- a/elektronLogging/schedPolicySwitchLogger.go +++ b/elektronLogging/schedPolicySwitchLogger.go @@ -12,29 +12,53 @@ type SchedPolicySwitchLogger struct { LoggerImpl } -func NewSchedPolicySwitchLogger(logType int, prefix string) *SchedPolicySwitchLogger { +func NewSchedPolicySwitchLogger(b *baseLogData, logType int, prefix string) *SchedPolicySwitchLogger { sLog := &SchedPolicySwitchLogger{} sLog.Type = logType sLog.CreateLogFile(prefix) + sLog.next = nil + sLog.baseLogData = b return sLog } -func (sLog SchedPolicySwitchLogger) Log(logType int, level log.Level, logData log.Fields, message string) { +func (sLog SchedPolicySwitchLogger) Log(logType int, level log.Level, message string) { if config.SPSConfig.Enabled { if sLog.Type == logType { - logger.SetLevel(level) - if sLog.AllowOnConsole { logger.SetOutput(os.Stdout) - logger.WithFields(logData).Println(message) + logger.WithFields(sLog.data).Log(level, message) } logger.SetOutput(sLog.LogFile) - logger.WithFields(logData).Println(message) + logger.WithFields(sLog.data).Log(level, message) } if sLog.next != nil { - sLog.next.Log(logType, level, logData, message) + sLog.next.Log(logType, level, message) + } else { + // Clearing the fields. + sLog.resetFields() + } + } +} + +func (sLog SchedPolicySwitchLogger) Logf(logType int, level log.Level, msgFmtString string, args ...interface{}) { + if config.SPSConfig.Enabled { + if sLog.Type == logType { + + if sLog.AllowOnConsole { + logger.SetOutput(os.Stdout) + logger.WithFields(sLog.data).Logf(level, msgFmtString, args...) + } + + logger.SetOutput(sLog.LogFile) + logger.WithFields(sLog.data).Logf(level, msgFmtString, args...) + } + if sLog.next != nil { + sLog.next.Logf(logType, level, msgFmtString, args...) + } else { + // Clearing the fields. + sLog.resetFields() } } } diff --git a/elektronLogging/schedTraceLogger.go b/elektronLogging/schedTraceLogger.go index 208bf2a..2a429dd 100644 --- a/elektronLogging/schedTraceLogger.go +++ b/elektronLogging/schedTraceLogger.go @@ -12,29 +12,53 @@ type SchedTraceLogger struct { LoggerImpl } -func NewSchedTraceLogger(logType int, prefix string) *SchedTraceLogger { +func NewSchedTraceLogger(b *baseLogData, logType int, prefix string) *SchedTraceLogger { sLog := &SchedTraceLogger{} sLog.Type = logType sLog.CreateLogFile(prefix) + sLog.next = nil + sLog.baseLogData = b return sLog } -func (sLog SchedTraceLogger) Log(logType int, level log.Level, logData log.Fields, message string) { +func (sLog SchedTraceLogger) Log(logType int, level log.Level, message string) { if config.SchedTraceConfig.Enabled { if sLog.Type == logType { - logger.SetLevel(level) - if sLog.AllowOnConsole { logger.SetOutput(os.Stdout) - logger.WithFields(logData).Println(message) + logger.WithFields(sLog.data).Log(level, message) } logger.SetOutput(sLog.LogFile) - logger.WithFields(logData).Println(message) + logger.WithFields(sLog.data).Log(level, message) } if sLog.next != nil { - sLog.next.Log(logType, level, logData, message) + sLog.next.Log(logType, level, message) + } else { + // Clearing the fields. + sLog.resetFields() + } + } +} + +func (sLog SchedTraceLogger) Logf(logType int, level log.Level, msgFmtString string, args ...interface{}) { + if config.SchedTraceConfig.Enabled { + if sLog.Type == logType { + + if sLog.AllowOnConsole { + logger.SetOutput(os.Stdout) + logger.WithFields(sLog.data).Logf(level, msgFmtString, args...) + } + + logger.SetOutput(sLog.LogFile) + logger.WithFields(sLog.data).Logf(level, msgFmtString, args...) + } + if sLog.next != nil { + sLog.next.Logf(logType, level, msgFmtString, args...) + } else { + // Clearing the fields. + sLog.resetFields() } } } diff --git a/elektronLogging/schedWindowLogger.go b/elektronLogging/schedWindowLogger.go index 44184d0..d7c1895 100644 --- a/elektronLogging/schedWindowLogger.go +++ b/elektronLogging/schedWindowLogger.go @@ -12,29 +12,53 @@ type SchedWindowLogger struct { LoggerImpl } -func NewSchedWindowLogger(logType int, prefix string) *SchedWindowLogger { +func NewSchedWindowLogger(b *baseLogData, logType int, prefix string) *SchedWindowLogger { sLog := &SchedWindowLogger{} sLog.Type = logType sLog.CreateLogFile(prefix) + sLog.next = nil + sLog.baseLogData = b return sLog } -func (sLog SchedWindowLogger) Log(logType int, level log.Level, logData log.Fields, message string) { +func (sLog SchedWindowLogger) Log(logType int, level log.Level, message string) { if config.SchedWindowConfig.Enabled { if sLog.Type == logType { - logger.SetLevel(level) - if sLog.AllowOnConsole { logger.SetOutput(os.Stdout) - logger.WithFields(logData).Println(message) + logger.WithFields(sLog.data).Log(level, message) } logger.SetOutput(sLog.LogFile) - logger.WithFields(logData).Println(message) + logger.WithFields(sLog.data).Log(level, message) } if sLog.next != nil { - sLog.next.Log(logType, level, logData, message) + sLog.next.Log(logType, level, message) + } else { + // Clearing the fields. + sLog.resetFields() + } + } +} + +func (sLog SchedWindowLogger) Logf(logType int, level log.Level, msgFmtString string, args ...interface{}) { + if config.SchedWindowConfig.Enabled { + if sLog.Type == logType { + + if sLog.AllowOnConsole { + logger.SetOutput(os.Stdout) + logger.WithFields(sLog.data).Logf(level, msgFmtString, args...) + } + + logger.SetOutput(sLog.LogFile) + logger.WithFields(sLog.data).Logf(level, msgFmtString, args...) + } + if sLog.next != nil { + sLog.next.Logf(logType, level, msgFmtString, args...) + } else { + // Clearing the fields. + sLog.resetFields() } } } diff --git a/pcp/pcp.go b/pcp/pcp.go index 8781651..90d0b52 100644 --- a/pcp/pcp.go +++ b/pcp/pcp.go @@ -47,9 +47,7 @@ func Start(quit chan struct{}, logging *bool, pcpConfigFile string) { scanner.Scan() // Write to logfile - elekLog.ElektronLogger.Log(elekLogTypes.PCP, - log.InfoLevel, - log.Fields{}, scanner.Text()) + elekLog.ElektronLogger.Log(elekLogTypes.PCP, log.InfoLevel, scanner.Text()) // Throw away first set of results scanner.Scan() @@ -60,18 +58,14 @@ func Start(quit chan struct{}, logging *bool, pcpConfigFile string) { text := scanner.Text() if *logging { - elekLog.ElektronLogger.Log(elekLogTypes.PCP, - log.InfoLevel, - log.Fields{}, text) + elekLog.ElektronLogger.Log(elekLogTypes.PCP, log.InfoLevel, text) } seconds++ } }(logging) - elekLog.ElektronLogger.Log(elekLogTypes.CONSOLE, - log.InfoLevel, - log.Fields{}, "PCP logging started") + elekLog.ElektronLogger.Log(elekLogTypes.CONSOLE, log.InfoLevel, "PCP logging started") if err := cmd.Start(); err != nil { log.Fatal(err) @@ -81,9 +75,7 @@ func Start(quit chan struct{}, logging *bool, pcpConfigFile string) { select { case <-quit: - elekLog.ElektronLogger.Log(elekLogTypes.CONSOLE, - log.InfoLevel, - log.Fields{}, "Stopping PCP logging in 5 seconds") + elekLog.ElektronLogger.Log(elekLogTypes.CONSOLE, log.InfoLevel, "Stopping PCP logging in 5 seconds") time.Sleep(5 * time.Second) // http://stackoverflow.com/questions/22470193/why-wont-go-kill-a-child-process-correctly diff --git a/powerCap/extrema.go b/powerCap/extrema.go index 67b00b9..dbd38aa 100644 --- a/powerCap/extrema.go +++ b/powerCap/extrema.go @@ -43,9 +43,7 @@ func StartPCPLogAndExtremaDynamicCap(quit chan struct{}, logging *bool, hiThresh cmd.SysProcAttr = &syscall.SysProcAttr{Setpgid: true} if hiThreshold < loThreshold { - elekLog.ElektronLogger.Log(elekLogTypes.CONSOLE, - log.InfoLevel, - log.Fields{}, "High threshold is lower than low threshold!") + elekLog.ElektronLogger.Log(elekLogTypes.CONSOLE, log.InfoLevel, "High threshold is lower than low threshold!") } pipe, err := cmd.StdoutPipe() @@ -61,9 +59,7 @@ func StartPCPLogAndExtremaDynamicCap(quit chan struct{}, logging *bool, hiThresh scanner.Scan() // Write to logfile - elekLog.ElektronLogger.Log(elekLogTypes.PCP, - log.InfoLevel, - log.Fields{}, scanner.Text()) + elekLog.ElektronLogger.Log(elekLogTypes.PCP, log.InfoLevel, scanner.Text()) headers := strings.Split(scanner.Text(), ",") @@ -99,16 +95,12 @@ func StartPCPLogAndExtremaDynamicCap(quit chan struct{}, logging *bool, hiThresh if *logging { - elekLog.ElektronLogger.Log(elekLogTypes.CONSOLE, - log.InfoLevel, - log.Fields{}, "Logging PCP...") + elekLog.ElektronLogger.Log(elekLogTypes.CONSOLE, log.InfoLevel, "Logging PCP...") text := scanner.Text() split := strings.Split(text, ",") - elekLog.ElektronLogger.Log(elekLogTypes.PCP, - log.InfoLevel, - log.Fields{}, text) + elekLog.ElektronLogger.Log(elekLogTypes.PCP, log.InfoLevel, text) totalPower := 0.0 for _, powerIndex := range powerIndexes { @@ -119,10 +111,8 @@ func StartPCPLogAndExtremaDynamicCap(quit chan struct{}, logging *bool, hiThresh powerHistories[host].Value = power powerHistories[host] = powerHistories[host].Next() - elekLog.ElektronLogger.Log(elekLogTypes.CONSOLE, - log.InfoLevel, - log.Fields{"Host": fmt.Sprintf("%s", indexToHost[powerIndex]), "Power": fmt.Sprintf("%f", (power * pcp.RAPLUnits))}, - "") + elekLog.ElektronLogger.WithFields(log.Fields{"Host": fmt.Sprintf("%s", indexToHost[powerIndex]), + "Power": fmt.Sprintf("%f", (power * pcp.RAPLUnits))}).Log(elekLogTypes.CONSOLE, log.InfoLevel, "") totalPower += power } @@ -133,16 +123,12 @@ func StartPCPLogAndExtremaDynamicCap(quit chan struct{}, logging *bool, hiThresh clusterMean := pcp.AverageClusterPowerHistory(clusterPowerHist) - elekLog.ElektronLogger.Log(elekLogTypes.CONSOLE, - log.InfoLevel, - log.Fields{"Total power": fmt.Sprintf("%f %d", clusterPower, clusterPowerHist.Len()), - "Sec Avg": fmt.Sprintf("%f", clusterMean)}, - "") + elekLog.ElektronLogger.WithFields(log.Fields{"Total power": fmt.Sprintf("%f %d", clusterPower, clusterPowerHist.Len()), + "Sec Avg": fmt.Sprintf("%f", clusterMean)}).Log(elekLogTypes.CONSOLE, log.InfoLevel, "") if clusterMean > hiThreshold { elekLog.ElektronLogger.Log(elekLogTypes.CONSOLE, - log.InfoLevel, - log.Fields{}, "Need to cap a node") + log.InfoLevel, "Need to cap a node") // Create statics for all victims and choose one to cap victims := make([]pcp.Victim, 0, 8) @@ -163,14 +149,12 @@ func StartPCPLogAndExtremaDynamicCap(quit chan struct{}, logging *bool, hiThresh if !cappedHosts[victim.Host] { cappedHosts[victim.Host] = true orderCapped = append(orderCapped, victim.Host) - elekLog.ElektronLogger.Log(elekLogTypes.CONSOLE, - log.InfoLevel, - log.Fields{"Capping Victim": fmt.Sprintf("%s", victim.Host), - "Avg. Wattage": fmt.Sprintf("%f", victim.Watts*pcp.RAPLUnits)}, "") + elekLog.ElektronLogger.WithFields(log.Fields{"Capping Victim": fmt.Sprintf("%s", victim.Host), + "Avg. Wattage": fmt.Sprintf("%f", victim.Watts*pcp.RAPLUnits)}).Log(elekLogTypes.CONSOLE, log.InfoLevel, "") if err := rapl.Cap(victim.Host, "rapl", 50); err != nil { elekLog.ElektronLogger.Log(elekLogTypes.CONSOLE, log.ErrorLevel, - log.Fields{}, "Error capping host") + "Error capping host") } break // Only cap one machine at at time. } @@ -184,13 +168,9 @@ func StartPCPLogAndExtremaDynamicCap(quit chan struct{}, logging *bool, hiThresh cappedHosts[host] = false // User RAPL package to send uncap. log.Printf("Uncapping host %s", host) - elekLog.ElektronLogger.Log(elekLogTypes.CONSOLE, - log.InfoLevel, - log.Fields{"Uncapped host": host}, "") + elekLog.ElektronLogger.WithFields(log.Fields{"Uncapped host": host}).Log(elekLogTypes.CONSOLE, log.InfoLevel, "") if err := rapl.Cap(host, "rapl", 100); err != nil { - elekLog.ElektronLogger.Log(elekLogTypes.CONSOLE, - log.ErrorLevel, - log.Fields{}, "Error capping host") + elekLog.ElektronLogger.Log(elekLogTypes.CONSOLE, log.ErrorLevel, "Error capping host") } } } @@ -200,9 +180,7 @@ func StartPCPLogAndExtremaDynamicCap(quit chan struct{}, logging *bool, hiThresh } }(logging, hiThreshold, loThreshold) - elekLog.ElektronLogger.Log(elekLogTypes.CONSOLE, - log.InfoLevel, - log.Fields{}, "PCP logging started") + elekLog.ElektronLogger.Log(elekLogTypes.CONSOLE, log.InfoLevel, "PCP logging started") if err := cmd.Start(); err != nil { log.Fatal(err) @@ -212,9 +190,7 @@ func StartPCPLogAndExtremaDynamicCap(quit chan struct{}, logging *bool, hiThresh select { case <-quit: - elekLog.ElektronLogger.Log(elekLogTypes.CONSOLE, - log.InfoLevel, - log.Fields{}, "Stopping PCP logging in 5 seconds") + elekLog.ElektronLogger.Log(elekLogTypes.CONSOLE, log.InfoLevel, "Stopping PCP logging in 5 seconds") time.Sleep(5 * time.Second) // http://stackoverflow.com/questions/22470193/why-wont-go-kill-a-child-process-correctly diff --git a/powerCap/progressiveExtrema.go b/powerCap/progressiveExtrema.go index 1362f7a..f75f849 100644 --- a/powerCap/progressiveExtrema.go +++ b/powerCap/progressiveExtrema.go @@ -56,9 +56,7 @@ func StartPCPLogAndProgressiveExtremaCap(quit chan struct{}, logging *bool, hiTh cmd.SysProcAttr = &syscall.SysProcAttr{Setpgid: true} if hiThreshold < loThreshold { - elekLog.ElektronLogger.Log(elekLogTypes.CONSOLE, - log.InfoLevel, - log.Fields{}, "High threshold is lower than low threshold!") + elekLog.ElektronLogger.Log(elekLogTypes.CONSOLE, log.InfoLevel, "High threshold is lower than low threshold!") } pipe, err := cmd.StdoutPipe() @@ -74,9 +72,7 @@ func StartPCPLogAndProgressiveExtremaCap(quit chan struct{}, logging *bool, hiTh scanner.Scan() // Write to logfile - elekLog.ElektronLogger.Log(elekLogTypes.PCP, - log.InfoLevel, - log.Fields{}, scanner.Text()) + elekLog.ElektronLogger.Log(elekLogTypes.PCP, log.InfoLevel, scanner.Text()) headers := strings.Split(scanner.Text(), ",") @@ -115,15 +111,11 @@ func StartPCPLogAndProgressiveExtremaCap(quit chan struct{}, logging *bool, hiTh for scanner.Scan() { if *logging { - elekLog.ElektronLogger.Log(elekLogTypes.CONSOLE, - log.InfoLevel, - log.Fields{}, "Logging PCP...") + elekLog.ElektronLogger.Log(elekLogTypes.CONSOLE, log.InfoLevel, "Logging PCP...") split := strings.Split(scanner.Text(), ",") text := scanner.Text() - elekLog.ElektronLogger.Log(elekLogTypes.PCP, - log.InfoLevel, - log.Fields{}, text) + elekLog.ElektronLogger.Log(elekLogTypes.PCP, log.InfoLevel, text) totalPower := 0.0 for _, powerIndex := range powerIndexes { @@ -134,10 +126,8 @@ func StartPCPLogAndProgressiveExtremaCap(quit chan struct{}, logging *bool, hiTh powerHistories[host].Value = power powerHistories[host] = powerHistories[host].Next() - elekLog.ElektronLogger.Log(elekLogTypes.CONSOLE, - log.InfoLevel, - log.Fields{"Host": fmt.Sprintf("%s", indexToHost[powerIndex]), "Power": fmt.Sprintf("%f", (power * pcp.RAPLUnits))}, - "") + elekLog.ElektronLogger.WithFields(log.Fields{"Host": fmt.Sprintf("%s", indexToHost[powerIndex]), + "Power": fmt.Sprintf("%f", (power * pcp.RAPLUnits))}).Log(elekLogTypes.CONSOLE, log.InfoLevel, "") totalPower += power } clusterPower := totalPower * pcp.RAPLUnits @@ -147,24 +137,15 @@ func StartPCPLogAndProgressiveExtremaCap(quit chan struct{}, logging *bool, hiTh clusterMean := pcp.AverageClusterPowerHistory(clusterPowerHist) - elekLog.ElektronLogger.Log(elekLogTypes.CONSOLE, - log.InfoLevel, - log.Fields{"Total power": fmt.Sprintf("%f %d", clusterPower, clusterPowerHist.Len()), - "Sec Avg": fmt.Sprintf("%f", clusterMean)}, - "") + elekLog.ElektronLogger.WithFields(log.Fields{"Total power": fmt.Sprintf("%f %d", clusterPower, clusterPowerHist.Len()), + "Sec Avg": fmt.Sprintf("%f", clusterMean)}).Log(elekLogTypes.CONSOLE, log.InfoLevel, "") if clusterMean >= hiThreshold { - elekLog.ElektronLogger.Log(elekLogTypes.CONSOLE, - log.InfoLevel, - log.Fields{}, "Need to cap a node") + elekLog.ElektronLogger.Log(elekLogTypes.CONSOLE, log.InfoLevel, "Need to cap a node") - elekLog.ElektronLogger.Log(elekLogTypes.CONSOLE, - log.InfoLevel, - log.Fields{"Cap values of capped victims": fmt.Sprintf("%v", cappedVictims)}, "") + elekLog.ElektronLogger.WithFields(log.Fields{"Cap values of capped victims": fmt.Sprintf("%v", cappedVictims)}).Log(elekLogTypes.CONSOLE, log.InfoLevel, "") - elekLog.ElektronLogger.Log(elekLogTypes.CONSOLE, - log.InfoLevel, - log.Fields{"Cap values of victims to uncap": fmt.Sprintf("%v", orderCappedVictims)}, "") + elekLog.ElektronLogger.WithFields(log.Fields{"Cap values of victims to uncap": fmt.Sprintf("%v", orderCappedVictims)}).Log(elekLogTypes.CONSOLE, log.InfoLevel, "") // Create statics for all victims and choose one to cap victims := make([]pcp.Victim, 0, 8) @@ -192,14 +173,10 @@ func StartPCPLogAndProgressiveExtremaCap(quit chan struct{}, logging *bool, hiTh // Need to cap this victim. if err := rapl.Cap(victims[i].Host, "rapl", 50.0); err != nil { - elekLog.ElektronLogger.Log(elekLogTypes.CONSOLE, - log.ErrorLevel, - log.Fields{"Error capping host": fmt.Sprintf("%s", victims[i].Host)}, "") + elekLog.ElektronLogger.WithFields(log.Fields{"Error capping host": fmt.Sprintf("%s", victims[i].Host)}).Log(elekLogTypes.CONSOLE, log.ErrorLevel, "") } else { - elekLog.ElektronLogger.Log(elekLogTypes.CONSOLE, - log.InfoLevel, - log.Fields{}, fmt.Sprintf("Capped host[%s] at %f", victims[i].Host, 50.0)) + elekLog.ElektronLogger.Logf(elekLogTypes.CONSOLE, log.InfoLevel, "Capped host[%s] at %f", victims[i].Host, 50.0) // Keeping track of this victim and it's cap value cappedVictims[victims[i].Host] = 50.0 newVictimFound = true @@ -223,14 +200,11 @@ func StartPCPLogAndProgressiveExtremaCap(quit chan struct{}, logging *bool, hiTh newCapValue := getNextCapValue(capValue, 2) if err := rapl.Cap(alreadyCappedHosts[i], "rapl", newCapValue); err != nil { - elekLog.ElektronLogger.Log(elekLogTypes.CONSOLE, - log.ErrorLevel, - log.Fields{"Error capping host": fmt.Sprintf("%s", alreadyCappedHosts[i])}, "") + elekLog.ElektronLogger.WithFields(log.Fields{"Error capping host": fmt.Sprintf("%s", alreadyCappedHosts[i])}).Log(elekLogTypes.CONSOLE, log.ErrorLevel, "") } else { // Successful cap - elekLog.ElektronLogger.Log(elekLogTypes.CONSOLE, - log.InfoLevel, - log.Fields{}, fmt.Sprintf("Capped host[%s] at %f", alreadyCappedHosts[i], newCapValue)) + elekLog.ElektronLogger.Logf(elekLogTypes.CONSOLE, log.InfoLevel, + "Capped host[%s] at %f", alreadyCappedHosts[i], newCapValue) // Checking whether this victim can be capped further if newCapValue <= constants.LowerCapLimit { // Deleting victim from cappedVictims. @@ -253,23 +227,15 @@ func StartPCPLogAndProgressiveExtremaCap(quit chan struct{}, logging *bool, hiTh } } if !canCapAlreadyCappedVictim { - elekLog.ElektronLogger.Log(elekLogTypes.CONSOLE, - log.InfoLevel, - log.Fields{}, "No Victim left to cap") + elekLog.ElektronLogger.Log(elekLogTypes.CONSOLE, log.InfoLevel, "No Victim left to cap") } } } else if clusterMean < loThreshold { - elekLog.ElektronLogger.Log(elekLogTypes.CONSOLE, - log.InfoLevel, - log.Fields{}, "Need to uncap a node") - elekLog.ElektronLogger.Log(elekLogTypes.CONSOLE, - log.InfoLevel, - log.Fields{"Cap values of capped victims": fmt.Sprintf("%v", cappedVictims)}, "") - elekLog.ElektronLogger.Log(elekLogTypes.CONSOLE, - log.InfoLevel, - log.Fields{"Cap values of victims to uncap": fmt.Sprintf("%v", orderCappedVictims)}, "") + elekLog.ElektronLogger.Log(elekLogTypes.CONSOLE, log.InfoLevel, "Need to uncap a node") + elekLog.ElektronLogger.WithFields(log.Fields{"Cap values of capped victims": fmt.Sprintf("%v", cappedVictims)}).Log(elekLogTypes.CONSOLE, log.InfoLevel, "") + elekLog.ElektronLogger.WithFields(log.Fields{"Cap values of victims to uncap": fmt.Sprintf("%v", orderCappedVictims)}).Log(elekLogTypes.CONSOLE, log.InfoLevel, "") if len(orderCapped) > 0 { // We pick the host that is capped the most to uncap. orderCappedToSort := utilities.GetPairList(orderCappedVictims) @@ -280,14 +246,10 @@ func StartPCPLogAndProgressiveExtremaCap(quit chan struct{}, logging *bool, hiTh newUncapValue := orderCappedVictims[hostToUncap] * 2.0 if err := rapl.Cap(hostToUncap, "rapl", newUncapValue); err != nil { - elekLog.ElektronLogger.Log(elekLogTypes.CONSOLE, - log.ErrorLevel, - log.Fields{"Error uncapping host": fmt.Sprintf("%s", hostToUncap)}, "") + elekLog.ElektronLogger.WithFields(log.Fields{"Error uncapping host": fmt.Sprintf("%s", hostToUncap)}).Log(elekLogTypes.CONSOLE, log.ErrorLevel, "") } else { // Successful uncap - elekLog.ElektronLogger.Log(elekLogTypes.CONSOLE, - log.InfoLevel, - log.Fields{}, fmt.Sprintf("Uncapped host[%s] to %f", hostToUncap, newUncapValue)) + elekLog.ElektronLogger.Logf(elekLogTypes.CONSOLE, log.InfoLevel, "Uncapped host[%s] to %f", hostToUncap, newUncapValue) // Can we uncap this host further. If not, then we remove its entry from orderCapped if newUncapValue >= 100.0 { // can compare using == // Deleting entry from orderCapped @@ -308,9 +270,7 @@ func StartPCPLogAndProgressiveExtremaCap(quit chan struct{}, logging *bool, hiTh } } } else { - elekLog.ElektronLogger.Log(elekLogTypes.CONSOLE, - log.InfoLevel, - log.Fields{}, "No host staged for Uncapped") + elekLog.ElektronLogger.Log(elekLogTypes.CONSOLE, log.InfoLevel, "No host staged for Uncapped") } } } @@ -319,9 +279,7 @@ func StartPCPLogAndProgressiveExtremaCap(quit chan struct{}, logging *bool, hiTh }(logging, hiThreshold, loThreshold) - elekLog.ElektronLogger.Log(elekLogTypes.CONSOLE, - log.InfoLevel, - log.Fields{}, "PCP logging started") + elekLog.ElektronLogger.Log(elekLogTypes.CONSOLE, log.InfoLevel, "PCP logging started") if err := cmd.Start(); err != nil { log.Fatal(err) } @@ -330,9 +288,7 @@ func StartPCPLogAndProgressiveExtremaCap(quit chan struct{}, logging *bool, hiTh select { case <-quit: - elekLog.ElektronLogger.Log(elekLogTypes.CONSOLE, - log.InfoLevel, - log.Fields{}, "Stopping PCP logging in 5 seconds") + elekLog.ElektronLogger.Log(elekLogTypes.CONSOLE, log.InfoLevel, "Stopping PCP logging in 5 seconds") time.Sleep(5 * time.Second) // http://stackoverflow.com/questions/22470193/why-wont-go-kill-a-child-process-correctly diff --git a/scheduler.go b/scheduler.go index d171870..ec2df7b 100644 --- a/scheduler.go +++ b/scheduler.go @@ -282,11 +282,8 @@ func main() { // Starting the scheduler driver. if status, err := driver.Run(); err != nil { - elekLog.ElektronLogger.Log(elekLogTypes.CONSOLE, - log.ErrorLevel, - log.Fields{"status": status.String(), "error": err.Error()}, "Framework stopped ") + elekLog.ElektronLogger.WithFields(log.Fields{"status": status.String(), "error": err.Error()}).Log(elekLogTypes.CONSOLE, + log.ErrorLevel, "Framework stopped ") } - elekLog.ElektronLogger.Log(elekLogTypes.CONSOLE, - log.InfoLevel, - log.Fields{}, "Exiting...") + elekLog.ElektronLogger.Log(elekLogTypes.CONSOLE, log.InfoLevel, "Exiting...") } diff --git a/schedulers/base.go b/schedulers/base.go index 5844281..065a903 100644 --- a/schedulers/base.go +++ b/schedulers/base.go @@ -250,39 +250,31 @@ func (s *BaseScheduler) StatusUpdate(driver sched.SchedulerDriver, status *mesos func (s *BaseScheduler) LogTaskStarting(ts *def.Task, offer *mesos.Offer) { if ts == nil { - elekLog.ElektronLogger.Log(elekLogTypes.CONSOLE, log.InfoLevel, - log.Fields{"host": fmt.Sprintf("%s", offer.GetHostname())}, "TASKS STARTING...") + elekLog.ElektronLogger.WithFields(log.Fields{"host": fmt.Sprintf("%s", offer.GetHostname())}).Log(elekLogTypes.CONSOLE, log.InfoLevel, "TASKS STARTING...") } else { - elekLog.ElektronLogger.Log(elekLogTypes.CONSOLE, - log.InfoLevel, - log.Fields{"task": fmt.Sprintf("%s", ts.Name), - "Instance": fmt.Sprintf("%d", *ts.Instances), "host": fmt.Sprintf("%s", offer.GetHostname())}, - "TASK STARTING... ") + elekLog.ElektronLogger.WithFields(log.Fields{"task": fmt.Sprintf("%s", ts.Name), + "Instance": fmt.Sprintf("%d", *ts.Instances), "host": fmt.Sprintf("%s", offer.GetHostname())}).Log(elekLogTypes.CONSOLE, + log.InfoLevel, "TASK STARTING... ") } } func (s *BaseScheduler) LogTaskWattsConsideration(ts def.Task, host string, wattsToConsider float64) { - elekLog.ElektronLogger.Log(elekLogTypes.CONSOLE, - log.InfoLevel, - log.Fields{"task": ts.Name, "host": host, "Watts": fmt.Sprintf("%f", wattsToConsider)}, "Watts considered for ") + elekLog.ElektronLogger.WithFields(log.Fields{"task": ts.Name, "host": host, "Watts": fmt.Sprintf("%f", wattsToConsider)}).Log(elekLogTypes.CONSOLE, log.InfoLevel, "Watts considered for ") } func (s *BaseScheduler) LogOffersReceived(offers []*mesos.Offer) { - elekLog.ElektronLogger.Log(elekLogTypes.CONSOLE, - log.InfoLevel, - log.Fields{"Resource offers received": fmt.Sprintf("%d", len(offers))}, "") + elekLog.ElektronLogger.WithFields(log.Fields{"Resource offers received": fmt.Sprintf("%d", len(offers))}).Log(elekLogTypes.CONSOLE, + log.InfoLevel, "") } func (s *BaseScheduler) LogNoPendingTasksDeclineOffers(offer *mesos.Offer) { - elekLog.ElektronLogger.Log(elekLogTypes.CONSOLE, - log.WarnLevel, - log.Fields{"DECLINING OFFER for host": fmt.Sprintf("%s", offer.GetHostname())}, "No tasks left to schedule ") + elekLog.ElektronLogger.WithFields(log.Fields{"DECLINING OFFER for host": fmt.Sprintf("%s", offer.GetHostname())}).Log(elekLogTypes.CONSOLE, + log.WarnLevel, "No tasks left to schedule ") } func (s *BaseScheduler) LogNumberOfRunningTasks() { - elekLog.ElektronLogger.Log(elekLogTypes.CONSOLE, - log.InfoLevel, - log.Fields{"Number of tasks still Running": fmt.Sprintf("%d", s.tasksRunning)}, "") + elekLog.ElektronLogger.WithFields(log.Fields{"Number of tasks still Running": fmt.Sprintf("%d", s.tasksRunning)}).Log(elekLogTypes.CONSOLE, + log.InfoLevel, "") } func (s *BaseScheduler) LogCoLocatedTasks(slaveID string) { @@ -292,81 +284,67 @@ func (s *BaseScheduler) LogCoLocatedTasks(slaveID string) { buffer.WriteString(fmt.Sprintln(taskName)) } s.TasksRunningMutex.Unlock() - elekLog.ElektronLogger.Log(elekLogTypes.CONSOLE, - log.InfoLevel, - log.Fields{"Colocated with": fmt.Sprintf("%s", buffer.String())}, "") + elekLog.ElektronLogger.WithFields(log.Fields{"Colocated with": fmt.Sprintf("%s", buffer.String())}).Log(elekLogTypes.CONSOLE, + log.InfoLevel, "") } func (s *BaseScheduler) LogSchedTrace(taskToSchedule *mesos.TaskInfo, offer *mesos.Offer) { - elekLog.ElektronLogger.Log(elekLogTypes.SCHED_TRACE, - log.InfoLevel, - log.Fields{offer.GetHostname(): fmt.Sprintf("%s", taskToSchedule.GetTaskId().GetValue())}, "") + elekLog.ElektronLogger.WithFields(log.Fields{offer.GetHostname(): fmt.Sprintf("%s", taskToSchedule.GetTaskId().GetValue())}).Log(elekLogTypes.SCHED_TRACE, log.InfoLevel, "") } func (s *BaseScheduler) LogTerminateScheduler() { - elekLog.ElektronLogger.Log(elekLogTypes.CONSOLE, log.InfoLevel, log.Fields{}, "Done scheduling all tasks!") + elekLog.ElektronLogger.Log(elekLogTypes.CONSOLE, log.InfoLevel, "Done scheduling all tasks!") } func (s *BaseScheduler) LogInsufficientResourcesDeclineOffer(offer *mesos.Offer, offerResources ...interface{}) { buffer := bytes.Buffer{} buffer.WriteString(fmt.Sprintf("", offerResources...)) - elekLog.ElektronLogger.Log(elekLogTypes.CONSOLE, - log.WarnLevel, - log.Fields{"Offer Resources": fmt.Sprintf("%s", buffer.String())}, "DECLINING OFFER... Offer has insufficient resources to launch a task") + elekLog.ElektronLogger.WithFields(log.Fields{"Offer Resources": fmt.Sprintf("%s", buffer.String())}).Log(elekLogTypes.CONSOLE, + log.WarnLevel, "DECLINING OFFER... Offer has insufficient resources to launch a task") } func (s *BaseScheduler) LogOfferRescinded(offerID *mesos.OfferID) { - elekLog.ElektronLogger.Log(elekLogTypes.CONSOLE, - log.ErrorLevel, - log.Fields{"OfferID": fmt.Sprintf("%s", offerID)}, "OFFER RESCINDED") + elekLog.ElektronLogger.WithFields(log.Fields{"OfferID": fmt.Sprintf("%s", offerID)}).Log(elekLogTypes.CONSOLE, + log.ErrorLevel, "OFFER RESCINDED") } func (s *BaseScheduler) LogSlaveLost(slaveID *mesos.SlaveID) { - elekLog.ElektronLogger.Log(elekLogTypes.CONSOLE, - log.ErrorLevel, - log.Fields{"SlaveID": fmt.Sprintf("%s", slaveID)}, "SLAVE LOST") + elekLog.ElektronLogger.WithFields(log.Fields{"SlaveID": fmt.Sprintf("%s", slaveID)}).Log(elekLogTypes.CONSOLE, + log.ErrorLevel, "SLAVE LOST") } func (s *BaseScheduler) LogExecutorLost(executorID *mesos.ExecutorID, slaveID *mesos.SlaveID) { - elekLog.ElektronLogger.Log(elekLogTypes.CONSOLE, - log.ErrorLevel, - log.Fields{"ExecutorID": fmt.Sprintf("%s", executorID), "SlaveID": fmt.Sprintf("%s", slaveID)}, "EXECUTOR LOST") + elekLog.ElektronLogger.WithFields(log.Fields{"ExecutorID": fmt.Sprintf("%s", executorID), "SlaveID": fmt.Sprintf("%s", slaveID)}).Log(elekLogTypes.CONSOLE, log.ErrorLevel, "EXECUTOR LOST") } func (s *BaseScheduler) LogFrameworkMessage(executorID *mesos.ExecutorID, slaveID *mesos.SlaveID, message string) { - elekLog.ElektronLogger.Log(elekLogTypes.CONSOLE, - log.InfoLevel, - log.Fields{"Received Framework message from executor": executorID}, message) + elekLog.ElektronLogger.WithFields(log.Fields{"Received Framework message from executor": executorID}).Log(elekLogTypes.CONSOLE, + log.InfoLevel, message) } func (s *BaseScheduler) LogMesosError(err string) { - elekLog.ElektronLogger.Log(elekLogTypes.CONSOLE, - log.ErrorLevel, - log.Fields{"MESOS CONSOLE": fmt.Sprintf("%v", err)}, "") + elekLog.ElektronLogger.WithFields(log.Fields{"MESOS CONSOLE": fmt.Sprintf("%v", err)}).Log(elekLogTypes.CONSOLE, + log.ErrorLevel, "") } func (s *BaseScheduler) LogElectronError(err error) { - elekLog.ElektronLogger.Log(elekLogTypes.CONSOLE, - log.ErrorLevel, log.Fields{"ELECTRON CONSOLE": fmt.Sprintf("%v", err)}, "") + elekLog.ElektronLogger.WithFields(log.Fields{"ELECTRON CONSOLE": fmt.Sprintf("%v", err)}).Log(elekLogTypes.CONSOLE, log.ErrorLevel, "") } func (s *BaseScheduler) LogFrameworkRegistered(frameworkID *mesos.FrameworkID, masterInfo *mesos.MasterInfo) { - elekLog.ElektronLogger.Log(elekLogTypes.CONSOLE, - log.InfoLevel, - log.Fields{"frameworkID": fmt.Sprintf("%s", frameworkID), "master": fmt.Sprintf("%v", masterInfo)}, "FRAMEWORK REGISTERED!") + elekLog.ElektronLogger.WithFields(log.Fields{"frameworkID": fmt.Sprintf("%s", frameworkID), "master": fmt.Sprintf("%v", masterInfo)}).Log(elekLogTypes.CONSOLE, log.InfoLevel, "FRAMEWORK REGISTERED!") } func (s *BaseScheduler) LogFrameworkReregistered(masterInfo *mesos.MasterInfo) { - elekLog.ElektronLogger.Log(elekLogTypes.CONSOLE, - log.InfoLevel, - log.Fields{"master": fmt.Sprintf("%v", masterInfo)}, "Framework re-registered") + elekLog.ElektronLogger.WithFields(log.Fields{"master": fmt.Sprintf("%v", masterInfo)}).Log(elekLogTypes.CONSOLE, + log.InfoLevel, "Framework re-registered") } func (s *BaseScheduler) LogDisconnected() { - elekLog.ElektronLogger.Log(elekLogTypes.CONSOLE, log.WarnLevel, log.Fields{}, "Framework disconnected with master") + elekLog.ElektronLogger.Log(elekLogTypes.CONSOLE, log.WarnLevel, "Framework disconnected with master") } func (s *BaseScheduler) LogTaskStatusUpdate(status *mesos.TaskStatus) { @@ -378,13 +356,12 @@ func (s *BaseScheduler) LogTaskStatusUpdate(status *mesos.TaskStatus) { default: level = log.InfoLevel } - elekLog.ElektronLogger.Log(elekLogTypes.CONSOLE, - level, log.Fields{"task": fmt.Sprintf("%s", *status.TaskId.Value), "state": NameFor(status.State)}, "Task Status received") + elekLog.ElektronLogger.WithFields(log.Fields{"task": fmt.Sprintf("%s", *status.TaskId.Value), "state": NameFor(status.State)}).Log(elekLogTypes.CONSOLE, level, "Task Status received") } func (s *BaseScheduler) LogSchedPolicySwitch(name string, nextPolicy SchedPolicyState) { logSPS := func() { - elekLog.ElektronLogger.Log(elekLogTypes.SPS, log.InfoLevel, log.Fields{"Name": name}, "") + elekLog.ElektronLogger.WithFields(log.Fields{"Name": name}).Log(elekLogTypes.SPS, log.InfoLevel, "") } if s.hasReceivedResourceOffers && (s.curSchedPolicy != nextPolicy) { logSPS() @@ -393,14 +370,10 @@ func (s *BaseScheduler) LogSchedPolicySwitch(name string, nextPolicy SchedPolicy } // Logging the size of the scheduling window and the scheduling policy // that is going to schedule the tasks in the scheduling window. - elekLog.ElektronLogger.Log(elekLogTypes.SCHED_WINDOW, - log.InfoLevel, - log.Fields{"Window size": fmt.Sprintf("%d", s.schedWindowSize), "Name": name}, "") + elekLog.ElektronLogger.WithFields(log.Fields{"Window size": fmt.Sprintf("%d", s.schedWindowSize), "Name": name}).Log(elekLogTypes.SCHED_WINDOW, log.InfoLevel, "") } func (s *BaseScheduler) LogClsfnAndTaskDistOverhead(overhead time.Duration) { // Logging the overhead in microseconds. - elekLog.ElektronLogger.Log(elekLogTypes.CLSFN_TASKDIST_OVERHEAD, - log.InfoLevel, - log.Fields{"Overhead in microseconds": fmt.Sprintf("%f", float64(overhead.Nanoseconds())/1000.0)}, "") + elekLog.ElektronLogger.WithFields(log.Fields{"Overhead in microseconds": fmt.Sprintf("%f", float64(overhead.Nanoseconds())/1000.0)}).Log(elekLogTypes.CLSFN_TASKDIST_OVERHEAD, log.InfoLevel, "") } diff --git a/schedulers/helpers.go b/schedulers/helpers.go index 2bf0cd3..a9004e0 100644 --- a/schedulers/helpers.go +++ b/schedulers/helpers.go @@ -36,10 +36,10 @@ import ( func coLocated(tasks map[string]bool, s BaseScheduler) { for _, task := range tasks { - elekLog.ElektronLogger.Log(elekLogTypes.CONSOLE, log.InfoLevel, log.Fields{"Task": task}, "") + elekLog.ElektronLogger.WithFields(log.Fields{"Task": task}).Log(elekLogTypes.CONSOLE, log.InfoLevel, "") } - elekLog.ElektronLogger.Log(elekLogTypes.CONSOLE, log.InfoLevel, log.Fields{}, "---------------------") + elekLog.ElektronLogger.Log(elekLogTypes.CONSOLE, log.InfoLevel, "---------------------") } // Get the powerClass of the given hostname. diff --git a/schedulers/schedPolicy.go b/schedulers/schedPolicy.go index dd0c58f..dfd44ec 100644 --- a/schedulers/schedPolicy.go +++ b/schedulers/schedPolicy.go @@ -90,9 +90,8 @@ func switchTaskDistBased(baseSchedRef *BaseScheduler) string { // Determine the distribution of tasks in the new scheduling window. taskDist, err := def.GetTaskDistributionInWindow(baseSchedRef.schedWindowSize, baseSchedRef.tasks) baseSchedRef.LogClsfnAndTaskDistOverhead(time.Now().Sub(startTime)) - elekLog.ElektronLogger.Log(elekLogTypes.CONSOLE, - log.InfoLevel, - log.Fields{"Task Distribution": fmt.Sprintf("%f", taskDist)}, "Switching... ") + elekLog.ElektronLogger.WithFields(log.Fields{"Task Distribution": fmt.Sprintf("%f", taskDist)}).Log(elekLogTypes.CONSOLE, + log.InfoLevel, "Switching... ") if err != nil { // All the tasks in the window were only classified into 1 cluster. // Max-Min and Max-GreedyMins would work the same way as Bin-Packing for this situation. diff --git a/utilities/offerUtils/offerUtils.go b/utilities/offerUtils/offerUtils.go index 7aaf30d..4c1a475 100644 --- a/utilities/offerUtils/offerUtils.go +++ b/utilities/offerUtils/offerUtils.go @@ -90,14 +90,13 @@ func UpdateEnvironment(offer *mesos.Offer) { var host = offer.GetHostname() // If this host is not present in the set of hosts. if _, ok := constants.Hosts[host]; !ok { - elekLog.ElektronLogger.Log(elekLogTypes.CONSOLE, log.InfoLevel, - log.Fields{"Adding host": host}, "New host detected") + elekLog.ElektronLogger.WithFields(log.Fields{"Adding host": host}).Log(elekLogTypes.CONSOLE, log.InfoLevel, "New host detected") // Add this host. constants.Hosts[host] = struct{}{} // Get the power class of this host. class := PowerClass(offer) - elekLog.ElektronLogger.Log(elekLogTypes.CONSOLE, log.InfoLevel, - log.Fields{"host": host, "PowerClass": class}, "Registering the power class...") + elekLog.ElektronLogger.WithFields(log.Fields{"host": host, "PowerClass": class}).Log(elekLogTypes.CONSOLE, + log.InfoLevel, "Registering the power class...") // If new power class, register the power class. if _, ok := constants.PowerClasses[class]; !ok { constants.PowerClasses[class] = make(map[string]struct{}) diff --git a/utilities/schedUtils/schedUtils.go b/utilities/schedUtils/schedUtils.go index 6f50334..5e4fc69 100644 --- a/utilities/schedUtils/schedUtils.go +++ b/utilities/schedUtils/schedUtils.go @@ -19,8 +19,6 @@ package schedUtils import ( - "fmt" - log "github.com/sirupsen/logrus" "github.com/spdfg/elektron/def" elekLog "github.com/spdfg/elektron/elektronLogging" @@ -80,9 +78,9 @@ func (s *fillNextOfferCycle) apply(taskQueue []def.Task) (int, int) { for _, task := range taskQueue { numberOfTasksTraversed++ for i := *task.Instances; i > 0; i-- { - elekLog.ElektronLogger.Log(elekLogTypes.CONSOLE, log.InfoLevel, - log.Fields{}, fmt.Sprintf("Checking if Instance #%d of Task[%s] can be scheduled "+ - "during the next offer cycle...", i, task.Name)) + elekLog.ElektronLogger.Logf(elekLogTypes.CONSOLE, log.InfoLevel, + "Checking if Instance #%d of Task[%s] can be scheduled "+ + "during the next offer cycle...", i, task.Name) if canSchedule(task) { filledCPU += task.CPU filledRAM += task.RAM -- 2.47.2 From c91416164318eb07fac3e417d9c99750fdda54e8 Mon Sep 17 00:00:00 2001 From: balandi1 Date: Wed, 4 Dec 2019 14:08:17 -0500 Subject: [PATCH 26/48] Minor bug fixes --- .../clsfnTaskDistOverheadLogger.go | 35 +++++++++--------- elektronLogging/consoleLogger.go | 37 +++++++++---------- elektronLogging/createLogDir.go | 3 +- elektronLogging/logger.go | 2 +- elektronLogging/pcpLogger.go | 35 +++++++++--------- elektronLogging/schedPolicySwitchLogger.go | 35 +++++++++--------- elektronLogging/schedTraceLogger.go | 35 +++++++++--------- elektronLogging/schedWindowLogger.go | 35 +++++++++--------- elektronLogging/types/types.go | 2 +- schedulers/base.go | 2 +- 10 files changed, 108 insertions(+), 113 deletions(-) diff --git a/elektronLogging/clsfnTaskDistOverheadLogger.go b/elektronLogging/clsfnTaskDistOverheadLogger.go index 6d0823f..6565211 100644 --- a/elektronLogging/clsfnTaskDistOverheadLogger.go +++ b/elektronLogging/clsfnTaskDistOverheadLogger.go @@ -22,9 +22,8 @@ func NewClsfnTaskDistrOverheadLogger(b *baseLogData, logType int, prefix string) } func (cLog ClsfnTaskDistrOverheadLogger) Log(logType int, level log.Level, message string) { - if config.TaskDistrConfig.Enabled { - if cLog.Type == logType { - + if cLog.Type == logType { + if config.TaskDistrConfig.Enabled { if cLog.AllowOnConsole { logger.SetOutput(os.Stdout) logger.WithFields(cLog.data).Log(level, message) @@ -33,19 +32,19 @@ func (cLog ClsfnTaskDistrOverheadLogger) Log(logType int, level log.Level, messa logger.SetOutput(cLog.LogFile) logger.WithFields(cLog.data).Log(level, message) } - if cLog.next != nil { - cLog.next.Log(logType, level, message) - } else { - // Clearing the fields. - cLog.resetFields() - } + } + // Forwarding to next logger + if cLog.next != nil { + cLog.next.Log(logType, level, message) + } else { + // Clearing the fields. + cLog.resetFields() } } func (cLog ClsfnTaskDistrOverheadLogger) Logf(logType int, level log.Level, msgFmtString string, args ...interface{}) { - if config.TaskDistrConfig.Enabled { - if cLog.Type == logType { - + if cLog.Type == logType { + if config.TaskDistrConfig.Enabled { if cLog.AllowOnConsole { logger.SetOutput(os.Stdout) logger.WithFields(cLog.data).Logf(level, msgFmtString, args...) @@ -54,12 +53,12 @@ func (cLog ClsfnTaskDistrOverheadLogger) Logf(logType int, level log.Level, msgF logger.SetOutput(cLog.LogFile) logger.WithFields(cLog.data).Logf(level, msgFmtString, args...) } - if cLog.next != nil { - cLog.next.Logf(logType, level, msgFmtString, args...) - } else { - // Clearing the fields. - cLog.resetFields() - } + } + if cLog.next != nil { + cLog.next.Logf(logType, level, msgFmtString, args...) + } else { + // Clearing the fields. + cLog.resetFields() } } diff --git a/elektronLogging/consoleLogger.go b/elektronLogging/consoleLogger.go index b1b9eda..64b20ea 100644 --- a/elektronLogging/consoleLogger.go +++ b/elektronLogging/consoleLogger.go @@ -21,45 +21,44 @@ func NewConsoleLogger(b *baseLogData, logType int, prefix string) *ConsoleLogger return cLog } func (cLog ConsoleLogger) Log(logType int, level log.Level, message string) { - if config.ConsoleConfig.Enabled { - if logType <= cLog.Type { - + if logType <= cLog.Type { + if config.ConsoleConfig.Enabled { logger.SetOutput(os.Stdout) logger.WithFields(cLog.data).Log(level, message) logger.SetOutput(cLog.LogFile) logger.WithFields(cLog.data).Log(level, message) } - if cLog.next != nil { - cLog.next.Log(logType, level, message) - } else { - // Clearing the fields. - cLog.resetFields() - } + } + // Forwarding to next logger. + if cLog.next != nil { + cLog.next.Log(logType, level, message) + } else { + // Clearing the fields. + cLog.resetFields() } } func (cLog ConsoleLogger) Logf(logType int, level log.Level, msgFmtString string, args ...interface{}) { - if config.ConsoleConfig.Enabled { - if logType <= cLog.Type { - + if logType <= cLog.Type { + if config.ConsoleConfig.Enabled { logger.SetOutput(os.Stdout) logger.WithFields(cLog.data).Logf(level, msgFmtString, args...) logger.SetOutput(cLog.LogFile) logger.WithFields(cLog.data).Logf(level, msgFmtString, args...) } - if cLog.next != nil { - cLog.next.Logf(logType, level, msgFmtString, args...) - } else { - // Clearing the fields. - cLog.resetFields() - } + } + if cLog.next != nil { + cLog.next.Logf(logType, level, msgFmtString, args...) + } else { + // Clearing the fields. + cLog.resetFields() } } func (cLog *ConsoleLogger) CreateLogFile(prefix string) { - + // Create log file for the type if it is enabled. if config.ConsoleConfig.Enabled { filename := strings.Join([]string{prefix, config.ConsoleConfig.FilenameExtension}, "") dirName := logDir.getDirName() diff --git a/elektronLogging/createLogDir.go b/elektronLogging/createLogDir.go index c40abbc..b5666d9 100644 --- a/elektronLogging/createLogDir.go +++ b/elektronLogging/createLogDir.go @@ -20,7 +20,8 @@ func (logD *logDirectory) getDirName() string { func (logD *logDirectory) createLogDir(prefix string, startTime time.Time) { if logD.name == "" { - // Creating directory to store all logs for this run. Directory name format - 2019-November-21_14-33-0. + // Creating directory to store all logs for this run. Directory name format : _2019-November-21_14-33-0. + prefix = prefix + "_" logDirName := strings.Join([]string{"./", prefix, strconv.Itoa(startTime.Year())}, "") logDirName = strings.Join([]string{logDirName, startTime.Month().String(), strconv.Itoa(startTime.Day())}, "-") logDirName = strings.Join([]string{logDirName, strconv.Itoa(startTime.Hour())}, "_") diff --git a/elektronLogging/logger.go b/elektronLogging/logger.go index 44f70ee..bdf07ea 100644 --- a/elektronLogging/logger.go +++ b/elektronLogging/logger.go @@ -42,7 +42,7 @@ func BuildLogger(prefix string, logConfigFilename string) { schedTraceLog := NewSchedTraceLogger(b, SCHED_TRACE, prefix) spsLog := NewSchedPolicySwitchLogger(b, SPS, prefix) schedWindowLog := NewSchedWindowLogger(b, SCHED_WINDOW, prefix) - tskDistLog := NewClsfnTaskDistrOverheadLogger(b, CLSFN_TASKDIST_OVERHEAD, prefix) + tskDistLog := NewClsfnTaskDistrOverheadLogger(b, CLSFN_TASKDISTR_OVERHEAD, prefix) head.SetNext(cLog) cLog.SetNext(pLog) diff --git a/elektronLogging/pcpLogger.go b/elektronLogging/pcpLogger.go index 022e885..192eb88 100644 --- a/elektronLogging/pcpLogger.go +++ b/elektronLogging/pcpLogger.go @@ -22,9 +22,8 @@ func NewPCPLogger(b *baseLogData, logType int, prefix string) *PCPLogger { } func (pLog PCPLogger) Log(logType int, level log.Level, message string) { - if config.PCPConfig.Enabled { - if pLog.Type == logType { - + if pLog.Type == logType { + if config.PCPConfig.Enabled { if pLog.AllowOnConsole { logger.SetOutput(os.Stdout) logger.WithFields(pLog.data).Log(level, message) @@ -33,19 +32,18 @@ func (pLog PCPLogger) Log(logType int, level log.Level, message string) { logger.SetOutput(pLog.LogFile) logger.WithFields(pLog.data).Log(level, message) } - if pLog.next != nil { - pLog.next.Log(logType, level, message) - } else { - // Clearing the fields. - pLog.resetFields() - } + } + if pLog.next != nil { + pLog.next.Log(logType, level, message) + } else { + // Clearing the fields. + pLog.resetFields() } } func (pLog PCPLogger) Logf(logType int, level log.Level, msgFmtString string, args ...interface{}) { - if config.PCPConfig.Enabled { - if pLog.Type == logType { - + if pLog.Type == logType { + if config.PCPConfig.Enabled { if pLog.AllowOnConsole { logger.SetOutput(os.Stdout) logger.WithFields(pLog.data).Logf(level, msgFmtString, args...) @@ -54,12 +52,13 @@ func (pLog PCPLogger) Logf(logType int, level log.Level, msgFmtString string, ar logger.SetOutput(pLog.LogFile) logger.WithFields(pLog.data).Logf(level, msgFmtString, args...) } - if pLog.next != nil { - pLog.next.Logf(logType, level, msgFmtString, args...) - } else { - // Clearing the fields. - pLog.resetFields() - } + } + // Forwarding to next logger + if pLog.next != nil { + pLog.next.Logf(logType, level, msgFmtString, args...) + } else { + // Clearing the fields. + pLog.resetFields() } } diff --git a/elektronLogging/schedPolicySwitchLogger.go b/elektronLogging/schedPolicySwitchLogger.go index b13cc5b..8d85d2f 100644 --- a/elektronLogging/schedPolicySwitchLogger.go +++ b/elektronLogging/schedPolicySwitchLogger.go @@ -22,9 +22,8 @@ func NewSchedPolicySwitchLogger(b *baseLogData, logType int, prefix string) *Sch } func (sLog SchedPolicySwitchLogger) Log(logType int, level log.Level, message string) { - if config.SPSConfig.Enabled { - if sLog.Type == logType { - + if sLog.Type == logType { + if config.SPSConfig.Enabled { if sLog.AllowOnConsole { logger.SetOutput(os.Stdout) logger.WithFields(sLog.data).Log(level, message) @@ -33,19 +32,18 @@ func (sLog SchedPolicySwitchLogger) Log(logType int, level log.Level, message st logger.SetOutput(sLog.LogFile) logger.WithFields(sLog.data).Log(level, message) } - if sLog.next != nil { - sLog.next.Log(logType, level, message) - } else { - // Clearing the fields. - sLog.resetFields() - } + } + if sLog.next != nil { + sLog.next.Log(logType, level, message) + } else { + // Clearing the fields. + sLog.resetFields() } } func (sLog SchedPolicySwitchLogger) Logf(logType int, level log.Level, msgFmtString string, args ...interface{}) { - if config.SPSConfig.Enabled { - if sLog.Type == logType { - + if sLog.Type == logType { + if config.SPSConfig.Enabled { if sLog.AllowOnConsole { logger.SetOutput(os.Stdout) logger.WithFields(sLog.data).Logf(level, msgFmtString, args...) @@ -54,12 +52,13 @@ func (sLog SchedPolicySwitchLogger) Logf(logType int, level log.Level, msgFmtStr logger.SetOutput(sLog.LogFile) logger.WithFields(sLog.data).Logf(level, msgFmtString, args...) } - if sLog.next != nil { - sLog.next.Logf(logType, level, msgFmtString, args...) - } else { - // Clearing the fields. - sLog.resetFields() - } + } + // Forwarding to next logger + if sLog.next != nil { + sLog.next.Logf(logType, level, msgFmtString, args...) + } else { + // Clearing the fields. + sLog.resetFields() } } diff --git a/elektronLogging/schedTraceLogger.go b/elektronLogging/schedTraceLogger.go index 2a429dd..838eff7 100644 --- a/elektronLogging/schedTraceLogger.go +++ b/elektronLogging/schedTraceLogger.go @@ -22,9 +22,8 @@ func NewSchedTraceLogger(b *baseLogData, logType int, prefix string) *SchedTrace } func (sLog SchedTraceLogger) Log(logType int, level log.Level, message string) { - if config.SchedTraceConfig.Enabled { - if sLog.Type == logType { - + if sLog.Type == logType { + if config.SchedTraceConfig.Enabled { if sLog.AllowOnConsole { logger.SetOutput(os.Stdout) logger.WithFields(sLog.data).Log(level, message) @@ -33,19 +32,18 @@ func (sLog SchedTraceLogger) Log(logType int, level log.Level, message string) { logger.SetOutput(sLog.LogFile) logger.WithFields(sLog.data).Log(level, message) } - if sLog.next != nil { - sLog.next.Log(logType, level, message) - } else { - // Clearing the fields. - sLog.resetFields() - } + } + if sLog.next != nil { + sLog.next.Log(logType, level, message) + } else { + // Clearing the fields. + sLog.resetFields() } } func (sLog SchedTraceLogger) Logf(logType int, level log.Level, msgFmtString string, args ...interface{}) { - if config.SchedTraceConfig.Enabled { - if sLog.Type == logType { - + if sLog.Type == logType { + if config.SchedTraceConfig.Enabled { if sLog.AllowOnConsole { logger.SetOutput(os.Stdout) logger.WithFields(sLog.data).Logf(level, msgFmtString, args...) @@ -54,12 +52,13 @@ func (sLog SchedTraceLogger) Logf(logType int, level log.Level, msgFmtString str logger.SetOutput(sLog.LogFile) logger.WithFields(sLog.data).Logf(level, msgFmtString, args...) } - if sLog.next != nil { - sLog.next.Logf(logType, level, msgFmtString, args...) - } else { - // Clearing the fields. - sLog.resetFields() - } + } + // Forwarding to next logger + if sLog.next != nil { + sLog.next.Logf(logType, level, msgFmtString, args...) + } else { + // Clearing the fields. + sLog.resetFields() } } diff --git a/elektronLogging/schedWindowLogger.go b/elektronLogging/schedWindowLogger.go index d7c1895..e8d6958 100644 --- a/elektronLogging/schedWindowLogger.go +++ b/elektronLogging/schedWindowLogger.go @@ -22,9 +22,8 @@ func NewSchedWindowLogger(b *baseLogData, logType int, prefix string) *SchedWind } func (sLog SchedWindowLogger) Log(logType int, level log.Level, message string) { - if config.SchedWindowConfig.Enabled { - if sLog.Type == logType { - + if sLog.Type == logType { + if config.SchedWindowConfig.Enabled { if sLog.AllowOnConsole { logger.SetOutput(os.Stdout) logger.WithFields(sLog.data).Log(level, message) @@ -33,19 +32,19 @@ func (sLog SchedWindowLogger) Log(logType int, level log.Level, message string) logger.SetOutput(sLog.LogFile) logger.WithFields(sLog.data).Log(level, message) } - if sLog.next != nil { - sLog.next.Log(logType, level, message) - } else { - // Clearing the fields. - sLog.resetFields() - } + } + // Forwarding to next logger + if sLog.next != nil { + sLog.next.Log(logType, level, message) + } else { + // Clearing the fields. + sLog.resetFields() } } func (sLog SchedWindowLogger) Logf(logType int, level log.Level, msgFmtString string, args ...interface{}) { - if config.SchedWindowConfig.Enabled { - if sLog.Type == logType { - + if sLog.Type == logType { + if config.SchedWindowConfig.Enabled { if sLog.AllowOnConsole { logger.SetOutput(os.Stdout) logger.WithFields(sLog.data).Logf(level, msgFmtString, args...) @@ -54,12 +53,12 @@ func (sLog SchedWindowLogger) Logf(logType int, level log.Level, msgFmtString st logger.SetOutput(sLog.LogFile) logger.WithFields(sLog.data).Logf(level, msgFmtString, args...) } - if sLog.next != nil { - sLog.next.Logf(logType, level, msgFmtString, args...) - } else { - // Clearing the fields. - sLog.resetFields() - } + } + if sLog.next != nil { + sLog.next.Logf(logType, level, msgFmtString, args...) + } else { + // Clearing the fields. + sLog.resetFields() } } diff --git a/elektronLogging/types/types.go b/elektronLogging/types/types.go index 7e99836..903fe34 100644 --- a/elektronLogging/types/types.go +++ b/elektronLogging/types/types.go @@ -6,5 +6,5 @@ const ( SCHED_TRACE SPS SCHED_WINDOW - CLSFN_TASKDIST_OVERHEAD + CLSFN_TASKDISTR_OVERHEAD ) diff --git a/schedulers/base.go b/schedulers/base.go index 065a903..25f06a9 100644 --- a/schedulers/base.go +++ b/schedulers/base.go @@ -375,5 +375,5 @@ func (s *BaseScheduler) LogSchedPolicySwitch(name string, nextPolicy SchedPolicy func (s *BaseScheduler) LogClsfnAndTaskDistOverhead(overhead time.Duration) { // Logging the overhead in microseconds. - elekLog.ElektronLogger.WithFields(log.Fields{"Overhead in microseconds": fmt.Sprintf("%f", float64(overhead.Nanoseconds())/1000.0)}).Log(elekLogTypes.CLSFN_TASKDIST_OVERHEAD, log.InfoLevel, "") + elekLog.ElektronLogger.WithFields(log.Fields{"Overhead in microseconds": fmt.Sprintf("%f", float64(overhead.Nanoseconds())/1000.0)}).Log(elekLogTypes.CLSFN_TASKDISTR_OVERHEAD, log.InfoLevel, "") } -- 2.47.2 From 64ab443d25dd251ed70e8ebe51ef3320020bfe62 Mon Sep 17 00:00:00 2001 From: balandi1 Date: Wed, 4 Dec 2019 14:56:48 -0500 Subject: [PATCH 27/48] Minor code style fixes Removed the global logger instance and kept it in LoggerImpl struct. Changed access level for members of LoggerImpl. --- .../clsfnTaskDistOverheadLogger.go | 33 ++++++++++--------- elektronLogging/consoleLogger.go | 29 ++++++++-------- elektronLogging/logger.go | 15 ++++----- elektronLogging/loggerChain.go | 7 ++-- elektronLogging/pcpLogger.go | 33 ++++++++++--------- elektronLogging/schedPolicySwitchLogger.go | 33 ++++++++++--------- elektronLogging/schedTraceLogger.go | 33 ++++++++++--------- elektronLogging/schedWindowLogger.go | 33 ++++++++++--------- 8 files changed, 111 insertions(+), 105 deletions(-) diff --git a/elektronLogging/clsfnTaskDistOverheadLogger.go b/elektronLogging/clsfnTaskDistOverheadLogger.go index 6565211..c3f15cb 100644 --- a/elektronLogging/clsfnTaskDistOverheadLogger.go +++ b/elektronLogging/clsfnTaskDistOverheadLogger.go @@ -12,25 +12,26 @@ type ClsfnTaskDistrOverheadLogger struct { LoggerImpl } -func NewClsfnTaskDistrOverheadLogger(b *baseLogData, logType int, prefix string) *ClsfnTaskDistrOverheadLogger { +func NewClsfnTaskDistrOverheadLogger(b *baseLogData, logType int, prefix string, logger *log.Logger) *ClsfnTaskDistrOverheadLogger { cLog := &ClsfnTaskDistrOverheadLogger{} - cLog.Type = logType + cLog.logType = logType cLog.CreateLogFile(prefix) cLog.next = nil cLog.baseLogData = b + cLog.logger = logger return cLog } func (cLog ClsfnTaskDistrOverheadLogger) Log(logType int, level log.Level, message string) { - if cLog.Type == logType { + if cLog.logType == logType { if config.TaskDistrConfig.Enabled { - if cLog.AllowOnConsole { - logger.SetOutput(os.Stdout) - logger.WithFields(cLog.data).Log(level, message) + if cLog.allowOnConsole { + cLog.logger.SetOutput(os.Stdout) + cLog.logger.WithFields(cLog.data).Log(level, message) } - logger.SetOutput(cLog.LogFile) - logger.WithFields(cLog.data).Log(level, message) + cLog.logger.SetOutput(cLog.logFile) + cLog.logger.WithFields(cLog.data).Log(level, message) } } // Forwarding to next logger @@ -43,15 +44,15 @@ func (cLog ClsfnTaskDistrOverheadLogger) Log(logType int, level log.Level, messa } func (cLog ClsfnTaskDistrOverheadLogger) Logf(logType int, level log.Level, msgFmtString string, args ...interface{}) { - if cLog.Type == logType { + if cLog.logType == logType { if config.TaskDistrConfig.Enabled { - if cLog.AllowOnConsole { - logger.SetOutput(os.Stdout) - logger.WithFields(cLog.data).Logf(level, msgFmtString, args...) + if cLog.allowOnConsole { + cLog.logger.SetOutput(os.Stdout) + cLog.logger.WithFields(cLog.data).Logf(level, msgFmtString, args...) } - logger.SetOutput(cLog.LogFile) - logger.WithFields(cLog.data).Logf(level, msgFmtString, args...) + cLog.logger.SetOutput(cLog.logFile) + cLog.logger.WithFields(cLog.data).Logf(level, msgFmtString, args...) } } if cLog.next != nil { @@ -71,8 +72,8 @@ func (cLog *ClsfnTaskDistrOverheadLogger) CreateLogFile(prefix string) { if logFile, err := os.Create(filepath.Join(dirName, filename)); err != nil { log.Fatal("Unable to create logFile: ", err) } else { - cLog.LogFile = logFile - cLog.AllowOnConsole = config.TaskDistrConfig.AllowOnConsole + cLog.logFile = logFile + cLog.allowOnConsole = config.TaskDistrConfig.AllowOnConsole } } } diff --git a/elektronLogging/consoleLogger.go b/elektronLogging/consoleLogger.go index 64b20ea..9091283 100644 --- a/elektronLogging/consoleLogger.go +++ b/elektronLogging/consoleLogger.go @@ -12,22 +12,23 @@ type ConsoleLogger struct { LoggerImpl } -func NewConsoleLogger(b *baseLogData, logType int, prefix string) *ConsoleLogger { +func NewConsoleLogger(b *baseLogData, logType int, prefix string, logger *log.Logger) *ConsoleLogger { cLog := &ConsoleLogger{} - cLog.Type = logType + cLog.logType = logType cLog.CreateLogFile(prefix) cLog.next = nil cLog.baseLogData = b + cLog.logger = logger return cLog } func (cLog ConsoleLogger) Log(logType int, level log.Level, message string) { - if logType <= cLog.Type { + if logType <= cLog.logType { if config.ConsoleConfig.Enabled { - logger.SetOutput(os.Stdout) - logger.WithFields(cLog.data).Log(level, message) + cLog.logger.SetOutput(os.Stdout) + cLog.logger.WithFields(cLog.data).Log(level, message) - logger.SetOutput(cLog.LogFile) - logger.WithFields(cLog.data).Log(level, message) + cLog.logger.SetOutput(cLog.logFile) + cLog.logger.WithFields(cLog.data).Log(level, message) } } // Forwarding to next logger. @@ -40,13 +41,13 @@ func (cLog ConsoleLogger) Log(logType int, level log.Level, message string) { } func (cLog ConsoleLogger) Logf(logType int, level log.Level, msgFmtString string, args ...interface{}) { - if logType <= cLog.Type { + if logType <= cLog.logType { if config.ConsoleConfig.Enabled { - logger.SetOutput(os.Stdout) - logger.WithFields(cLog.data).Logf(level, msgFmtString, args...) + cLog.logger.SetOutput(os.Stdout) + cLog.logger.WithFields(cLog.data).Logf(level, msgFmtString, args...) - logger.SetOutput(cLog.LogFile) - logger.WithFields(cLog.data).Logf(level, msgFmtString, args...) + cLog.logger.SetOutput(cLog.logFile) + cLog.logger.WithFields(cLog.data).Logf(level, msgFmtString, args...) } } if cLog.next != nil { @@ -66,8 +67,8 @@ func (cLog *ConsoleLogger) CreateLogFile(prefix string) { if logFile, err := os.Create(filepath.Join(dirName, filename)); err != nil { log.Fatal("Unable to create logFile: ", err) } else { - cLog.LogFile = logFile - cLog.AllowOnConsole = config.ConsoleConfig.AllowOnConsole + cLog.logFile = logFile + cLog.allowOnConsole = config.ConsoleConfig.AllowOnConsole } } } diff --git a/elektronLogging/logger.go b/elektronLogging/logger.go index bdf07ea..7bcf234 100644 --- a/elektronLogging/logger.go +++ b/elektronLogging/logger.go @@ -10,7 +10,6 @@ import ( ) var config LoggerConfig -var logger *log.Logger var formatter ElektronFormatter var ElektronLogger *LoggerImpl var logDir logDirectory @@ -28,7 +27,7 @@ func BuildLogger(prefix string, logConfigFilename string) { // Instantiate the logrus instance. prefix = strings.Join([]string{prefix, formattedStartTime}, "_") - logger = &log.Logger{ + logger := &log.Logger{ Out: os.Stderr, Level: log.DebugLevel, Formatter: &formatter, @@ -37,12 +36,12 @@ func BuildLogger(prefix string, logConfigFilename string) { // Create a chain of loggers. b := &baseLogData{data: log.Fields{}} head := &LoggerImpl{baseLogData: b} - cLog := NewConsoleLogger(b, CONSOLE, prefix) - pLog := NewPCPLogger(b, PCP, prefix) - schedTraceLog := NewSchedTraceLogger(b, SCHED_TRACE, prefix) - spsLog := NewSchedPolicySwitchLogger(b, SPS, prefix) - schedWindowLog := NewSchedWindowLogger(b, SCHED_WINDOW, prefix) - tskDistLog := NewClsfnTaskDistrOverheadLogger(b, CLSFN_TASKDISTR_OVERHEAD, prefix) + cLog := NewConsoleLogger(b, CONSOLE, prefix, logger) + pLog := NewPCPLogger(b, PCP, prefix, logger) + schedTraceLog := NewSchedTraceLogger(b, SCHED_TRACE, prefix, logger) + spsLog := NewSchedPolicySwitchLogger(b, SPS, prefix, logger) + schedWindowLog := NewSchedWindowLogger(b, SCHED_WINDOW, prefix, logger) + tskDistLog := NewClsfnTaskDistrOverheadLogger(b, CLSFN_TASKDISTR_OVERHEAD, prefix, logger) head.SetNext(cLog) cLog.SetNext(pLog) diff --git a/elektronLogging/loggerChain.go b/elektronLogging/loggerChain.go index bbf41fc..d4f6d38 100644 --- a/elektronLogging/loggerChain.go +++ b/elektronLogging/loggerChain.go @@ -16,10 +16,11 @@ type baseLogData struct { } type LoggerImpl struct { *baseLogData - Type int - AllowOnConsole bool - LogFile *os.File + logType int + allowOnConsole bool + logFile *os.File next Logger + logger *log.Logger } func (l *LoggerImpl) WithFields(logData log.Fields) *LoggerImpl { diff --git a/elektronLogging/pcpLogger.go b/elektronLogging/pcpLogger.go index 192eb88..c7a498f 100644 --- a/elektronLogging/pcpLogger.go +++ b/elektronLogging/pcpLogger.go @@ -12,25 +12,26 @@ type PCPLogger struct { LoggerImpl } -func NewPCPLogger(b *baseLogData, logType int, prefix string) *PCPLogger { +func NewPCPLogger(b *baseLogData, logType int, prefix string, logger *log.Logger) *PCPLogger { pLog := &PCPLogger{} - pLog.Type = logType + pLog.logType = logType pLog.CreateLogFile(prefix) pLog.next = nil pLog.baseLogData = b + pLog.logger = logger return pLog } func (pLog PCPLogger) Log(logType int, level log.Level, message string) { - if pLog.Type == logType { + if pLog.logType == logType { if config.PCPConfig.Enabled { - if pLog.AllowOnConsole { - logger.SetOutput(os.Stdout) - logger.WithFields(pLog.data).Log(level, message) + if pLog.allowOnConsole { + pLog.logger.SetOutput(os.Stdout) + pLog.logger.WithFields(pLog.data).Log(level, message) } - logger.SetOutput(pLog.LogFile) - logger.WithFields(pLog.data).Log(level, message) + pLog.logger.SetOutput(pLog.logFile) + pLog.logger.WithFields(pLog.data).Log(level, message) } } if pLog.next != nil { @@ -42,15 +43,15 @@ func (pLog PCPLogger) Log(logType int, level log.Level, message string) { } func (pLog PCPLogger) Logf(logType int, level log.Level, msgFmtString string, args ...interface{}) { - if pLog.Type == logType { + if pLog.logType == logType { if config.PCPConfig.Enabled { - if pLog.AllowOnConsole { - logger.SetOutput(os.Stdout) - logger.WithFields(pLog.data).Logf(level, msgFmtString, args...) + if pLog.allowOnConsole { + pLog.logger.SetOutput(os.Stdout) + pLog.logger.WithFields(pLog.data).Logf(level, msgFmtString, args...) } - logger.SetOutput(pLog.LogFile) - logger.WithFields(pLog.data).Logf(level, msgFmtString, args...) + pLog.logger.SetOutput(pLog.logFile) + pLog.logger.WithFields(pLog.data).Logf(level, msgFmtString, args...) } } // Forwarding to next logger @@ -70,8 +71,8 @@ func (pLog *PCPLogger) CreateLogFile(prefix string) { if logFile, err := os.Create(filepath.Join(dirName, filename)); err != nil { log.Fatal("Unable to create logFile: ", err) } else { - pLog.LogFile = logFile - pLog.AllowOnConsole = config.PCPConfig.AllowOnConsole + pLog.logFile = logFile + pLog.allowOnConsole = config.PCPConfig.AllowOnConsole } } } diff --git a/elektronLogging/schedPolicySwitchLogger.go b/elektronLogging/schedPolicySwitchLogger.go index 8d85d2f..457889a 100644 --- a/elektronLogging/schedPolicySwitchLogger.go +++ b/elektronLogging/schedPolicySwitchLogger.go @@ -12,25 +12,26 @@ type SchedPolicySwitchLogger struct { LoggerImpl } -func NewSchedPolicySwitchLogger(b *baseLogData, logType int, prefix string) *SchedPolicySwitchLogger { +func NewSchedPolicySwitchLogger(b *baseLogData, logType int, prefix string, logger *log.Logger) *SchedPolicySwitchLogger { sLog := &SchedPolicySwitchLogger{} - sLog.Type = logType + sLog.logType = logType sLog.CreateLogFile(prefix) sLog.next = nil sLog.baseLogData = b + sLog.logger = logger return sLog } func (sLog SchedPolicySwitchLogger) Log(logType int, level log.Level, message string) { - if sLog.Type == logType { + if sLog.logType == logType { if config.SPSConfig.Enabled { - if sLog.AllowOnConsole { - logger.SetOutput(os.Stdout) - logger.WithFields(sLog.data).Log(level, message) + if sLog.allowOnConsole { + sLog.logger.SetOutput(os.Stdout) + sLog.logger.WithFields(sLog.data).Log(level, message) } - logger.SetOutput(sLog.LogFile) - logger.WithFields(sLog.data).Log(level, message) + sLog.logger.SetOutput(sLog.logFile) + sLog.logger.WithFields(sLog.data).Log(level, message) } } if sLog.next != nil { @@ -42,15 +43,15 @@ func (sLog SchedPolicySwitchLogger) Log(logType int, level log.Level, message st } func (sLog SchedPolicySwitchLogger) Logf(logType int, level log.Level, msgFmtString string, args ...interface{}) { - if sLog.Type == logType { + if sLog.logType == logType { if config.SPSConfig.Enabled { - if sLog.AllowOnConsole { - logger.SetOutput(os.Stdout) - logger.WithFields(sLog.data).Logf(level, msgFmtString, args...) + if sLog.allowOnConsole { + sLog.logger.SetOutput(os.Stdout) + sLog.logger.WithFields(sLog.data).Logf(level, msgFmtString, args...) } - logger.SetOutput(sLog.LogFile) - logger.WithFields(sLog.data).Logf(level, msgFmtString, args...) + sLog.logger.SetOutput(sLog.logFile) + sLog.logger.WithFields(sLog.data).Logf(level, msgFmtString, args...) } } // Forwarding to next logger @@ -70,8 +71,8 @@ func (sLog *SchedPolicySwitchLogger) CreateLogFile(prefix string) { if logFile, err := os.Create(filepath.Join(dirName, filename)); err != nil { log.Fatal("Unable to create logFile: ", err) } else { - sLog.LogFile = logFile - sLog.AllowOnConsole = config.SPSConfig.AllowOnConsole + sLog.logFile = logFile + sLog.allowOnConsole = config.SPSConfig.AllowOnConsole } } } diff --git a/elektronLogging/schedTraceLogger.go b/elektronLogging/schedTraceLogger.go index 838eff7..7ac1167 100644 --- a/elektronLogging/schedTraceLogger.go +++ b/elektronLogging/schedTraceLogger.go @@ -12,25 +12,26 @@ type SchedTraceLogger struct { LoggerImpl } -func NewSchedTraceLogger(b *baseLogData, logType int, prefix string) *SchedTraceLogger { +func NewSchedTraceLogger(b *baseLogData, logType int, prefix string, logger *log.Logger) *SchedTraceLogger { sLog := &SchedTraceLogger{} - sLog.Type = logType + sLog.logType = logType sLog.CreateLogFile(prefix) sLog.next = nil sLog.baseLogData = b + sLog.logger = logger return sLog } func (sLog SchedTraceLogger) Log(logType int, level log.Level, message string) { - if sLog.Type == logType { + if sLog.logType == logType { if config.SchedTraceConfig.Enabled { - if sLog.AllowOnConsole { - logger.SetOutput(os.Stdout) - logger.WithFields(sLog.data).Log(level, message) + if sLog.allowOnConsole { + sLog.logger.SetOutput(os.Stdout) + sLog.logger.WithFields(sLog.data).Log(level, message) } - logger.SetOutput(sLog.LogFile) - logger.WithFields(sLog.data).Log(level, message) + sLog.logger.SetOutput(sLog.logFile) + sLog.logger.WithFields(sLog.data).Log(level, message) } } if sLog.next != nil { @@ -42,15 +43,15 @@ func (sLog SchedTraceLogger) Log(logType int, level log.Level, message string) { } func (sLog SchedTraceLogger) Logf(logType int, level log.Level, msgFmtString string, args ...interface{}) { - if sLog.Type == logType { + if sLog.logType == logType { if config.SchedTraceConfig.Enabled { - if sLog.AllowOnConsole { - logger.SetOutput(os.Stdout) - logger.WithFields(sLog.data).Logf(level, msgFmtString, args...) + if sLog.allowOnConsole { + sLog.logger.SetOutput(os.Stdout) + sLog.logger.WithFields(sLog.data).Logf(level, msgFmtString, args...) } - logger.SetOutput(sLog.LogFile) - logger.WithFields(sLog.data).Logf(level, msgFmtString, args...) + sLog.logger.SetOutput(sLog.logFile) + sLog.logger.WithFields(sLog.data).Logf(level, msgFmtString, args...) } } // Forwarding to next logger @@ -70,8 +71,8 @@ func (sLog *SchedTraceLogger) CreateLogFile(prefix string) { if logFile, err := os.Create(filepath.Join(dirName, filename)); err != nil { log.Fatal("Unable to create logFile: ", err) } else { - sLog.LogFile = logFile - sLog.AllowOnConsole = config.SchedTraceConfig.AllowOnConsole + sLog.logFile = logFile + sLog.allowOnConsole = config.SchedTraceConfig.AllowOnConsole } } } diff --git a/elektronLogging/schedWindowLogger.go b/elektronLogging/schedWindowLogger.go index e8d6958..ce79483 100644 --- a/elektronLogging/schedWindowLogger.go +++ b/elektronLogging/schedWindowLogger.go @@ -12,25 +12,26 @@ type SchedWindowLogger struct { LoggerImpl } -func NewSchedWindowLogger(b *baseLogData, logType int, prefix string) *SchedWindowLogger { +func NewSchedWindowLogger(b *baseLogData, logType int, prefix string, logger *log.Logger) *SchedWindowLogger { sLog := &SchedWindowLogger{} - sLog.Type = logType + sLog.logType = logType sLog.CreateLogFile(prefix) sLog.next = nil sLog.baseLogData = b + sLog.logger = logger return sLog } func (sLog SchedWindowLogger) Log(logType int, level log.Level, message string) { - if sLog.Type == logType { + if sLog.logType == logType { if config.SchedWindowConfig.Enabled { - if sLog.AllowOnConsole { - logger.SetOutput(os.Stdout) - logger.WithFields(sLog.data).Log(level, message) + if sLog.allowOnConsole { + sLog.logger.SetOutput(os.Stdout) + sLog.logger.WithFields(sLog.data).Log(level, message) } - logger.SetOutput(sLog.LogFile) - logger.WithFields(sLog.data).Log(level, message) + sLog.logger.SetOutput(sLog.logFile) + sLog.logger.WithFields(sLog.data).Log(level, message) } } // Forwarding to next logger @@ -43,15 +44,15 @@ func (sLog SchedWindowLogger) Log(logType int, level log.Level, message string) } func (sLog SchedWindowLogger) Logf(logType int, level log.Level, msgFmtString string, args ...interface{}) { - if sLog.Type == logType { + if sLog.logType == logType { if config.SchedWindowConfig.Enabled { - if sLog.AllowOnConsole { - logger.SetOutput(os.Stdout) - logger.WithFields(sLog.data).Logf(level, msgFmtString, args...) + if sLog.allowOnConsole { + sLog.logger.SetOutput(os.Stdout) + sLog.logger.WithFields(sLog.data).Logf(level, msgFmtString, args...) } - logger.SetOutput(sLog.LogFile) - logger.WithFields(sLog.data).Logf(level, msgFmtString, args...) + sLog.logger.SetOutput(sLog.logFile) + sLog.logger.WithFields(sLog.data).Logf(level, msgFmtString, args...) } } if sLog.next != nil { @@ -70,8 +71,8 @@ func (sLog *SchedWindowLogger) CreateLogFile(prefix string) { if logFile, err := os.Create(filepath.Join(dirName, filename)); err != nil { log.Fatal("Unable to create logFile: ", err) } else { - sLog.LogFile = logFile - sLog.AllowOnConsole = config.SchedWindowConfig.AllowOnConsole + sLog.logFile = logFile + sLog.allowOnConsole = config.SchedWindowConfig.AllowOnConsole } } } -- 2.47.2 From bd8ddd18355852ff8a2cdaa9b958794013edcac2 Mon Sep 17 00:00:00 2001 From: balandi1 Date: Thu, 5 Dec 2019 15:01:11 -0500 Subject: [PATCH 28/48] Refactored Code Moved the 'logDir' and 'logger' global variables into 'loggerImpl' struct Renamed struct names and interface name --- .../clsfnTaskDistOverheadLogger.go | 12 ++++---- elektronLogging/consoleLogger.go | 17 ++++++----- elektronLogging/logger.go | 30 +++++++++---------- elektronLogging/loggerChain.go | 23 +++++++------- elektronLogging/pcpLogger.go | 12 ++++---- elektronLogging/schedPolicySwitchLogger.go | 12 ++++---- elektronLogging/schedTraceLogger.go | 12 ++++---- elektronLogging/schedWindowLogger.go | 12 ++++---- 8 files changed, 72 insertions(+), 58 deletions(-) diff --git a/elektronLogging/clsfnTaskDistOverheadLogger.go b/elektronLogging/clsfnTaskDistOverheadLogger.go index c3f15cb..bd13429 100644 --- a/elektronLogging/clsfnTaskDistOverheadLogger.go +++ b/elektronLogging/clsfnTaskDistOverheadLogger.go @@ -9,16 +9,18 @@ import ( ) type ClsfnTaskDistrOverheadLogger struct { - LoggerImpl + loggerImpl } -func NewClsfnTaskDistrOverheadLogger(b *baseLogData, logType int, prefix string, logger *log.Logger) *ClsfnTaskDistrOverheadLogger { +func NewClsfnTaskDistrOverheadLogger(b *baseLogData, logType int, prefix string, + logger *log.Logger, logDir *logDirectory) *ClsfnTaskDistrOverheadLogger { cLog := &ClsfnTaskDistrOverheadLogger{} cLog.logType = logType - cLog.CreateLogFile(prefix) + cLog.logDir = logDir cLog.next = nil cLog.baseLogData = b cLog.logger = logger + cLog.createLogFile(prefix) return cLog } @@ -63,11 +65,11 @@ func (cLog ClsfnTaskDistrOverheadLogger) Logf(logType int, level log.Level, msgF } } -func (cLog *ClsfnTaskDistrOverheadLogger) CreateLogFile(prefix string) { +func (cLog *ClsfnTaskDistrOverheadLogger) createLogFile(prefix string) { if config.TaskDistrConfig.Enabled { filename := strings.Join([]string{prefix, config.TaskDistrConfig.FilenameExtension}, "") - dirName := logDir.getDirName() + dirName := cLog.logDir.getDirName() if dirName != "" { if logFile, err := os.Create(filepath.Join(dirName, filename)); err != nil { log.Fatal("Unable to create logFile: ", err) diff --git a/elektronLogging/consoleLogger.go b/elektronLogging/consoleLogger.go index 9091283..052fc30 100644 --- a/elektronLogging/consoleLogger.go +++ b/elektronLogging/consoleLogger.go @@ -1,24 +1,26 @@ package elektronLogging import ( + "fmt" + log "github.com/sirupsen/logrus" "os" "path/filepath" "strings" - - log "github.com/sirupsen/logrus" ) type ConsoleLogger struct { - LoggerImpl + loggerImpl } -func NewConsoleLogger(b *baseLogData, logType int, prefix string, logger *log.Logger) *ConsoleLogger { +func NewConsoleLogger(b *baseLogData, logType int, prefix string, + logger *log.Logger, logDir *logDirectory) *ConsoleLogger { cLog := &ConsoleLogger{} cLog.logType = logType - cLog.CreateLogFile(prefix) + cLog.logDir = logDir cLog.next = nil cLog.baseLogData = b cLog.logger = logger + cLog.createLogFile(prefix) return cLog } func (cLog ConsoleLogger) Log(logType int, level log.Level, message string) { @@ -58,11 +60,12 @@ func (cLog ConsoleLogger) Logf(logType int, level log.Level, msgFmtString string } } -func (cLog *ConsoleLogger) CreateLogFile(prefix string) { +func (cLog *ConsoleLogger) createLogFile(prefix string) { // Create log file for the type if it is enabled. if config.ConsoleConfig.Enabled { filename := strings.Join([]string{prefix, config.ConsoleConfig.FilenameExtension}, "") - dirName := logDir.getDirName() + dirName := cLog.logDir.getDirName() + fmt.Println(dirName) if dirName != "" { if logFile, err := os.Create(filepath.Join(dirName, filename)); err != nil { log.Fatal("Unable to create logFile: ", err) diff --git a/elektronLogging/logger.go b/elektronLogging/logger.go index 7bcf234..90c2b87 100644 --- a/elektronLogging/logger.go +++ b/elektronLogging/logger.go @@ -11,8 +11,7 @@ import ( var config LoggerConfig var formatter ElektronFormatter -var ElektronLogger *LoggerImpl -var logDir logDirectory +var ElektronLogger *loggerImpl func BuildLogger(prefix string, logConfigFilename string) { @@ -23,6 +22,7 @@ func BuildLogger(prefix string, logConfigFilename string) { startTime := time.Now() formatter.TimestampFormat = "2006-01-02 15:04:05" formattedStartTime := startTime.Format("20060102150405") + logDir := &logDirectory{} logDir.createLogDir(prefix, startTime) // Instantiate the logrus instance. @@ -35,20 +35,20 @@ func BuildLogger(prefix string, logConfigFilename string) { // Create a chain of loggers. b := &baseLogData{data: log.Fields{}} - head := &LoggerImpl{baseLogData: b} - cLog := NewConsoleLogger(b, CONSOLE, prefix, logger) - pLog := NewPCPLogger(b, PCP, prefix, logger) - schedTraceLog := NewSchedTraceLogger(b, SCHED_TRACE, prefix, logger) - spsLog := NewSchedPolicySwitchLogger(b, SPS, prefix, logger) - schedWindowLog := NewSchedWindowLogger(b, SCHED_WINDOW, prefix, logger) - tskDistLog := NewClsfnTaskDistrOverheadLogger(b, CLSFN_TASKDISTR_OVERHEAD, prefix, logger) + head := &loggerImpl{baseLogData: b} + cLog := NewConsoleLogger(b, CONSOLE, prefix, logger, logDir) + pLog := NewPCPLogger(b, PCP, prefix, logger, logDir) + schedTraceLog := NewSchedTraceLogger(b, SCHED_TRACE, prefix, logger, logDir) + spsLog := NewSchedPolicySwitchLogger(b, SPS, prefix, logger, logDir) + schedWindowLog := NewSchedWindowLogger(b, SCHED_WINDOW, prefix, logger, logDir) + tskDistLog := NewClsfnTaskDistrOverheadLogger(b, CLSFN_TASKDISTR_OVERHEAD, prefix, logger, logDir) - head.SetNext(cLog) - cLog.SetNext(pLog) - pLog.SetNext(schedTraceLog) - schedTraceLog.SetNext(spsLog) - spsLog.SetNext(schedWindowLog) - schedWindowLog.SetNext(tskDistLog) + head.setNext(cLog) + cLog.setNext(pLog) + pLog.setNext(schedTraceLog) + schedTraceLog.setNext(spsLog) + spsLog.setNext(schedWindowLog) + schedWindowLog.setNext(tskDistLog) ElektronLogger = head } diff --git a/elektronLogging/loggerChain.go b/elektronLogging/loggerChain.go index d4f6d38..a771257 100644 --- a/elektronLogging/loggerChain.go +++ b/elektronLogging/loggerChain.go @@ -5,51 +5,52 @@ import ( "os" ) -type Logger interface { - SetNext(logType Logger) +type logInterface interface { + setNext(logType logInterface) Log(logType int, level log.Level, message string) Logf(logType int, level log.Level, msgFmtString string, args ...interface{}) - CreateLogFile(prefix string) + createLogFile(prefix string) } type baseLogData struct { data log.Fields } -type LoggerImpl struct { +type loggerImpl struct { *baseLogData logType int allowOnConsole bool logFile *os.File - next Logger + next logInterface logger *log.Logger + logDir *logDirectory } -func (l *LoggerImpl) WithFields(logData log.Fields) *LoggerImpl { +func (l *loggerImpl) WithFields(logData log.Fields) *loggerImpl { l.data = logData return l } -func (l *LoggerImpl) WithField(key string, value string) *LoggerImpl { +func (l *loggerImpl) WithField(key string, value string) *loggerImpl { l.data[key] = value return l } -func (l *LoggerImpl) SetNext(logType Logger) { +func (l *loggerImpl) setNext(logType logInterface) { l.next = logType } -func (l LoggerImpl) Log(logType int, level log.Level, message string) { +func (l loggerImpl) Log(logType int, level log.Level, message string) { if l.next != nil { l.next.Log(logType, level, message) } } -func (l LoggerImpl) Logf(logType int, level log.Level, msgFmtString string, args ...interface{}) { +func (l loggerImpl) Logf(logType int, level log.Level, msgFmtString string, args ...interface{}) { if l.next != nil { l.next.Logf(logType, level, msgFmtString, args...) } } -func (l *LoggerImpl) resetFields() { +func (l *loggerImpl) resetFields() { l.data = nil l.data = log.Fields{} } diff --git a/elektronLogging/pcpLogger.go b/elektronLogging/pcpLogger.go index c7a498f..7dc8fd1 100644 --- a/elektronLogging/pcpLogger.go +++ b/elektronLogging/pcpLogger.go @@ -9,16 +9,18 @@ import ( ) type PCPLogger struct { - LoggerImpl + loggerImpl } -func NewPCPLogger(b *baseLogData, logType int, prefix string, logger *log.Logger) *PCPLogger { +func NewPCPLogger(b *baseLogData, logType int, prefix string, + logger *log.Logger, logDir *logDirectory) *PCPLogger { pLog := &PCPLogger{} pLog.logType = logType - pLog.CreateLogFile(prefix) + pLog.logDir = logDir pLog.next = nil pLog.baseLogData = b pLog.logger = logger + pLog.createLogFile(prefix) return pLog } @@ -63,10 +65,10 @@ func (pLog PCPLogger) Logf(logType int, level log.Level, msgFmtString string, ar } } -func (pLog *PCPLogger) CreateLogFile(prefix string) { +func (pLog *PCPLogger) createLogFile(prefix string) { if config.PCPConfig.Enabled { filename := strings.Join([]string{prefix, config.PCPConfig.FilenameExtension}, "") - dirName := logDir.getDirName() + dirName := pLog.logDir.getDirName() if dirName != "" { if logFile, err := os.Create(filepath.Join(dirName, filename)); err != nil { log.Fatal("Unable to create logFile: ", err) diff --git a/elektronLogging/schedPolicySwitchLogger.go b/elektronLogging/schedPolicySwitchLogger.go index 457889a..c3d555b 100644 --- a/elektronLogging/schedPolicySwitchLogger.go +++ b/elektronLogging/schedPolicySwitchLogger.go @@ -9,16 +9,18 @@ import ( ) type SchedPolicySwitchLogger struct { - LoggerImpl + loggerImpl } -func NewSchedPolicySwitchLogger(b *baseLogData, logType int, prefix string, logger *log.Logger) *SchedPolicySwitchLogger { +func NewSchedPolicySwitchLogger(b *baseLogData, logType int, prefix string, + logger *log.Logger, logDir *logDirectory) *SchedPolicySwitchLogger { sLog := &SchedPolicySwitchLogger{} sLog.logType = logType - sLog.CreateLogFile(prefix) + sLog.logDir = logDir sLog.next = nil sLog.baseLogData = b sLog.logger = logger + sLog.createLogFile(prefix) return sLog } @@ -63,10 +65,10 @@ func (sLog SchedPolicySwitchLogger) Logf(logType int, level log.Level, msgFmtStr } } -func (sLog *SchedPolicySwitchLogger) CreateLogFile(prefix string) { +func (sLog *SchedPolicySwitchLogger) createLogFile(prefix string) { if config.SPSConfig.Enabled { filename := strings.Join([]string{prefix, config.SPSConfig.FilenameExtension}, "") - dirName := logDir.getDirName() + dirName := sLog.logDir.getDirName() if dirName != "" { if logFile, err := os.Create(filepath.Join(dirName, filename)); err != nil { log.Fatal("Unable to create logFile: ", err) diff --git a/elektronLogging/schedTraceLogger.go b/elektronLogging/schedTraceLogger.go index 7ac1167..9174e80 100644 --- a/elektronLogging/schedTraceLogger.go +++ b/elektronLogging/schedTraceLogger.go @@ -9,16 +9,18 @@ import ( ) type SchedTraceLogger struct { - LoggerImpl + loggerImpl } -func NewSchedTraceLogger(b *baseLogData, logType int, prefix string, logger *log.Logger) *SchedTraceLogger { +func NewSchedTraceLogger(b *baseLogData, logType int, prefix string, + logger *log.Logger, logDir *logDirectory) *SchedTraceLogger { sLog := &SchedTraceLogger{} sLog.logType = logType - sLog.CreateLogFile(prefix) + sLog.logDir = logDir sLog.next = nil sLog.baseLogData = b sLog.logger = logger + sLog.createLogFile(prefix) return sLog } @@ -63,10 +65,10 @@ func (sLog SchedTraceLogger) Logf(logType int, level log.Level, msgFmtString str } } -func (sLog *SchedTraceLogger) CreateLogFile(prefix string) { +func (sLog *SchedTraceLogger) createLogFile(prefix string) { if config.SchedTraceConfig.Enabled { filename := strings.Join([]string{prefix, config.SchedTraceConfig.FilenameExtension}, "") - dirName := logDir.getDirName() + dirName := sLog.logDir.getDirName() if dirName != "" { if logFile, err := os.Create(filepath.Join(dirName, filename)); err != nil { log.Fatal("Unable to create logFile: ", err) diff --git a/elektronLogging/schedWindowLogger.go b/elektronLogging/schedWindowLogger.go index ce79483..75c6a50 100644 --- a/elektronLogging/schedWindowLogger.go +++ b/elektronLogging/schedWindowLogger.go @@ -9,16 +9,18 @@ import ( ) type SchedWindowLogger struct { - LoggerImpl + loggerImpl } -func NewSchedWindowLogger(b *baseLogData, logType int, prefix string, logger *log.Logger) *SchedWindowLogger { +func NewSchedWindowLogger(b *baseLogData, logType int, prefix string, + logger *log.Logger, logDir *logDirectory) *SchedWindowLogger { sLog := &SchedWindowLogger{} sLog.logType = logType - sLog.CreateLogFile(prefix) + sLog.logDir = logDir sLog.next = nil sLog.baseLogData = b sLog.logger = logger + sLog.createLogFile(prefix) return sLog } @@ -63,10 +65,10 @@ func (sLog SchedWindowLogger) Logf(logType int, level log.Level, msgFmtString st } } -func (sLog *SchedWindowLogger) CreateLogFile(prefix string) { +func (sLog *SchedWindowLogger) createLogFile(prefix string) { if config.SchedWindowConfig.Enabled { filename := strings.Join([]string{prefix, config.SchedWindowConfig.FilenameExtension}, "") - dirName := logDir.getDirName() + dirName := sLog.logDir.getDirName() if dirName != "" { if logFile, err := os.Create(filepath.Join(dirName, filename)); err != nil { log.Fatal("Unable to create logFile: ", err) -- 2.47.2 From 3d201bf4376154e8aa462b41438af9e76a937269 Mon Sep 17 00:00:00 2001 From: Pradyumna Kaushik Date: Thu, 5 Dec 2019 17:38:56 -0500 Subject: [PATCH 29/48] refactored elektronLogging to logging --- def/taskUtils.go | 4 ++-- {elektronLogging => logging}/ElektronFormatter.go | 2 +- {elektronLogging => logging}/clsfnTaskDistOverheadLogger.go | 2 +- {elektronLogging => logging}/consoleLogger.go | 2 +- {elektronLogging => logging}/createLogDir.go | 2 +- {elektronLogging => logging}/logger.go | 4 ++-- {elektronLogging => logging}/loggerChain.go | 2 +- {elektronLogging => logging}/loggerConfig.go | 2 +- {elektronLogging => logging}/pcpLogger.go | 2 +- {elektronLogging => logging}/schedPolicySwitchLogger.go | 2 +- {elektronLogging => logging}/schedTraceLogger.go | 2 +- {elektronLogging => logging}/schedWindowLogger.go | 2 +- {elektronLogging => logging}/types/types.go | 0 pcp/pcp.go | 4 ++-- powerCap/extrema.go | 4 ++-- powerCap/progressiveExtrema.go | 4 ++-- scheduler.go | 4 ++-- schedulers/base.go | 4 ++-- schedulers/helpers.go | 4 ++-- schedulers/schedPolicy.go | 4 ++-- utilities/offerUtils/offerUtils.go | 4 ++-- utilities/schedUtils/schedUtils.go | 4 ++-- 22 files changed, 32 insertions(+), 32 deletions(-) rename {elektronLogging => logging}/ElektronFormatter.go (96%) rename {elektronLogging => logging}/clsfnTaskDistOverheadLogger.go (98%) rename {elektronLogging => logging}/consoleLogger.go (98%) rename {elektronLogging => logging}/createLogDir.go (97%) rename {elektronLogging => logging}/logger.go (95%) rename {elektronLogging => logging}/loggerChain.go (98%) rename {elektronLogging => logging}/loggerConfig.go (98%) rename {elektronLogging => logging}/pcpLogger.go (98%) rename {elektronLogging => logging}/schedPolicySwitchLogger.go (98%) rename {elektronLogging => logging}/schedTraceLogger.go (98%) rename {elektronLogging => logging}/schedWindowLogger.go (98%) rename {elektronLogging => logging}/types/types.go (100%) diff --git a/def/taskUtils.go b/def/taskUtils.go index 0d203eb..1822779 100644 --- a/def/taskUtils.go +++ b/def/taskUtils.go @@ -26,8 +26,8 @@ import ( "github.com/mash/gokmeans" "github.com/montanaflynn/stats" log "github.com/sirupsen/logrus" - elekLog "github.com/spdfg/elektron/elektronLogging" - elekLogTypes "github.com/spdfg/elektron/elektronLogging/types" + elekLog "github.com/spdfg/elektron/logging" + elekLogTypes "github.com/spdfg/elektron/logging/types" ) // Information about a cluster of tasks. diff --git a/elektronLogging/ElektronFormatter.go b/logging/ElektronFormatter.go similarity index 96% rename from elektronLogging/ElektronFormatter.go rename to logging/ElektronFormatter.go index a0b1ff0..1ea7ea0 100644 --- a/elektronLogging/ElektronFormatter.go +++ b/logging/ElektronFormatter.go @@ -1,4 +1,4 @@ -package elektronLogging +package logging import ( "bytes" diff --git a/elektronLogging/clsfnTaskDistOverheadLogger.go b/logging/clsfnTaskDistOverheadLogger.go similarity index 98% rename from elektronLogging/clsfnTaskDistOverheadLogger.go rename to logging/clsfnTaskDistOverheadLogger.go index bd13429..b965609 100644 --- a/elektronLogging/clsfnTaskDistOverheadLogger.go +++ b/logging/clsfnTaskDistOverheadLogger.go @@ -1,4 +1,4 @@ -package elektronLogging +package logging import ( "os" diff --git a/elektronLogging/consoleLogger.go b/logging/consoleLogger.go similarity index 98% rename from elektronLogging/consoleLogger.go rename to logging/consoleLogger.go index 052fc30..d1a115d 100644 --- a/elektronLogging/consoleLogger.go +++ b/logging/consoleLogger.go @@ -1,4 +1,4 @@ -package elektronLogging +package logging import ( "fmt" diff --git a/elektronLogging/createLogDir.go b/logging/createLogDir.go similarity index 97% rename from elektronLogging/createLogDir.go rename to logging/createLogDir.go index b5666d9..e6730f4 100644 --- a/elektronLogging/createLogDir.go +++ b/logging/createLogDir.go @@ -1,4 +1,4 @@ -package elektronLogging +package logging import ( "os" diff --git a/elektronLogging/logger.go b/logging/logger.go similarity index 95% rename from elektronLogging/logger.go rename to logging/logger.go index 90c2b87..b271c44 100644 --- a/elektronLogging/logger.go +++ b/logging/logger.go @@ -1,4 +1,4 @@ -package elektronLogging +package logging import ( "os" @@ -6,7 +6,7 @@ import ( "time" log "github.com/sirupsen/logrus" - . "github.com/spdfg/elektron/elektronLogging/types" + . "github.com/spdfg/elektron/logging/types" ) var config LoggerConfig diff --git a/elektronLogging/loggerChain.go b/logging/loggerChain.go similarity index 98% rename from elektronLogging/loggerChain.go rename to logging/loggerChain.go index a771257..ff9792e 100644 --- a/elektronLogging/loggerChain.go +++ b/logging/loggerChain.go @@ -1,4 +1,4 @@ -package elektronLogging +package logging import ( log "github.com/sirupsen/logrus" diff --git a/elektronLogging/loggerConfig.go b/logging/loggerConfig.go similarity index 98% rename from elektronLogging/loggerConfig.go rename to logging/loggerConfig.go index 06ac247..a0ae5de 100644 --- a/elektronLogging/loggerConfig.go +++ b/logging/loggerConfig.go @@ -1,4 +1,4 @@ -package elektronLogging +package logging import ( log "github.com/sirupsen/logrus" diff --git a/elektronLogging/pcpLogger.go b/logging/pcpLogger.go similarity index 98% rename from elektronLogging/pcpLogger.go rename to logging/pcpLogger.go index 7dc8fd1..d9a91f8 100644 --- a/elektronLogging/pcpLogger.go +++ b/logging/pcpLogger.go @@ -1,4 +1,4 @@ -package elektronLogging +package logging import ( "os" diff --git a/elektronLogging/schedPolicySwitchLogger.go b/logging/schedPolicySwitchLogger.go similarity index 98% rename from elektronLogging/schedPolicySwitchLogger.go rename to logging/schedPolicySwitchLogger.go index c3d555b..437c300 100644 --- a/elektronLogging/schedPolicySwitchLogger.go +++ b/logging/schedPolicySwitchLogger.go @@ -1,4 +1,4 @@ -package elektronLogging +package logging import ( "os" diff --git a/elektronLogging/schedTraceLogger.go b/logging/schedTraceLogger.go similarity index 98% rename from elektronLogging/schedTraceLogger.go rename to logging/schedTraceLogger.go index 9174e80..ccbad63 100644 --- a/elektronLogging/schedTraceLogger.go +++ b/logging/schedTraceLogger.go @@ -1,4 +1,4 @@ -package elektronLogging +package logging import ( "os" diff --git a/elektronLogging/schedWindowLogger.go b/logging/schedWindowLogger.go similarity index 98% rename from elektronLogging/schedWindowLogger.go rename to logging/schedWindowLogger.go index 75c6a50..b303b28 100644 --- a/elektronLogging/schedWindowLogger.go +++ b/logging/schedWindowLogger.go @@ -1,4 +1,4 @@ -package elektronLogging +package logging import ( "os" diff --git a/elektronLogging/types/types.go b/logging/types/types.go similarity index 100% rename from elektronLogging/types/types.go rename to logging/types/types.go diff --git a/pcp/pcp.go b/pcp/pcp.go index 90d0b52..5f5affd 100644 --- a/pcp/pcp.go +++ b/pcp/pcp.go @@ -25,8 +25,8 @@ import ( "time" log "github.com/sirupsen/logrus" - elekLog "github.com/spdfg/elektron/elektronLogging" - elekLogTypes "github.com/spdfg/elektron/elektronLogging/types" + elekLog "github.com/spdfg/elektron/logging" + elekLogTypes "github.com/spdfg/elektron/logging/types" ) func Start(quit chan struct{}, logging *bool, pcpConfigFile string) { diff --git a/powerCap/extrema.go b/powerCap/extrema.go index dbd38aa..e2d2bec 100644 --- a/powerCap/extrema.go +++ b/powerCap/extrema.go @@ -30,8 +30,8 @@ import ( "time" log "github.com/sirupsen/logrus" - elekLog "github.com/spdfg/elektron/elektronLogging" - elekLogTypes "github.com/spdfg/elektron/elektronLogging/types" + elekLog "github.com/spdfg/elektron/logging" + elekLogTypes "github.com/spdfg/elektron/logging/types" "github.com/spdfg/elektron/pcp" "github.com/spdfg/elektron/rapl" ) diff --git a/powerCap/progressiveExtrema.go b/powerCap/progressiveExtrema.go index f75f849..2ab9147 100644 --- a/powerCap/progressiveExtrema.go +++ b/powerCap/progressiveExtrema.go @@ -32,8 +32,8 @@ import ( log "github.com/sirupsen/logrus" "github.com/spdfg/elektron/constants" - elekLog "github.com/spdfg/elektron/elektronLogging" - elekLogTypes "github.com/spdfg/elektron/elektronLogging/types" + elekLog "github.com/spdfg/elektron/logging" + elekLogTypes "github.com/spdfg/elektron/logging/types" "github.com/spdfg/elektron/pcp" "github.com/spdfg/elektron/rapl" "github.com/spdfg/elektron/utilities" diff --git a/scheduler.go b/scheduler.go index ec2df7b..d376f38 100644 --- a/scheduler.go +++ b/scheduler.go @@ -31,8 +31,8 @@ import ( sched "github.com/mesos/mesos-go/api/v0/scheduler" log "github.com/sirupsen/logrus" "github.com/spdfg/elektron/def" - elekLog "github.com/spdfg/elektron/elektronLogging" - elekLogTypes "github.com/spdfg/elektron/elektronLogging/types" + elekLog "github.com/spdfg/elektron/logging" + elekLogTypes "github.com/spdfg/elektron/logging/types" "github.com/spdfg/elektron/pcp" "github.com/spdfg/elektron/powerCap" "github.com/spdfg/elektron/schedulers" diff --git a/schedulers/base.go b/schedulers/base.go index 25f06a9..55657c3 100644 --- a/schedulers/base.go +++ b/schedulers/base.go @@ -30,8 +30,8 @@ import ( sched "github.com/mesos/mesos-go/api/v0/scheduler" log "github.com/sirupsen/logrus" "github.com/spdfg/elektron/def" - elekLog "github.com/spdfg/elektron/elektronLogging" - elekLogTypes "github.com/spdfg/elektron/elektronLogging/types" + elekLog "github.com/spdfg/elektron/logging" + elekLogTypes "github.com/spdfg/elektron/logging/types" "github.com/spdfg/elektron/utilities" "github.com/spdfg/elektron/utilities/schedUtils" ) diff --git a/schedulers/helpers.go b/schedulers/helpers.go index a9004e0..fcc3f05 100644 --- a/schedulers/helpers.go +++ b/schedulers/helpers.go @@ -27,8 +27,8 @@ import ( log "github.com/sirupsen/logrus" "github.com/spdfg/elektron/constants" "github.com/spdfg/elektron/def" - elekLog "github.com/spdfg/elektron/elektronLogging" - elekLogTypes "github.com/spdfg/elektron/elektronLogging/types" + elekLog "github.com/spdfg/elektron/logging" + elekLogTypes "github.com/spdfg/elektron/logging/types" "github.com/spdfg/elektron/utilities" "github.com/spdfg/elektron/utilities/mesosUtils" ) diff --git a/schedulers/schedPolicy.go b/schedulers/schedPolicy.go index dfd44ec..cc6ae14 100644 --- a/schedulers/schedPolicy.go +++ b/schedulers/schedPolicy.go @@ -26,8 +26,8 @@ import ( sched "github.com/mesos/mesos-go/api/v0/scheduler" log "github.com/sirupsen/logrus" "github.com/spdfg/elektron/def" - elekLog "github.com/spdfg/elektron/elektronLogging" - elekLogTypes "github.com/spdfg/elektron/elektronLogging/types" + elekLog "github.com/spdfg/elektron/logging" + elekLogTypes "github.com/spdfg/elektron/logging/types" ) type SchedPolicyContext interface { diff --git a/utilities/offerUtils/offerUtils.go b/utilities/offerUtils/offerUtils.go index 4c1a475..0f9338e 100644 --- a/utilities/offerUtils/offerUtils.go +++ b/utilities/offerUtils/offerUtils.go @@ -24,8 +24,8 @@ import ( mesos "github.com/mesos/mesos-go/api/v0/mesosproto" log "github.com/sirupsen/logrus" "github.com/spdfg/elektron/constants" - elekLog "github.com/spdfg/elektron/elektronLogging" - elekLogTypes "github.com/spdfg/elektron/elektronLogging/types" + elekLog "github.com/spdfg/elektron/logging" + elekLogTypes "github.com/spdfg/elektron/logging/types" ) func OfferAgg(offer *mesos.Offer) (float64, float64, float64) { diff --git a/utilities/schedUtils/schedUtils.go b/utilities/schedUtils/schedUtils.go index 5e4fc69..c28c201 100644 --- a/utilities/schedUtils/schedUtils.go +++ b/utilities/schedUtils/schedUtils.go @@ -21,8 +21,8 @@ package schedUtils import ( log "github.com/sirupsen/logrus" "github.com/spdfg/elektron/def" - elekLog "github.com/spdfg/elektron/elektronLogging" - elekLogTypes "github.com/spdfg/elektron/elektronLogging/types" + elekLog "github.com/spdfg/elektron/logging" + elekLogTypes "github.com/spdfg/elektron/logging/types" "github.com/spdfg/elektron/utilities" ) -- 2.47.2 From 5a6d1bed4ace22a72504b30e00c998279fcea59a Mon Sep 17 00:00:00 2001 From: Pradyumna Kaushik Date: Thu, 5 Dec 2019 17:40:00 -0500 Subject: [PATCH 30/48] refactored Dist to Distr in clsfnTaskDistOverheadLogger.go --- ...nTaskDistOverheadLogger.go => clsfnTaskDistrOverheadLogger.go} | 0 1 file changed, 0 insertions(+), 0 deletions(-) rename logging/{clsfnTaskDistOverheadLogger.go => clsfnTaskDistrOverheadLogger.go} (100%) diff --git a/logging/clsfnTaskDistOverheadLogger.go b/logging/clsfnTaskDistrOverheadLogger.go similarity index 100% rename from logging/clsfnTaskDistOverheadLogger.go rename to logging/clsfnTaskDistrOverheadLogger.go -- 2.47.2 From 6fb0e4a3fe63e76982817bbdb2dcb8b5b80af7b1 Mon Sep 17 00:00:00 2001 From: Pradyumna Kaushik Date: Thu, 5 Dec 2019 21:32:37 -0500 Subject: [PATCH 31/48] move cfg to loggers + refactor + log fn wrappers 1. Instead of maintaining a global config, each specialized logger now stores its config. 2. Refactored logInterface to elektronLogger. 3. Refactored loggerImpl to baseElektronLogger to be consistent with the rest of the code base. 4. Wrapped elektronLogger#Log(...) and elektronLogf(...) so that we do not have to use the instance of elektronLogger everytime we want to log. Instead, we just do logging.Log(...) or logging.Logf(...). 5. Wrapped elektronLogger#WithFields(...) and elektronLogger#WithField(...). 6. Refactored codebase to adhere to the changes. --- def/taskUtils.go | 4 +- logging/clsfnTaskDistrOverheadLogger.go | 51 ++++++---- logging/consoleLogger.go | 50 +++++++--- logging/logger.go | 124 ++++++++++++++++++++---- logging/loggerChain.go | 56 ----------- logging/loggerConfig.go | 9 +- logging/pcpLogger.go | 50 +++++++--- logging/schedPolicySwitchLogger.go | 50 +++++++--- logging/schedTraceLogger.go | 50 +++++++--- logging/schedWindowLogger.go | 50 +++++++--- logging/types/types.go | 2 +- pcp/pcp.go | 8 +- powerCap/extrema.go | 26 ++--- powerCap/progressiveExtrema.go | 44 ++++----- scheduler.go | 11 ++- schedulers/base.go | 49 +++++----- schedulers/helpers.go | 4 +- schedulers/schedPolicy.go | 2 +- utilities/offerUtils/offerUtils.go | 4 +- utilities/schedUtils/schedUtils.go | 2 +- 20 files changed, 396 insertions(+), 250 deletions(-) delete mode 100644 logging/loggerChain.go diff --git a/def/taskUtils.go b/def/taskUtils.go index 1822779..7de0a34 100644 --- a/def/taskUtils.go +++ b/def/taskUtils.go @@ -52,7 +52,7 @@ func (tc TasksToClassify) taskObservationCalculator(task Task) []float64 { } else if task.Watts != 0.0 { return []float64{task.Watts} } else { - elekLog.ElektronLogger.Log(elekLogTypes.CONSOLE, log.FatalLevel, "Unable to classify tasks. Missing Watts or ClassToWatts attribute in workload") + elekLog.Log(elekLogTypes.CONSOLE, log.FatalLevel, "Unable to classify tasks. Missing Watts or ClassToWatts attribute in workload") return []float64{0.0} // Won't reach here. } } @@ -107,7 +107,7 @@ func clusterSizeAvgMMMPU(tasks []Task, taskObservation func(task Task) []float64 } else { // skip this value // there is an error in the task config. - elekLog.ElektronLogger.Log(elekLogTypes.CONSOLE, log.ErrorLevel, err.Error()) + elekLog.Log(elekLogTypes.CONSOLE, log.ErrorLevel, err.Error()) } } else { // There is only one observation for the task. diff --git a/logging/clsfnTaskDistrOverheadLogger.go b/logging/clsfnTaskDistrOverheadLogger.go index b965609..2d2777b 100644 --- a/logging/clsfnTaskDistrOverheadLogger.go +++ b/logging/clsfnTaskDistrOverheadLogger.go @@ -9,25 +9,43 @@ import ( ) type ClsfnTaskDistrOverheadLogger struct { - loggerImpl + baseElektronLogger } -func NewClsfnTaskDistrOverheadLogger(b *baseLogData, logType int, prefix string, - logger *log.Logger, logDir *logDirectory) *ClsfnTaskDistrOverheadLogger { - cLog := &ClsfnTaskDistrOverheadLogger{} - cLog.logType = logType - cLog.logDir = logDir - cLog.next = nil - cLog.baseLogData = b - cLog.logger = logger +func NewClsfnTaskDistrOverheadLogger( + config *LoggerConfig, + b *baseLogData, + logType int, + prefix string, + logger *log.Logger, + logDir *logDirectory) *ClsfnTaskDistrOverheadLogger { + + cLog := &ClsfnTaskDistrOverheadLogger{ + baseElektronLogger: baseElektronLogger{ + baseLogData: b, + config: struct { + Enabled bool + FilenameExtension string + AllowOnConsole bool + }{ + Enabled: config.TaskDistrConfig.Enabled, + FilenameExtension: config.TaskDistrConfig.FilenameExtension, + AllowOnConsole: config.TaskDistrConfig.AllowOnConsole, + }, + logType: logType, + next: nil, + logger: logger, + logDir: logDir, + }, + } + cLog.createLogFile(prefix) return cLog } - func (cLog ClsfnTaskDistrOverheadLogger) Log(logType int, level log.Level, message string) { if cLog.logType == logType { - if config.TaskDistrConfig.Enabled { - if cLog.allowOnConsole { + if cLog.isEnabled() { + if cLog.config.AllowOnConsole { cLog.logger.SetOutput(os.Stdout) cLog.logger.WithFields(cLog.data).Log(level, message) } @@ -47,8 +65,8 @@ func (cLog ClsfnTaskDistrOverheadLogger) Log(logType int, level log.Level, messa func (cLog ClsfnTaskDistrOverheadLogger) Logf(logType int, level log.Level, msgFmtString string, args ...interface{}) { if cLog.logType == logType { - if config.TaskDistrConfig.Enabled { - if cLog.allowOnConsole { + if cLog.isEnabled() { + if cLog.config.AllowOnConsole { cLog.logger.SetOutput(os.Stdout) cLog.logger.WithFields(cLog.data).Logf(level, msgFmtString, args...) } @@ -67,15 +85,14 @@ func (cLog ClsfnTaskDistrOverheadLogger) Logf(logType int, level log.Level, msgF func (cLog *ClsfnTaskDistrOverheadLogger) createLogFile(prefix string) { - if config.TaskDistrConfig.Enabled { - filename := strings.Join([]string{prefix, config.TaskDistrConfig.FilenameExtension}, "") + if cLog.isEnabled() { + filename := strings.Join([]string{prefix, cLog.config.FilenameExtension}, "") dirName := cLog.logDir.getDirName() if dirName != "" { if logFile, err := os.Create(filepath.Join(dirName, filename)); err != nil { log.Fatal("Unable to create logFile: ", err) } else { cLog.logFile = logFile - cLog.allowOnConsole = config.TaskDistrConfig.AllowOnConsole } } } diff --git a/logging/consoleLogger.go b/logging/consoleLogger.go index d1a115d..ab449b9 100644 --- a/logging/consoleLogger.go +++ b/logging/consoleLogger.go @@ -9,23 +9,46 @@ import ( ) type ConsoleLogger struct { - loggerImpl + baseElektronLogger + MinLogLevel string } -func NewConsoleLogger(b *baseLogData, logType int, prefix string, - logger *log.Logger, logDir *logDirectory) *ConsoleLogger { - cLog := &ConsoleLogger{} - cLog.logType = logType - cLog.logDir = logDir - cLog.next = nil - cLog.baseLogData = b - cLog.logger = logger +func NewConsoleLogger( + config *LoggerConfig, + b *baseLogData, + logType int, + prefix string, + logger *log.Logger, + logDir *logDirectory) *ConsoleLogger { + + cLog := &ConsoleLogger{ + baseElektronLogger: baseElektronLogger{ + baseLogData: b, + config: struct { + Enabled bool + FilenameExtension string + AllowOnConsole bool + }{ + Enabled: config.ConsoleConfig.Enabled, + FilenameExtension: config.ConsoleConfig.FilenameExtension, + AllowOnConsole: config.ConsoleConfig.AllowOnConsole, + }, + logType: logType, + next: nil, + logger: logger, + logDir: logDir, + }, + + MinLogLevel: config.ConsoleConfig.MinLogLevel, + } + cLog.createLogFile(prefix) return cLog } + func (cLog ConsoleLogger) Log(logType int, level log.Level, message string) { if logType <= cLog.logType { - if config.ConsoleConfig.Enabled { + if cLog.isEnabled() { cLog.logger.SetOutput(os.Stdout) cLog.logger.WithFields(cLog.data).Log(level, message) @@ -44,7 +67,7 @@ func (cLog ConsoleLogger) Log(logType int, level log.Level, message string) { func (cLog ConsoleLogger) Logf(logType int, level log.Level, msgFmtString string, args ...interface{}) { if logType <= cLog.logType { - if config.ConsoleConfig.Enabled { + if cLog.isEnabled() { cLog.logger.SetOutput(os.Stdout) cLog.logger.WithFields(cLog.data).Logf(level, msgFmtString, args...) @@ -62,8 +85,8 @@ func (cLog ConsoleLogger) Logf(logType int, level log.Level, msgFmtString string func (cLog *ConsoleLogger) createLogFile(prefix string) { // Create log file for the type if it is enabled. - if config.ConsoleConfig.Enabled { - filename := strings.Join([]string{prefix, config.ConsoleConfig.FilenameExtension}, "") + if cLog.isEnabled() { + filename := strings.Join([]string{prefix, cLog.config.FilenameExtension}, "") dirName := cLog.logDir.getDirName() fmt.Println(dirName) if dirName != "" { @@ -71,7 +94,6 @@ func (cLog *ConsoleLogger) createLogFile(prefix string) { log.Fatal("Unable to create logFile: ", err) } else { cLog.logFile = logFile - cLog.allowOnConsole = config.ConsoleConfig.AllowOnConsole } } } diff --git a/logging/logger.go b/logging/logger.go index b271c44..413fffb 100644 --- a/logging/logger.go +++ b/logging/logger.go @@ -1,6 +1,7 @@ package logging import ( + "github.com/pkg/errors" "os" "strings" "time" @@ -9,14 +10,75 @@ import ( . "github.com/spdfg/elektron/logging/types" ) -var config LoggerConfig +// var config LoggerConfig var formatter ElektronFormatter -var ElektronLogger *loggerImpl +var elektronLoggerInstance elektronLogger -func BuildLogger(prefix string, logConfigFilename string) { +type elektronLogger interface { + setNext(next elektronLogger) + isEnabled() bool + Log(logType int, level log.Level, message string) + Logf(logType int, level log.Level, msgFmtString string, args ...interface{}) + WithFields(logData log.Fields) elektronLogger + WithField(key string, value string) elektronLogger +} - // Read configuration from yaml. - config.GetConfig(logConfigFilename) +type baseLogData struct { + data log.Fields +} + +type baseElektronLogger struct { + *baseLogData + + config struct { + Enabled bool + FilenameExtension string + AllowOnConsole bool + } + + logType int + logFile *os.File + next elektronLogger + logger *log.Logger + logDir *logDirectory +} + +func (l baseElektronLogger) isEnabled() bool { + return l.config.Enabled +} + +func (l *baseElektronLogger) WithFields(logData log.Fields) elektronLogger { + l.data = logData + return l +} + +func (l *baseElektronLogger) WithField(key string, value string) elektronLogger { + l.data[key] = value + return l +} + +func (l *baseElektronLogger) setNext(next elektronLogger) { + l.next = next +} + +func (l baseElektronLogger) Log(logType int, level log.Level, message string) { + if l.next != nil { + l.next.Log(logType, level, message) + } +} + +func (l baseElektronLogger) Logf(logType int, level log.Level, msgFmtString string, args ...interface{}) { + if l.next != nil { + l.next.Logf(logType, level, msgFmtString, args...) + } +} + +func (l *baseElektronLogger) resetFields() { + l.data = nil + l.data = log.Fields{} +} + +func BuildLogger(prefix string, logConfigFilename string) error { // Create the log directory. startTime := time.Now() @@ -35,20 +97,44 @@ func BuildLogger(prefix string, logConfigFilename string) { // Create a chain of loggers. b := &baseLogData{data: log.Fields{}} - head := &loggerImpl{baseLogData: b} - cLog := NewConsoleLogger(b, CONSOLE, prefix, logger, logDir) - pLog := NewPCPLogger(b, PCP, prefix, logger, logDir) - schedTraceLog := NewSchedTraceLogger(b, SCHED_TRACE, prefix, logger, logDir) - spsLog := NewSchedPolicySwitchLogger(b, SPS, prefix, logger, logDir) - schedWindowLog := NewSchedWindowLogger(b, SCHED_WINDOW, prefix, logger, logDir) - tskDistLog := NewClsfnTaskDistrOverheadLogger(b, CLSFN_TASKDISTR_OVERHEAD, prefix, logger, logDir) + head := &baseElektronLogger{baseLogData: b} - head.setNext(cLog) - cLog.setNext(pLog) - pLog.setNext(schedTraceLog) - schedTraceLog.setNext(spsLog) - spsLog.setNext(schedWindowLog) - schedWindowLog.setNext(tskDistLog) + // Read configuration from yaml. + if config, err := GetConfig(logConfigFilename); err != nil { + return errors.Wrap(err, "Failed to build logger") + } else { + cLog := NewConsoleLogger(config, b, CONSOLE, prefix, logger, logDir) + pLog := NewPCPLogger(config, b, PCP, prefix, logger, logDir) + schedTraceLog := NewSchedTraceLogger(config, b, SCHED_TRACE, prefix, logger, logDir) + spsLog := NewSchedPolicySwitchLogger(config, b, SPS, prefix, logger, logDir) + schedWindowLog := NewSchedWindowLogger(config, b, SCHED_WINDOW, prefix, logger, logDir) + tskDistLog := NewClsfnTaskDistrOverheadLogger(config, b, CLSFN_TASKDISTR_OVERHEAD, prefix, logger, logDir) - ElektronLogger = head + head.setNext(cLog) + cLog.setNext(pLog) + pLog.setNext(schedTraceLog) + schedTraceLog.setNext(spsLog) + spsLog.setNext(schedWindowLog) + schedWindowLog.setNext(tskDistLog) + + } + + elektronLoggerInstance = head + return nil +} + +func Log(logType int, level log.Level, message string) { + elektronLoggerInstance.Log(logType, level, message) +} + +func Logf(logType int, level log.Level, msgFmtString string, args ...interface{}) { + elektronLoggerInstance.Logf(logType, level, msgFmtString, args...) +} + +func WithFields(logData log.Fields) elektronLogger { + return elektronLoggerInstance.WithFields(logData) +} + +func WithField(key string, value string) elektronLogger { + return elektronLoggerInstance.WithField(key, value) } diff --git a/logging/loggerChain.go b/logging/loggerChain.go deleted file mode 100644 index ff9792e..0000000 --- a/logging/loggerChain.go +++ /dev/null @@ -1,56 +0,0 @@ -package logging - -import ( - log "github.com/sirupsen/logrus" - "os" -) - -type logInterface interface { - setNext(logType logInterface) - Log(logType int, level log.Level, message string) - Logf(logType int, level log.Level, msgFmtString string, args ...interface{}) - createLogFile(prefix string) -} -type baseLogData struct { - data log.Fields -} -type loggerImpl struct { - *baseLogData - logType int - allowOnConsole bool - logFile *os.File - next logInterface - logger *log.Logger - logDir *logDirectory -} - -func (l *loggerImpl) WithFields(logData log.Fields) *loggerImpl { - l.data = logData - return l -} - -func (l *loggerImpl) WithField(key string, value string) *loggerImpl { - l.data[key] = value - return l -} - -func (l *loggerImpl) setNext(logType logInterface) { - l.next = logType -} - -func (l loggerImpl) Log(logType int, level log.Level, message string) { - if l.next != nil { - l.next.Log(logType, level, message) - } -} - -func (l loggerImpl) Logf(logType int, level log.Level, msgFmtString string, args ...interface{}) { - if l.next != nil { - l.next.Logf(logType, level, msgFmtString, args...) - } -} - -func (l *loggerImpl) resetFields() { - l.data = nil - l.data = log.Fields{} -} diff --git a/logging/loggerConfig.go b/logging/loggerConfig.go index a0ae5de..cbf3cbc 100644 --- a/logging/loggerConfig.go +++ b/logging/loggerConfig.go @@ -1,6 +1,7 @@ package logging import ( + "github.com/pkg/errors" log "github.com/sirupsen/logrus" "gopkg.in/yaml.v2" "io/ioutil" @@ -47,16 +48,18 @@ type LoggerConfig struct { Format []string `yaml:"format"` } -func (c *LoggerConfig) GetConfig(logConfigFilename string) *LoggerConfig { +func GetConfig(logConfigFilename string) (*LoggerConfig, error) { yamlFile, err := ioutil.ReadFile(logConfigFilename) if err != nil { - log.Printf("Error in reading yaml file #%v ", err) + return nil, errors.Wrap(err, "failed to read log config file") } + + c := &LoggerConfig{} err = yaml.Unmarshal(yamlFile, c) if err != nil { log.Fatalf("Error in unmarshalling yaml: %v", err) } - return c + return c, nil } diff --git a/logging/pcpLogger.go b/logging/pcpLogger.go index d9a91f8..52c1fbe 100644 --- a/logging/pcpLogger.go +++ b/logging/pcpLogger.go @@ -9,25 +9,44 @@ import ( ) type PCPLogger struct { - loggerImpl + baseElektronLogger } -func NewPCPLogger(b *baseLogData, logType int, prefix string, - logger *log.Logger, logDir *logDirectory) *PCPLogger { - pLog := &PCPLogger{} - pLog.logType = logType - pLog.logDir = logDir - pLog.next = nil - pLog.baseLogData = b - pLog.logger = logger +func NewPCPLogger( + config *LoggerConfig, + b *baseLogData, + logType int, + prefix string, + logger *log.Logger, + logDir *logDirectory) *PCPLogger { + + pLog := &PCPLogger{ + baseElektronLogger: baseElektronLogger{ + baseLogData: b, + config: struct { + Enabled bool + FilenameExtension string + AllowOnConsole bool + }{ + Enabled: config.PCPConfig.Enabled, + FilenameExtension: config.PCPConfig.FilenameExtension, + AllowOnConsole: config.PCPConfig.AllowOnConsole, + }, + logType: logType, + next: nil, + logger: logger, + logDir: logDir, + }, + } + pLog.createLogFile(prefix) return pLog } func (pLog PCPLogger) Log(logType int, level log.Level, message string) { if pLog.logType == logType { - if config.PCPConfig.Enabled { - if pLog.allowOnConsole { + if pLog.isEnabled() { + if pLog.config.AllowOnConsole { pLog.logger.SetOutput(os.Stdout) pLog.logger.WithFields(pLog.data).Log(level, message) } @@ -46,8 +65,8 @@ func (pLog PCPLogger) Log(logType int, level log.Level, message string) { func (pLog PCPLogger) Logf(logType int, level log.Level, msgFmtString string, args ...interface{}) { if pLog.logType == logType { - if config.PCPConfig.Enabled { - if pLog.allowOnConsole { + if pLog.isEnabled() { + if pLog.config.AllowOnConsole { pLog.logger.SetOutput(os.Stdout) pLog.logger.WithFields(pLog.data).Logf(level, msgFmtString, args...) } @@ -66,15 +85,14 @@ func (pLog PCPLogger) Logf(logType int, level log.Level, msgFmtString string, ar } func (pLog *PCPLogger) createLogFile(prefix string) { - if config.PCPConfig.Enabled { - filename := strings.Join([]string{prefix, config.PCPConfig.FilenameExtension}, "") + if pLog.isEnabled() { + filename := strings.Join([]string{prefix, pLog.config.FilenameExtension}, "") dirName := pLog.logDir.getDirName() if dirName != "" { if logFile, err := os.Create(filepath.Join(dirName, filename)); err != nil { log.Fatal("Unable to create logFile: ", err) } else { pLog.logFile = logFile - pLog.allowOnConsole = config.PCPConfig.AllowOnConsole } } } diff --git a/logging/schedPolicySwitchLogger.go b/logging/schedPolicySwitchLogger.go index 437c300..98a5094 100644 --- a/logging/schedPolicySwitchLogger.go +++ b/logging/schedPolicySwitchLogger.go @@ -9,25 +9,44 @@ import ( ) type SchedPolicySwitchLogger struct { - loggerImpl + baseElektronLogger } -func NewSchedPolicySwitchLogger(b *baseLogData, logType int, prefix string, - logger *log.Logger, logDir *logDirectory) *SchedPolicySwitchLogger { - sLog := &SchedPolicySwitchLogger{} - sLog.logType = logType - sLog.logDir = logDir - sLog.next = nil - sLog.baseLogData = b - sLog.logger = logger +func NewSchedPolicySwitchLogger( + config *LoggerConfig, + b *baseLogData, + logType int, + prefix string, + logger *log.Logger, + logDir *logDirectory) *SchedPolicySwitchLogger { + + sLog := &SchedPolicySwitchLogger{ + baseElektronLogger: baseElektronLogger{ + baseLogData: b, + config: struct { + Enabled bool + FilenameExtension string + AllowOnConsole bool + }{ + Enabled: config.SPSConfig.Enabled, + FilenameExtension: config.SPSConfig.FilenameExtension, + AllowOnConsole: config.SPSConfig.AllowOnConsole, + }, + logType: logType, + next: nil, + logger: logger, + logDir: logDir, + }, + } + sLog.createLogFile(prefix) return sLog } func (sLog SchedPolicySwitchLogger) Log(logType int, level log.Level, message string) { if sLog.logType == logType { - if config.SPSConfig.Enabled { - if sLog.allowOnConsole { + if sLog.isEnabled() { + if sLog.config.AllowOnConsole { sLog.logger.SetOutput(os.Stdout) sLog.logger.WithFields(sLog.data).Log(level, message) } @@ -46,8 +65,8 @@ func (sLog SchedPolicySwitchLogger) Log(logType int, level log.Level, message st func (sLog SchedPolicySwitchLogger) Logf(logType int, level log.Level, msgFmtString string, args ...interface{}) { if sLog.logType == logType { - if config.SPSConfig.Enabled { - if sLog.allowOnConsole { + if sLog.isEnabled() { + if sLog.config.AllowOnConsole { sLog.logger.SetOutput(os.Stdout) sLog.logger.WithFields(sLog.data).Logf(level, msgFmtString, args...) } @@ -66,15 +85,14 @@ func (sLog SchedPolicySwitchLogger) Logf(logType int, level log.Level, msgFmtStr } func (sLog *SchedPolicySwitchLogger) createLogFile(prefix string) { - if config.SPSConfig.Enabled { - filename := strings.Join([]string{prefix, config.SPSConfig.FilenameExtension}, "") + if sLog.isEnabled() { + filename := strings.Join([]string{prefix, sLog.config.FilenameExtension}, "") dirName := sLog.logDir.getDirName() if dirName != "" { if logFile, err := os.Create(filepath.Join(dirName, filename)); err != nil { log.Fatal("Unable to create logFile: ", err) } else { sLog.logFile = logFile - sLog.allowOnConsole = config.SPSConfig.AllowOnConsole } } } diff --git a/logging/schedTraceLogger.go b/logging/schedTraceLogger.go index ccbad63..292dff8 100644 --- a/logging/schedTraceLogger.go +++ b/logging/schedTraceLogger.go @@ -9,25 +9,44 @@ import ( ) type SchedTraceLogger struct { - loggerImpl + baseElektronLogger } -func NewSchedTraceLogger(b *baseLogData, logType int, prefix string, - logger *log.Logger, logDir *logDirectory) *SchedTraceLogger { - sLog := &SchedTraceLogger{} - sLog.logType = logType - sLog.logDir = logDir - sLog.next = nil - sLog.baseLogData = b - sLog.logger = logger +func NewSchedTraceLogger( + config *LoggerConfig, + b *baseLogData, + logType int, + prefix string, + logger *log.Logger, + logDir *logDirectory) *SchedTraceLogger { + + sLog := &SchedTraceLogger{ + baseElektronLogger: baseElektronLogger{ + baseLogData: b, + config: struct { + Enabled bool + FilenameExtension string + AllowOnConsole bool + }{ + Enabled: config.SchedTraceConfig.Enabled, + FilenameExtension: config.SchedTraceConfig.FilenameExtension, + AllowOnConsole: config.SchedTraceConfig.AllowOnConsole, + }, + logType: logType, + next: nil, + logger: logger, + logDir: logDir, + }, + } + sLog.createLogFile(prefix) return sLog } func (sLog SchedTraceLogger) Log(logType int, level log.Level, message string) { if sLog.logType == logType { - if config.SchedTraceConfig.Enabled { - if sLog.allowOnConsole { + if sLog.isEnabled() { + if sLog.config.AllowOnConsole { sLog.logger.SetOutput(os.Stdout) sLog.logger.WithFields(sLog.data).Log(level, message) } @@ -46,8 +65,8 @@ func (sLog SchedTraceLogger) Log(logType int, level log.Level, message string) { func (sLog SchedTraceLogger) Logf(logType int, level log.Level, msgFmtString string, args ...interface{}) { if sLog.logType == logType { - if config.SchedTraceConfig.Enabled { - if sLog.allowOnConsole { + if sLog.isEnabled() { + if sLog.config.AllowOnConsole { sLog.logger.SetOutput(os.Stdout) sLog.logger.WithFields(sLog.data).Logf(level, msgFmtString, args...) } @@ -66,15 +85,14 @@ func (sLog SchedTraceLogger) Logf(logType int, level log.Level, msgFmtString str } func (sLog *SchedTraceLogger) createLogFile(prefix string) { - if config.SchedTraceConfig.Enabled { - filename := strings.Join([]string{prefix, config.SchedTraceConfig.FilenameExtension}, "") + if sLog.isEnabled() { + filename := strings.Join([]string{prefix, sLog.config.FilenameExtension}, "") dirName := sLog.logDir.getDirName() if dirName != "" { if logFile, err := os.Create(filepath.Join(dirName, filename)); err != nil { log.Fatal("Unable to create logFile: ", err) } else { sLog.logFile = logFile - sLog.allowOnConsole = config.SchedTraceConfig.AllowOnConsole } } } diff --git a/logging/schedWindowLogger.go b/logging/schedWindowLogger.go index b303b28..9627e5e 100644 --- a/logging/schedWindowLogger.go +++ b/logging/schedWindowLogger.go @@ -9,25 +9,44 @@ import ( ) type SchedWindowLogger struct { - loggerImpl + baseElektronLogger } -func NewSchedWindowLogger(b *baseLogData, logType int, prefix string, - logger *log.Logger, logDir *logDirectory) *SchedWindowLogger { - sLog := &SchedWindowLogger{} - sLog.logType = logType - sLog.logDir = logDir - sLog.next = nil - sLog.baseLogData = b - sLog.logger = logger +func NewSchedWindowLogger( + config *LoggerConfig, + b *baseLogData, + logType int, + prefix string, + logger *log.Logger, + logDir *logDirectory) *SchedWindowLogger { + + sLog := &SchedWindowLogger{ + baseElektronLogger: baseElektronLogger{ + baseLogData: b, + config: struct { + Enabled bool + FilenameExtension string + AllowOnConsole bool + }{ + Enabled: config.SchedWindowConfig.Enabled, + FilenameExtension: config.SchedWindowConfig.FilenameExtension, + AllowOnConsole: config.SchedWindowConfig.AllowOnConsole, + }, + logType: logType, + next: nil, + logger: logger, + logDir: logDir, + }, + } + sLog.createLogFile(prefix) return sLog } func (sLog SchedWindowLogger) Log(logType int, level log.Level, message string) { if sLog.logType == logType { - if config.SchedWindowConfig.Enabled { - if sLog.allowOnConsole { + if sLog.isEnabled() { + if sLog.config.AllowOnConsole { sLog.logger.SetOutput(os.Stdout) sLog.logger.WithFields(sLog.data).Log(level, message) } @@ -47,8 +66,8 @@ func (sLog SchedWindowLogger) Log(logType int, level log.Level, message string) func (sLog SchedWindowLogger) Logf(logType int, level log.Level, msgFmtString string, args ...interface{}) { if sLog.logType == logType { - if config.SchedWindowConfig.Enabled { - if sLog.allowOnConsole { + if sLog.isEnabled() { + if sLog.config.AllowOnConsole { sLog.logger.SetOutput(os.Stdout) sLog.logger.WithFields(sLog.data).Logf(level, msgFmtString, args...) } @@ -66,15 +85,14 @@ func (sLog SchedWindowLogger) Logf(logType int, level log.Level, msgFmtString st } func (sLog *SchedWindowLogger) createLogFile(prefix string) { - if config.SchedWindowConfig.Enabled { - filename := strings.Join([]string{prefix, config.SchedWindowConfig.FilenameExtension}, "") + if sLog.isEnabled() { + filename := strings.Join([]string{prefix, sLog.config.FilenameExtension}, "") dirName := sLog.logDir.getDirName() if dirName != "" { if logFile, err := os.Create(filepath.Join(dirName, filename)); err != nil { log.Fatal("Unable to create logFile: ", err) } else { sLog.logFile = logFile - sLog.allowOnConsole = config.SchedWindowConfig.AllowOnConsole } } } diff --git a/logging/types/types.go b/logging/types/types.go index 903fe34..44b8484 100644 --- a/logging/types/types.go +++ b/logging/types/types.go @@ -1,4 +1,4 @@ -package elektronLogging +package types const ( CONSOLE = iota diff --git a/pcp/pcp.go b/pcp/pcp.go index 5f5affd..b2e886f 100644 --- a/pcp/pcp.go +++ b/pcp/pcp.go @@ -47,7 +47,7 @@ func Start(quit chan struct{}, logging *bool, pcpConfigFile string) { scanner.Scan() // Write to logfile - elekLog.ElektronLogger.Log(elekLogTypes.PCP, log.InfoLevel, scanner.Text()) + elekLog.Log(elekLogTypes.PCP, log.InfoLevel, scanner.Text()) // Throw away first set of results scanner.Scan() @@ -58,14 +58,14 @@ func Start(quit chan struct{}, logging *bool, pcpConfigFile string) { text := scanner.Text() if *logging { - elekLog.ElektronLogger.Log(elekLogTypes.PCP, log.InfoLevel, text) + elekLog.Log(elekLogTypes.PCP, log.InfoLevel, text) } seconds++ } }(logging) - elekLog.ElektronLogger.Log(elekLogTypes.CONSOLE, log.InfoLevel, "PCP logging started") + elekLog.Log(elekLogTypes.CONSOLE, log.InfoLevel, "PCP logging started") if err := cmd.Start(); err != nil { log.Fatal(err) @@ -75,7 +75,7 @@ func Start(quit chan struct{}, logging *bool, pcpConfigFile string) { select { case <-quit: - elekLog.ElektronLogger.Log(elekLogTypes.CONSOLE, log.InfoLevel, "Stopping PCP logging in 5 seconds") + elekLog.Log(elekLogTypes.CONSOLE, log.InfoLevel, "Stopping PCP logging in 5 seconds") time.Sleep(5 * time.Second) // http://stackoverflow.com/questions/22470193/why-wont-go-kill-a-child-process-correctly diff --git a/powerCap/extrema.go b/powerCap/extrema.go index e2d2bec..6abb65f 100644 --- a/powerCap/extrema.go +++ b/powerCap/extrema.go @@ -43,7 +43,7 @@ func StartPCPLogAndExtremaDynamicCap(quit chan struct{}, logging *bool, hiThresh cmd.SysProcAttr = &syscall.SysProcAttr{Setpgid: true} if hiThreshold < loThreshold { - elekLog.ElektronLogger.Log(elekLogTypes.CONSOLE, log.InfoLevel, "High threshold is lower than low threshold!") + elekLog.Log(elekLogTypes.CONSOLE, log.InfoLevel, "High threshold is lower than low threshold!") } pipe, err := cmd.StdoutPipe() @@ -59,7 +59,7 @@ func StartPCPLogAndExtremaDynamicCap(quit chan struct{}, logging *bool, hiThresh scanner.Scan() // Write to logfile - elekLog.ElektronLogger.Log(elekLogTypes.PCP, log.InfoLevel, scanner.Text()) + elekLog.Log(elekLogTypes.PCP, log.InfoLevel, scanner.Text()) headers := strings.Split(scanner.Text(), ",") @@ -95,12 +95,12 @@ func StartPCPLogAndExtremaDynamicCap(quit chan struct{}, logging *bool, hiThresh if *logging { - elekLog.ElektronLogger.Log(elekLogTypes.CONSOLE, log.InfoLevel, "Logging PCP...") + elekLog.Log(elekLogTypes.CONSOLE, log.InfoLevel, "Logging PCP...") text := scanner.Text() split := strings.Split(text, ",") - elekLog.ElektronLogger.Log(elekLogTypes.PCP, log.InfoLevel, text) + elekLog.Log(elekLogTypes.PCP, log.InfoLevel, text) totalPower := 0.0 for _, powerIndex := range powerIndexes { @@ -111,7 +111,7 @@ func StartPCPLogAndExtremaDynamicCap(quit chan struct{}, logging *bool, hiThresh powerHistories[host].Value = power powerHistories[host] = powerHistories[host].Next() - elekLog.ElektronLogger.WithFields(log.Fields{"Host": fmt.Sprintf("%s", indexToHost[powerIndex]), + elekLog.WithFields(log.Fields{"Host": fmt.Sprintf("%s", indexToHost[powerIndex]), "Power": fmt.Sprintf("%f", (power * pcp.RAPLUnits))}).Log(elekLogTypes.CONSOLE, log.InfoLevel, "") totalPower += power @@ -123,11 +123,11 @@ func StartPCPLogAndExtremaDynamicCap(quit chan struct{}, logging *bool, hiThresh clusterMean := pcp.AverageClusterPowerHistory(clusterPowerHist) - elekLog.ElektronLogger.WithFields(log.Fields{"Total power": fmt.Sprintf("%f %d", clusterPower, clusterPowerHist.Len()), + elekLog.WithFields(log.Fields{"Total power": fmt.Sprintf("%f %d", clusterPower, clusterPowerHist.Len()), "Sec Avg": fmt.Sprintf("%f", clusterMean)}).Log(elekLogTypes.CONSOLE, log.InfoLevel, "") if clusterMean > hiThreshold { - elekLog.ElektronLogger.Log(elekLogTypes.CONSOLE, + elekLog.Log(elekLogTypes.CONSOLE, log.InfoLevel, "Need to cap a node") // Create statics for all victims and choose one to cap victims := make([]pcp.Victim, 0, 8) @@ -149,10 +149,10 @@ func StartPCPLogAndExtremaDynamicCap(quit chan struct{}, logging *bool, hiThresh if !cappedHosts[victim.Host] { cappedHosts[victim.Host] = true orderCapped = append(orderCapped, victim.Host) - elekLog.ElektronLogger.WithFields(log.Fields{"Capping Victim": fmt.Sprintf("%s", victim.Host), + elekLog.WithFields(log.Fields{"Capping Victim": fmt.Sprintf("%s", victim.Host), "Avg. Wattage": fmt.Sprintf("%f", victim.Watts*pcp.RAPLUnits)}).Log(elekLogTypes.CONSOLE, log.InfoLevel, "") if err := rapl.Cap(victim.Host, "rapl", 50); err != nil { - elekLog.ElektronLogger.Log(elekLogTypes.CONSOLE, + elekLog.Log(elekLogTypes.CONSOLE, log.ErrorLevel, "Error capping host") } @@ -168,9 +168,9 @@ func StartPCPLogAndExtremaDynamicCap(quit chan struct{}, logging *bool, hiThresh cappedHosts[host] = false // User RAPL package to send uncap. log.Printf("Uncapping host %s", host) - elekLog.ElektronLogger.WithFields(log.Fields{"Uncapped host": host}).Log(elekLogTypes.CONSOLE, log.InfoLevel, "") + elekLog.WithFields(log.Fields{"Uncapped host": host}).Log(elekLogTypes.CONSOLE, log.InfoLevel, "") if err := rapl.Cap(host, "rapl", 100); err != nil { - elekLog.ElektronLogger.Log(elekLogTypes.CONSOLE, log.ErrorLevel, "Error capping host") + elekLog.Log(elekLogTypes.CONSOLE, log.ErrorLevel, "Error capping host") } } } @@ -180,7 +180,7 @@ func StartPCPLogAndExtremaDynamicCap(quit chan struct{}, logging *bool, hiThresh } }(logging, hiThreshold, loThreshold) - elekLog.ElektronLogger.Log(elekLogTypes.CONSOLE, log.InfoLevel, "PCP logging started") + elekLog.Log(elekLogTypes.CONSOLE, log.InfoLevel, "PCP logging started") if err := cmd.Start(); err != nil { log.Fatal(err) @@ -190,7 +190,7 @@ func StartPCPLogAndExtremaDynamicCap(quit chan struct{}, logging *bool, hiThresh select { case <-quit: - elekLog.ElektronLogger.Log(elekLogTypes.CONSOLE, log.InfoLevel, "Stopping PCP logging in 5 seconds") + elekLog.Log(elekLogTypes.CONSOLE, log.InfoLevel, "Stopping PCP logging in 5 seconds") time.Sleep(5 * time.Second) // http://stackoverflow.com/questions/22470193/why-wont-go-kill-a-child-process-correctly diff --git a/powerCap/progressiveExtrema.go b/powerCap/progressiveExtrema.go index 2ab9147..efa2023 100644 --- a/powerCap/progressiveExtrema.go +++ b/powerCap/progressiveExtrema.go @@ -56,7 +56,7 @@ func StartPCPLogAndProgressiveExtremaCap(quit chan struct{}, logging *bool, hiTh cmd.SysProcAttr = &syscall.SysProcAttr{Setpgid: true} if hiThreshold < loThreshold { - elekLog.ElektronLogger.Log(elekLogTypes.CONSOLE, log.InfoLevel, "High threshold is lower than low threshold!") + elekLog.Log(elekLogTypes.CONSOLE, log.InfoLevel, "High threshold is lower than low threshold!") } pipe, err := cmd.StdoutPipe() @@ -72,7 +72,7 @@ func StartPCPLogAndProgressiveExtremaCap(quit chan struct{}, logging *bool, hiTh scanner.Scan() // Write to logfile - elekLog.ElektronLogger.Log(elekLogTypes.PCP, log.InfoLevel, scanner.Text()) + elekLog.Log(elekLogTypes.PCP, log.InfoLevel, scanner.Text()) headers := strings.Split(scanner.Text(), ",") @@ -111,11 +111,11 @@ func StartPCPLogAndProgressiveExtremaCap(quit chan struct{}, logging *bool, hiTh for scanner.Scan() { if *logging { - elekLog.ElektronLogger.Log(elekLogTypes.CONSOLE, log.InfoLevel, "Logging PCP...") + elekLog.Log(elekLogTypes.CONSOLE, log.InfoLevel, "Logging PCP...") split := strings.Split(scanner.Text(), ",") text := scanner.Text() - elekLog.ElektronLogger.Log(elekLogTypes.PCP, log.InfoLevel, text) + elekLog.Log(elekLogTypes.PCP, log.InfoLevel, text) totalPower := 0.0 for _, powerIndex := range powerIndexes { @@ -126,7 +126,7 @@ func StartPCPLogAndProgressiveExtremaCap(quit chan struct{}, logging *bool, hiTh powerHistories[host].Value = power powerHistories[host] = powerHistories[host].Next() - elekLog.ElektronLogger.WithFields(log.Fields{"Host": fmt.Sprintf("%s", indexToHost[powerIndex]), + elekLog.WithFields(log.Fields{"Host": fmt.Sprintf("%s", indexToHost[powerIndex]), "Power": fmt.Sprintf("%f", (power * pcp.RAPLUnits))}).Log(elekLogTypes.CONSOLE, log.InfoLevel, "") totalPower += power } @@ -137,15 +137,15 @@ func StartPCPLogAndProgressiveExtremaCap(quit chan struct{}, logging *bool, hiTh clusterMean := pcp.AverageClusterPowerHistory(clusterPowerHist) - elekLog.ElektronLogger.WithFields(log.Fields{"Total power": fmt.Sprintf("%f %d", clusterPower, clusterPowerHist.Len()), + elekLog.WithFields(log.Fields{"Total power": fmt.Sprintf("%f %d", clusterPower, clusterPowerHist.Len()), "Sec Avg": fmt.Sprintf("%f", clusterMean)}).Log(elekLogTypes.CONSOLE, log.InfoLevel, "") if clusterMean >= hiThreshold { - elekLog.ElektronLogger.Log(elekLogTypes.CONSOLE, log.InfoLevel, "Need to cap a node") + elekLog.Log(elekLogTypes.CONSOLE, log.InfoLevel, "Need to cap a node") - elekLog.ElektronLogger.WithFields(log.Fields{"Cap values of capped victims": fmt.Sprintf("%v", cappedVictims)}).Log(elekLogTypes.CONSOLE, log.InfoLevel, "") + elekLog.WithFields(log.Fields{"Cap values of capped victims": fmt.Sprintf("%v", cappedVictims)}).Log(elekLogTypes.CONSOLE, log.InfoLevel, "") - elekLog.ElektronLogger.WithFields(log.Fields{"Cap values of victims to uncap": fmt.Sprintf("%v", orderCappedVictims)}).Log(elekLogTypes.CONSOLE, log.InfoLevel, "") + elekLog.WithFields(log.Fields{"Cap values of victims to uncap": fmt.Sprintf("%v", orderCappedVictims)}).Log(elekLogTypes.CONSOLE, log.InfoLevel, "") // Create statics for all victims and choose one to cap victims := make([]pcp.Victim, 0, 8) @@ -173,10 +173,10 @@ func StartPCPLogAndProgressiveExtremaCap(quit chan struct{}, logging *bool, hiTh // Need to cap this victim. if err := rapl.Cap(victims[i].Host, "rapl", 50.0); err != nil { - elekLog.ElektronLogger.WithFields(log.Fields{"Error capping host": fmt.Sprintf("%s", victims[i].Host)}).Log(elekLogTypes.CONSOLE, log.ErrorLevel, "") + elekLog.WithFields(log.Fields{"Error capping host": fmt.Sprintf("%s", victims[i].Host)}).Log(elekLogTypes.CONSOLE, log.ErrorLevel, "") } else { - elekLog.ElektronLogger.Logf(elekLogTypes.CONSOLE, log.InfoLevel, "Capped host[%s] at %f", victims[i].Host, 50.0) + elekLog.Logf(elekLogTypes.CONSOLE, log.InfoLevel, "Capped host[%s] at %f", victims[i].Host, 50.0) // Keeping track of this victim and it's cap value cappedVictims[victims[i].Host] = 50.0 newVictimFound = true @@ -200,10 +200,10 @@ func StartPCPLogAndProgressiveExtremaCap(quit chan struct{}, logging *bool, hiTh newCapValue := getNextCapValue(capValue, 2) if err := rapl.Cap(alreadyCappedHosts[i], "rapl", newCapValue); err != nil { - elekLog.ElektronLogger.WithFields(log.Fields{"Error capping host": fmt.Sprintf("%s", alreadyCappedHosts[i])}).Log(elekLogTypes.CONSOLE, log.ErrorLevel, "") + elekLog.WithFields(log.Fields{"Error capping host": fmt.Sprintf("%s", alreadyCappedHosts[i])}).Log(elekLogTypes.CONSOLE, log.ErrorLevel, "") } else { // Successful cap - elekLog.ElektronLogger.Logf(elekLogTypes.CONSOLE, log.InfoLevel, + elekLog.Logf(elekLogTypes.CONSOLE, log.InfoLevel, "Capped host[%s] at %f", alreadyCappedHosts[i], newCapValue) // Checking whether this victim can be capped further if newCapValue <= constants.LowerCapLimit { @@ -227,15 +227,15 @@ func StartPCPLogAndProgressiveExtremaCap(quit chan struct{}, logging *bool, hiTh } } if !canCapAlreadyCappedVictim { - elekLog.ElektronLogger.Log(elekLogTypes.CONSOLE, log.InfoLevel, "No Victim left to cap") + elekLog.Log(elekLogTypes.CONSOLE, log.InfoLevel, "No Victim left to cap") } } } else if clusterMean < loThreshold { - elekLog.ElektronLogger.Log(elekLogTypes.CONSOLE, log.InfoLevel, "Need to uncap a node") - elekLog.ElektronLogger.WithFields(log.Fields{"Cap values of capped victims": fmt.Sprintf("%v", cappedVictims)}).Log(elekLogTypes.CONSOLE, log.InfoLevel, "") - elekLog.ElektronLogger.WithFields(log.Fields{"Cap values of victims to uncap": fmt.Sprintf("%v", orderCappedVictims)}).Log(elekLogTypes.CONSOLE, log.InfoLevel, "") + elekLog.Log(elekLogTypes.CONSOLE, log.InfoLevel, "Need to uncap a node") + elekLog.WithFields(log.Fields{"Cap values of capped victims": fmt.Sprintf("%v", cappedVictims)}).Log(elekLogTypes.CONSOLE, log.InfoLevel, "") + elekLog.WithFields(log.Fields{"Cap values of victims to uncap": fmt.Sprintf("%v", orderCappedVictims)}).Log(elekLogTypes.CONSOLE, log.InfoLevel, "") if len(orderCapped) > 0 { // We pick the host that is capped the most to uncap. orderCappedToSort := utilities.GetPairList(orderCappedVictims) @@ -246,10 +246,10 @@ func StartPCPLogAndProgressiveExtremaCap(quit chan struct{}, logging *bool, hiTh newUncapValue := orderCappedVictims[hostToUncap] * 2.0 if err := rapl.Cap(hostToUncap, "rapl", newUncapValue); err != nil { - elekLog.ElektronLogger.WithFields(log.Fields{"Error uncapping host": fmt.Sprintf("%s", hostToUncap)}).Log(elekLogTypes.CONSOLE, log.ErrorLevel, "") + elekLog.WithFields(log.Fields{"Error uncapping host": fmt.Sprintf("%s", hostToUncap)}).Log(elekLogTypes.CONSOLE, log.ErrorLevel, "") } else { // Successful uncap - elekLog.ElektronLogger.Logf(elekLogTypes.CONSOLE, log.InfoLevel, "Uncapped host[%s] to %f", hostToUncap, newUncapValue) + elekLog.Logf(elekLogTypes.CONSOLE, log.InfoLevel, "Uncapped host[%s] to %f", hostToUncap, newUncapValue) // Can we uncap this host further. If not, then we remove its entry from orderCapped if newUncapValue >= 100.0 { // can compare using == // Deleting entry from orderCapped @@ -270,7 +270,7 @@ func StartPCPLogAndProgressiveExtremaCap(quit chan struct{}, logging *bool, hiTh } } } else { - elekLog.ElektronLogger.Log(elekLogTypes.CONSOLE, log.InfoLevel, "No host staged for Uncapped") + elekLog.Log(elekLogTypes.CONSOLE, log.InfoLevel, "No host staged for Uncapped") } } } @@ -279,7 +279,7 @@ func StartPCPLogAndProgressiveExtremaCap(quit chan struct{}, logging *bool, hiTh }(logging, hiThreshold, loThreshold) - elekLog.ElektronLogger.Log(elekLogTypes.CONSOLE, log.InfoLevel, "PCP logging started") + elekLog.Log(elekLogTypes.CONSOLE, log.InfoLevel, "PCP logging started") if err := cmd.Start(); err != nil { log.Fatal(err) } @@ -288,7 +288,7 @@ func StartPCPLogAndProgressiveExtremaCap(quit chan struct{}, logging *bool, hiTh select { case <-quit: - elekLog.ElektronLogger.Log(elekLogTypes.CONSOLE, log.InfoLevel, "Stopping PCP logging in 5 seconds") + elekLog.Log(elekLogTypes.CONSOLE, log.InfoLevel, "Stopping PCP logging in 5 seconds") time.Sleep(5 * time.Second) // http://stackoverflow.com/questions/22470193/why-wont-go-kill-a-child-process-correctly diff --git a/scheduler.go b/scheduler.go index d376f38..92b2e87 100644 --- a/scheduler.go +++ b/scheduler.go @@ -226,8 +226,11 @@ func main() { if strings.Contains(*pcplogPrefix, "/") { log.Fatal("log file prefix should not contain '/'.") } - // Build Logger for elektron. - elekLog.BuildLogger(*pcplogPrefix, *logConfigFilename) + + // Build Logger. + if err := elekLog.BuildLogger(*pcplogPrefix, *logConfigFilename); err != nil { + log.Fatal(err) + } // Starting PCP logging. if noPowercap { @@ -282,8 +285,8 @@ func main() { // Starting the scheduler driver. if status, err := driver.Run(); err != nil { - elekLog.ElektronLogger.WithFields(log.Fields{"status": status.String(), "error": err.Error()}).Log(elekLogTypes.CONSOLE, + elekLog.WithFields(log.Fields{"status": status.String(), "error": err.Error()}).Log(elekLogTypes.CONSOLE, log.ErrorLevel, "Framework stopped ") } - elekLog.ElektronLogger.Log(elekLogTypes.CONSOLE, log.InfoLevel, "Exiting...") + elekLog.Log(elekLogTypes.CONSOLE, log.InfoLevel, "Exiting...") } diff --git a/schedulers/base.go b/schedulers/base.go index 55657c3..cfb350b 100644 --- a/schedulers/base.go +++ b/schedulers/base.go @@ -250,30 +250,29 @@ func (s *BaseScheduler) StatusUpdate(driver sched.SchedulerDriver, status *mesos func (s *BaseScheduler) LogTaskStarting(ts *def.Task, offer *mesos.Offer) { if ts == nil { - elekLog.ElektronLogger.WithFields(log.Fields{"host": fmt.Sprintf("%s", offer.GetHostname())}).Log(elekLogTypes.CONSOLE, log.InfoLevel, "TASKS STARTING...") + elekLog.WithFields(log.Fields{"host": fmt.Sprintf("%s", offer.GetHostname())}).Log(elekLogTypes.CONSOLE, log.InfoLevel, "TASKS STARTING...") } else { - elekLog.ElektronLogger.WithFields(log.Fields{"task": fmt.Sprintf("%s", ts.Name), - "Instance": fmt.Sprintf("%d", *ts.Instances), "host": fmt.Sprintf("%s", offer.GetHostname())}).Log(elekLogTypes.CONSOLE, - log.InfoLevel, "TASK STARTING... ") + elekLog.WithFields(log.Fields{"task": fmt.Sprintf("%s", ts.Name), "Instance": fmt.Sprintf("%d", *ts.Instances), + "host": fmt.Sprintf("%s", offer.GetHostname())}).Log(elekLogTypes.CONSOLE, log.InfoLevel, "TASK STARTING... ") } } func (s *BaseScheduler) LogTaskWattsConsideration(ts def.Task, host string, wattsToConsider float64) { - elekLog.ElektronLogger.WithFields(log.Fields{"task": ts.Name, "host": host, "Watts": fmt.Sprintf("%f", wattsToConsider)}).Log(elekLogTypes.CONSOLE, log.InfoLevel, "Watts considered for ") + elekLog.WithFields(log.Fields{"task": ts.Name, "host": host, "Watts": fmt.Sprintf("%f", wattsToConsider)}).Log(elekLogTypes.CONSOLE, log.InfoLevel, "Watts considered for ") } func (s *BaseScheduler) LogOffersReceived(offers []*mesos.Offer) { - elekLog.ElektronLogger.WithFields(log.Fields{"Resource offers received": fmt.Sprintf("%d", len(offers))}).Log(elekLogTypes.CONSOLE, + elekLog.WithFields(log.Fields{"Resource offers received": fmt.Sprintf("%d", len(offers))}).Log(elekLogTypes.CONSOLE, log.InfoLevel, "") } func (s *BaseScheduler) LogNoPendingTasksDeclineOffers(offer *mesos.Offer) { - elekLog.ElektronLogger.WithFields(log.Fields{"DECLINING OFFER for host": fmt.Sprintf("%s", offer.GetHostname())}).Log(elekLogTypes.CONSOLE, + elekLog.WithFields(log.Fields{"DECLINING OFFER for host": fmt.Sprintf("%s", offer.GetHostname())}).Log(elekLogTypes.CONSOLE, log.WarnLevel, "No tasks left to schedule ") } func (s *BaseScheduler) LogNumberOfRunningTasks() { - elekLog.ElektronLogger.WithFields(log.Fields{"Number of tasks still Running": fmt.Sprintf("%d", s.tasksRunning)}).Log(elekLogTypes.CONSOLE, + elekLog.WithFields(log.Fields{"Number of tasks still Running": fmt.Sprintf("%d", s.tasksRunning)}).Log(elekLogTypes.CONSOLE, log.InfoLevel, "") } @@ -284,67 +283,67 @@ func (s *BaseScheduler) LogCoLocatedTasks(slaveID string) { buffer.WriteString(fmt.Sprintln(taskName)) } s.TasksRunningMutex.Unlock() - elekLog.ElektronLogger.WithFields(log.Fields{"Colocated with": fmt.Sprintf("%s", buffer.String())}).Log(elekLogTypes.CONSOLE, + elekLog.WithFields(log.Fields{"Colocated with": fmt.Sprintf("%s", buffer.String())}).Log(elekLogTypes.CONSOLE, log.InfoLevel, "") } func (s *BaseScheduler) LogSchedTrace(taskToSchedule *mesos.TaskInfo, offer *mesos.Offer) { - elekLog.ElektronLogger.WithFields(log.Fields{offer.GetHostname(): fmt.Sprintf("%s", taskToSchedule.GetTaskId().GetValue())}).Log(elekLogTypes.SCHED_TRACE, log.InfoLevel, "") + elekLog.WithFields(log.Fields{offer.GetHostname(): fmt.Sprintf("%s", taskToSchedule.GetTaskId().GetValue())}).Log(elekLogTypes.SCHED_TRACE, log.InfoLevel, "") } func (s *BaseScheduler) LogTerminateScheduler() { - elekLog.ElektronLogger.Log(elekLogTypes.CONSOLE, log.InfoLevel, "Done scheduling all tasks!") + elekLog.Log(elekLogTypes.CONSOLE, log.InfoLevel, "Done scheduling all tasks!") } func (s *BaseScheduler) LogInsufficientResourcesDeclineOffer(offer *mesos.Offer, offerResources ...interface{}) { buffer := bytes.Buffer{} buffer.WriteString(fmt.Sprintf("", offerResources...)) - elekLog.ElektronLogger.WithFields(log.Fields{"Offer Resources": fmt.Sprintf("%s", buffer.String())}).Log(elekLogTypes.CONSOLE, + elekLog.WithFields(log.Fields{"Offer Resources": fmt.Sprintf("%s", buffer.String())}).Log(elekLogTypes.CONSOLE, log.WarnLevel, "DECLINING OFFER... Offer has insufficient resources to launch a task") } func (s *BaseScheduler) LogOfferRescinded(offerID *mesos.OfferID) { - elekLog.ElektronLogger.WithFields(log.Fields{"OfferID": fmt.Sprintf("%s", offerID)}).Log(elekLogTypes.CONSOLE, + elekLog.WithFields(log.Fields{"OfferID": fmt.Sprintf("%s", offerID)}).Log(elekLogTypes.CONSOLE, log.ErrorLevel, "OFFER RESCINDED") } func (s *BaseScheduler) LogSlaveLost(slaveID *mesos.SlaveID) { - elekLog.ElektronLogger.WithFields(log.Fields{"SlaveID": fmt.Sprintf("%s", slaveID)}).Log(elekLogTypes.CONSOLE, + elekLog.WithFields(log.Fields{"SlaveID": fmt.Sprintf("%s", slaveID)}).Log(elekLogTypes.CONSOLE, log.ErrorLevel, "SLAVE LOST") } func (s *BaseScheduler) LogExecutorLost(executorID *mesos.ExecutorID, slaveID *mesos.SlaveID) { - elekLog.ElektronLogger.WithFields(log.Fields{"ExecutorID": fmt.Sprintf("%s", executorID), "SlaveID": fmt.Sprintf("%s", slaveID)}).Log(elekLogTypes.CONSOLE, log.ErrorLevel, "EXECUTOR LOST") + elekLog.WithFields(log.Fields{"ExecutorID": fmt.Sprintf("%s", executorID), "SlaveID": fmt.Sprintf("%s", slaveID)}).Log(elekLogTypes.CONSOLE, log.ErrorLevel, "EXECUTOR LOST") } func (s *BaseScheduler) LogFrameworkMessage(executorID *mesos.ExecutorID, slaveID *mesos.SlaveID, message string) { - elekLog.ElektronLogger.WithFields(log.Fields{"Received Framework message from executor": executorID}).Log(elekLogTypes.CONSOLE, + elekLog.WithFields(log.Fields{"Received Framework message from executor": executorID}).Log(elekLogTypes.CONSOLE, log.InfoLevel, message) } func (s *BaseScheduler) LogMesosError(err string) { - elekLog.ElektronLogger.WithFields(log.Fields{"MESOS CONSOLE": fmt.Sprintf("%v", err)}).Log(elekLogTypes.CONSOLE, + elekLog.WithFields(log.Fields{"MESOS CONSOLE": fmt.Sprintf("%v", err)}).Log(elekLogTypes.CONSOLE, log.ErrorLevel, "") } func (s *BaseScheduler) LogElectronError(err error) { - elekLog.ElektronLogger.WithFields(log.Fields{"ELECTRON CONSOLE": fmt.Sprintf("%v", err)}).Log(elekLogTypes.CONSOLE, log.ErrorLevel, "") + elekLog.WithFields(log.Fields{"ELECTRON CONSOLE": fmt.Sprintf("%v", err)}).Log(elekLogTypes.CONSOLE, log.ErrorLevel, "") } func (s *BaseScheduler) LogFrameworkRegistered(frameworkID *mesos.FrameworkID, masterInfo *mesos.MasterInfo) { - elekLog.ElektronLogger.WithFields(log.Fields{"frameworkID": fmt.Sprintf("%s", frameworkID), "master": fmt.Sprintf("%v", masterInfo)}).Log(elekLogTypes.CONSOLE, log.InfoLevel, "FRAMEWORK REGISTERED!") + elekLog.WithFields(log.Fields{"frameworkID": fmt.Sprintf("%s", frameworkID), "master": fmt.Sprintf("%v", masterInfo)}).Log(elekLogTypes.CONSOLE, log.InfoLevel, "FRAMEWORK REGISTERED!") } func (s *BaseScheduler) LogFrameworkReregistered(masterInfo *mesos.MasterInfo) { - elekLog.ElektronLogger.WithFields(log.Fields{"master": fmt.Sprintf("%v", masterInfo)}).Log(elekLogTypes.CONSOLE, + elekLog.WithFields(log.Fields{"master": fmt.Sprintf("%v", masterInfo)}).Log(elekLogTypes.CONSOLE, log.InfoLevel, "Framework re-registered") } func (s *BaseScheduler) LogDisconnected() { - elekLog.ElektronLogger.Log(elekLogTypes.CONSOLE, log.WarnLevel, "Framework disconnected with master") + elekLog.Log(elekLogTypes.CONSOLE, log.WarnLevel, "Framework disconnected with master") } func (s *BaseScheduler) LogTaskStatusUpdate(status *mesos.TaskStatus) { @@ -356,12 +355,12 @@ func (s *BaseScheduler) LogTaskStatusUpdate(status *mesos.TaskStatus) { default: level = log.InfoLevel } - elekLog.ElektronLogger.WithFields(log.Fields{"task": fmt.Sprintf("%s", *status.TaskId.Value), "state": NameFor(status.State)}).Log(elekLogTypes.CONSOLE, level, "Task Status received") + elekLog.WithFields(log.Fields{"task": fmt.Sprintf("%s", *status.TaskId.Value), "state": NameFor(status.State)}).Log(elekLogTypes.CONSOLE, level, "Task Status received") } func (s *BaseScheduler) LogSchedPolicySwitch(name string, nextPolicy SchedPolicyState) { logSPS := func() { - elekLog.ElektronLogger.WithFields(log.Fields{"Name": name}).Log(elekLogTypes.SPS, log.InfoLevel, "") + elekLog.WithFields(log.Fields{"Name": name}).Log(elekLogTypes.SPS, log.InfoLevel, "") } if s.hasReceivedResourceOffers && (s.curSchedPolicy != nextPolicy) { logSPS() @@ -370,10 +369,10 @@ func (s *BaseScheduler) LogSchedPolicySwitch(name string, nextPolicy SchedPolicy } // Logging the size of the scheduling window and the scheduling policy // that is going to schedule the tasks in the scheduling window. - elekLog.ElektronLogger.WithFields(log.Fields{"Window size": fmt.Sprintf("%d", s.schedWindowSize), "Name": name}).Log(elekLogTypes.SCHED_WINDOW, log.InfoLevel, "") + elekLog.WithFields(log.Fields{"Window size": fmt.Sprintf("%d", s.schedWindowSize), "Name": name}).Log(elekLogTypes.SCHED_WINDOW, log.InfoLevel, "") } func (s *BaseScheduler) LogClsfnAndTaskDistOverhead(overhead time.Duration) { // Logging the overhead in microseconds. - elekLog.ElektronLogger.WithFields(log.Fields{"Overhead in microseconds": fmt.Sprintf("%f", float64(overhead.Nanoseconds())/1000.0)}).Log(elekLogTypes.CLSFN_TASKDISTR_OVERHEAD, log.InfoLevel, "") + elekLog.WithFields(log.Fields{"Overhead in microseconds": fmt.Sprintf("%f", float64(overhead.Nanoseconds())/1000.0)}).Log(elekLogTypes.CLSFN_TASKDISTR_OVERHEAD, log.InfoLevel, "") } diff --git a/schedulers/helpers.go b/schedulers/helpers.go index fcc3f05..803fc58 100644 --- a/schedulers/helpers.go +++ b/schedulers/helpers.go @@ -36,10 +36,10 @@ import ( func coLocated(tasks map[string]bool, s BaseScheduler) { for _, task := range tasks { - elekLog.ElektronLogger.WithFields(log.Fields{"Task": task}).Log(elekLogTypes.CONSOLE, log.InfoLevel, "") + elekLog.WithFields(log.Fields{"Task": task}).Log(elekLogTypes.CONSOLE, log.InfoLevel, "") } - elekLog.ElektronLogger.Log(elekLogTypes.CONSOLE, log.InfoLevel, "---------------------") + elekLog.Log(elekLogTypes.CONSOLE, log.InfoLevel, "---------------------") } // Get the powerClass of the given hostname. diff --git a/schedulers/schedPolicy.go b/schedulers/schedPolicy.go index cc6ae14..3dc7bd9 100644 --- a/schedulers/schedPolicy.go +++ b/schedulers/schedPolicy.go @@ -90,7 +90,7 @@ func switchTaskDistBased(baseSchedRef *BaseScheduler) string { // Determine the distribution of tasks in the new scheduling window. taskDist, err := def.GetTaskDistributionInWindow(baseSchedRef.schedWindowSize, baseSchedRef.tasks) baseSchedRef.LogClsfnAndTaskDistOverhead(time.Now().Sub(startTime)) - elekLog.ElektronLogger.WithFields(log.Fields{"Task Distribution": fmt.Sprintf("%f", taskDist)}).Log(elekLogTypes.CONSOLE, + elekLog.WithFields(log.Fields{"Task Distribution": fmt.Sprintf("%f", taskDist)}).Log(elekLogTypes.CONSOLE, log.InfoLevel, "Switching... ") if err != nil { // All the tasks in the window were only classified into 1 cluster. diff --git a/utilities/offerUtils/offerUtils.go b/utilities/offerUtils/offerUtils.go index 0f9338e..5a3fb35 100644 --- a/utilities/offerUtils/offerUtils.go +++ b/utilities/offerUtils/offerUtils.go @@ -90,12 +90,12 @@ func UpdateEnvironment(offer *mesos.Offer) { var host = offer.GetHostname() // If this host is not present in the set of hosts. if _, ok := constants.Hosts[host]; !ok { - elekLog.ElektronLogger.WithFields(log.Fields{"Adding host": host}).Log(elekLogTypes.CONSOLE, log.InfoLevel, "New host detected") + elekLog.WithFields(log.Fields{"Adding host": host}).Log(elekLogTypes.CONSOLE, log.InfoLevel, "New host detected") // Add this host. constants.Hosts[host] = struct{}{} // Get the power class of this host. class := PowerClass(offer) - elekLog.ElektronLogger.WithFields(log.Fields{"host": host, "PowerClass": class}).Log(elekLogTypes.CONSOLE, + elekLog.WithFields(log.Fields{"host": host, "PowerClass": class}).Log(elekLogTypes.CONSOLE, log.InfoLevel, "Registering the power class...") // If new power class, register the power class. if _, ok := constants.PowerClasses[class]; !ok { diff --git a/utilities/schedUtils/schedUtils.go b/utilities/schedUtils/schedUtils.go index c28c201..bde4dcc 100644 --- a/utilities/schedUtils/schedUtils.go +++ b/utilities/schedUtils/schedUtils.go @@ -78,7 +78,7 @@ func (s *fillNextOfferCycle) apply(taskQueue []def.Task) (int, int) { for _, task := range taskQueue { numberOfTasksTraversed++ for i := *task.Instances; i > 0; i-- { - elekLog.ElektronLogger.Logf(elekLogTypes.CONSOLE, log.InfoLevel, + elekLog.Logf(elekLogTypes.CONSOLE, log.InfoLevel, "Checking if Instance #%d of Task[%s] can be scheduled "+ "during the next offer cycle...", i, task.Name) if canSchedule(task) { -- 2.47.2 From 3b70a13cc8b7275cdfae1d3f05382c412f7448f3 Mon Sep 17 00:00:00 2001 From: Pradyumna Kaushik Date: Thu, 5 Dec 2019 21:43:16 -0500 Subject: [PATCH 32/48] refactored logging/types imports to dot imports --- def/taskUtils.go | 6 ++-- pcp/pcp.go | 10 +++---- powerCap/extrema.go | 28 ++++++++--------- powerCap/progressiveExtrema.go | 46 ++++++++++++++-------------- scheduler.go | 6 ++-- schedulers/base.go | 48 +++++++++++++++--------------- schedulers/helpers.go | 6 ++-- schedulers/schedPolicy.go | 4 +-- utilities/offerUtils/offerUtils.go | 6 ++-- utilities/schedUtils/schedUtils.go | 4 +-- 10 files changed, 82 insertions(+), 82 deletions(-) diff --git a/def/taskUtils.go b/def/taskUtils.go index 7de0a34..d9904d4 100644 --- a/def/taskUtils.go +++ b/def/taskUtils.go @@ -27,7 +27,7 @@ import ( "github.com/montanaflynn/stats" log "github.com/sirupsen/logrus" elekLog "github.com/spdfg/elektron/logging" - elekLogTypes "github.com/spdfg/elektron/logging/types" + . "github.com/spdfg/elektron/logging/types" ) // Information about a cluster of tasks. @@ -52,7 +52,7 @@ func (tc TasksToClassify) taskObservationCalculator(task Task) []float64 { } else if task.Watts != 0.0 { return []float64{task.Watts} } else { - elekLog.Log(elekLogTypes.CONSOLE, log.FatalLevel, "Unable to classify tasks. Missing Watts or ClassToWatts attribute in workload") + elekLog.Log(CONSOLE, log.FatalLevel, "Unable to classify tasks. Missing Watts or ClassToWatts attribute in workload") return []float64{0.0} // Won't reach here. } } @@ -107,7 +107,7 @@ func clusterSizeAvgMMMPU(tasks []Task, taskObservation func(task Task) []float64 } else { // skip this value // there is an error in the task config. - elekLog.Log(elekLogTypes.CONSOLE, log.ErrorLevel, err.Error()) + elekLog.Log(CONSOLE, log.ErrorLevel, err.Error()) } } else { // There is only one observation for the task. diff --git a/pcp/pcp.go b/pcp/pcp.go index b2e886f..25e6664 100644 --- a/pcp/pcp.go +++ b/pcp/pcp.go @@ -26,7 +26,7 @@ import ( log "github.com/sirupsen/logrus" elekLog "github.com/spdfg/elektron/logging" - elekLogTypes "github.com/spdfg/elektron/logging/types" + . "github.com/spdfg/elektron/logging/types" ) func Start(quit chan struct{}, logging *bool, pcpConfigFile string) { @@ -47,7 +47,7 @@ func Start(quit chan struct{}, logging *bool, pcpConfigFile string) { scanner.Scan() // Write to logfile - elekLog.Log(elekLogTypes.PCP, log.InfoLevel, scanner.Text()) + elekLog.Log(PCP, log.InfoLevel, scanner.Text()) // Throw away first set of results scanner.Scan() @@ -58,14 +58,14 @@ func Start(quit chan struct{}, logging *bool, pcpConfigFile string) { text := scanner.Text() if *logging { - elekLog.Log(elekLogTypes.PCP, log.InfoLevel, text) + elekLog.Log(PCP, log.InfoLevel, text) } seconds++ } }(logging) - elekLog.Log(elekLogTypes.CONSOLE, log.InfoLevel, "PCP logging started") + elekLog.Log(CONSOLE, log.InfoLevel, "PCP logging started") if err := cmd.Start(); err != nil { log.Fatal(err) @@ -75,7 +75,7 @@ func Start(quit chan struct{}, logging *bool, pcpConfigFile string) { select { case <-quit: - elekLog.Log(elekLogTypes.CONSOLE, log.InfoLevel, "Stopping PCP logging in 5 seconds") + elekLog.Log(CONSOLE, log.InfoLevel, "Stopping PCP logging in 5 seconds") time.Sleep(5 * time.Second) // http://stackoverflow.com/questions/22470193/why-wont-go-kill-a-child-process-correctly diff --git a/powerCap/extrema.go b/powerCap/extrema.go index 6abb65f..066d409 100644 --- a/powerCap/extrema.go +++ b/powerCap/extrema.go @@ -31,7 +31,7 @@ import ( log "github.com/sirupsen/logrus" elekLog "github.com/spdfg/elektron/logging" - elekLogTypes "github.com/spdfg/elektron/logging/types" + . "github.com/spdfg/elektron/logging/types" "github.com/spdfg/elektron/pcp" "github.com/spdfg/elektron/rapl" ) @@ -43,7 +43,7 @@ func StartPCPLogAndExtremaDynamicCap(quit chan struct{}, logging *bool, hiThresh cmd.SysProcAttr = &syscall.SysProcAttr{Setpgid: true} if hiThreshold < loThreshold { - elekLog.Log(elekLogTypes.CONSOLE, log.InfoLevel, "High threshold is lower than low threshold!") + elekLog.Log(CONSOLE, log.InfoLevel, "High threshold is lower than low threshold!") } pipe, err := cmd.StdoutPipe() @@ -59,7 +59,7 @@ func StartPCPLogAndExtremaDynamicCap(quit chan struct{}, logging *bool, hiThresh scanner.Scan() // Write to logfile - elekLog.Log(elekLogTypes.PCP, log.InfoLevel, scanner.Text()) + elekLog.Log(PCP, log.InfoLevel, scanner.Text()) headers := strings.Split(scanner.Text(), ",") @@ -95,12 +95,12 @@ func StartPCPLogAndExtremaDynamicCap(quit chan struct{}, logging *bool, hiThresh if *logging { - elekLog.Log(elekLogTypes.CONSOLE, log.InfoLevel, "Logging PCP...") + elekLog.Log(CONSOLE, log.InfoLevel, "Logging PCP...") text := scanner.Text() split := strings.Split(text, ",") - elekLog.Log(elekLogTypes.PCP, log.InfoLevel, text) + elekLog.Log(PCP, log.InfoLevel, text) totalPower := 0.0 for _, powerIndex := range powerIndexes { @@ -112,7 +112,7 @@ func StartPCPLogAndExtremaDynamicCap(quit chan struct{}, logging *bool, hiThresh powerHistories[host] = powerHistories[host].Next() elekLog.WithFields(log.Fields{"Host": fmt.Sprintf("%s", indexToHost[powerIndex]), - "Power": fmt.Sprintf("%f", (power * pcp.RAPLUnits))}).Log(elekLogTypes.CONSOLE, log.InfoLevel, "") + "Power": fmt.Sprintf("%f", (power * pcp.RAPLUnits))}).Log(CONSOLE, log.InfoLevel, "") totalPower += power } @@ -124,10 +124,10 @@ func StartPCPLogAndExtremaDynamicCap(quit chan struct{}, logging *bool, hiThresh clusterMean := pcp.AverageClusterPowerHistory(clusterPowerHist) elekLog.WithFields(log.Fields{"Total power": fmt.Sprintf("%f %d", clusterPower, clusterPowerHist.Len()), - "Sec Avg": fmt.Sprintf("%f", clusterMean)}).Log(elekLogTypes.CONSOLE, log.InfoLevel, "") + "Sec Avg": fmt.Sprintf("%f", clusterMean)}).Log(CONSOLE, log.InfoLevel, "") if clusterMean > hiThreshold { - elekLog.Log(elekLogTypes.CONSOLE, + elekLog.Log(CONSOLE, log.InfoLevel, "Need to cap a node") // Create statics for all victims and choose one to cap victims := make([]pcp.Victim, 0, 8) @@ -150,9 +150,9 @@ func StartPCPLogAndExtremaDynamicCap(quit chan struct{}, logging *bool, hiThresh cappedHosts[victim.Host] = true orderCapped = append(orderCapped, victim.Host) elekLog.WithFields(log.Fields{"Capping Victim": fmt.Sprintf("%s", victim.Host), - "Avg. Wattage": fmt.Sprintf("%f", victim.Watts*pcp.RAPLUnits)}).Log(elekLogTypes.CONSOLE, log.InfoLevel, "") + "Avg. Wattage": fmt.Sprintf("%f", victim.Watts*pcp.RAPLUnits)}).Log(CONSOLE, log.InfoLevel, "") if err := rapl.Cap(victim.Host, "rapl", 50); err != nil { - elekLog.Log(elekLogTypes.CONSOLE, + elekLog.Log(CONSOLE, log.ErrorLevel, "Error capping host") } @@ -168,9 +168,9 @@ func StartPCPLogAndExtremaDynamicCap(quit chan struct{}, logging *bool, hiThresh cappedHosts[host] = false // User RAPL package to send uncap. log.Printf("Uncapping host %s", host) - elekLog.WithFields(log.Fields{"Uncapped host": host}).Log(elekLogTypes.CONSOLE, log.InfoLevel, "") + elekLog.WithFields(log.Fields{"Uncapped host": host}).Log(CONSOLE, log.InfoLevel, "") if err := rapl.Cap(host, "rapl", 100); err != nil { - elekLog.Log(elekLogTypes.CONSOLE, log.ErrorLevel, "Error capping host") + elekLog.Log(CONSOLE, log.ErrorLevel, "Error capping host") } } } @@ -180,7 +180,7 @@ func StartPCPLogAndExtremaDynamicCap(quit chan struct{}, logging *bool, hiThresh } }(logging, hiThreshold, loThreshold) - elekLog.Log(elekLogTypes.CONSOLE, log.InfoLevel, "PCP logging started") + elekLog.Log(CONSOLE, log.InfoLevel, "PCP logging started") if err := cmd.Start(); err != nil { log.Fatal(err) @@ -190,7 +190,7 @@ func StartPCPLogAndExtremaDynamicCap(quit chan struct{}, logging *bool, hiThresh select { case <-quit: - elekLog.Log(elekLogTypes.CONSOLE, log.InfoLevel, "Stopping PCP logging in 5 seconds") + elekLog.Log(CONSOLE, log.InfoLevel, "Stopping PCP logging in 5 seconds") time.Sleep(5 * time.Second) // http://stackoverflow.com/questions/22470193/why-wont-go-kill-a-child-process-correctly diff --git a/powerCap/progressiveExtrema.go b/powerCap/progressiveExtrema.go index efa2023..2de1bf7 100644 --- a/powerCap/progressiveExtrema.go +++ b/powerCap/progressiveExtrema.go @@ -33,7 +33,7 @@ import ( log "github.com/sirupsen/logrus" "github.com/spdfg/elektron/constants" elekLog "github.com/spdfg/elektron/logging" - elekLogTypes "github.com/spdfg/elektron/logging/types" + . "github.com/spdfg/elektron/logging/types" "github.com/spdfg/elektron/pcp" "github.com/spdfg/elektron/rapl" "github.com/spdfg/elektron/utilities" @@ -56,7 +56,7 @@ func StartPCPLogAndProgressiveExtremaCap(quit chan struct{}, logging *bool, hiTh cmd.SysProcAttr = &syscall.SysProcAttr{Setpgid: true} if hiThreshold < loThreshold { - elekLog.Log(elekLogTypes.CONSOLE, log.InfoLevel, "High threshold is lower than low threshold!") + elekLog.Log(CONSOLE, log.InfoLevel, "High threshold is lower than low threshold!") } pipe, err := cmd.StdoutPipe() @@ -72,7 +72,7 @@ func StartPCPLogAndProgressiveExtremaCap(quit chan struct{}, logging *bool, hiTh scanner.Scan() // Write to logfile - elekLog.Log(elekLogTypes.PCP, log.InfoLevel, scanner.Text()) + elekLog.Log(PCP, log.InfoLevel, scanner.Text()) headers := strings.Split(scanner.Text(), ",") @@ -111,11 +111,11 @@ func StartPCPLogAndProgressiveExtremaCap(quit chan struct{}, logging *bool, hiTh for scanner.Scan() { if *logging { - elekLog.Log(elekLogTypes.CONSOLE, log.InfoLevel, "Logging PCP...") + elekLog.Log(CONSOLE, log.InfoLevel, "Logging PCP...") split := strings.Split(scanner.Text(), ",") text := scanner.Text() - elekLog.Log(elekLogTypes.PCP, log.InfoLevel, text) + elekLog.Log(PCP, log.InfoLevel, text) totalPower := 0.0 for _, powerIndex := range powerIndexes { @@ -127,7 +127,7 @@ func StartPCPLogAndProgressiveExtremaCap(quit chan struct{}, logging *bool, hiTh powerHistories[host] = powerHistories[host].Next() elekLog.WithFields(log.Fields{"Host": fmt.Sprintf("%s", indexToHost[powerIndex]), - "Power": fmt.Sprintf("%f", (power * pcp.RAPLUnits))}).Log(elekLogTypes.CONSOLE, log.InfoLevel, "") + "Power": fmt.Sprintf("%f", (power * pcp.RAPLUnits))}).Log(CONSOLE, log.InfoLevel, "") totalPower += power } clusterPower := totalPower * pcp.RAPLUnits @@ -138,14 +138,14 @@ func StartPCPLogAndProgressiveExtremaCap(quit chan struct{}, logging *bool, hiTh clusterMean := pcp.AverageClusterPowerHistory(clusterPowerHist) elekLog.WithFields(log.Fields{"Total power": fmt.Sprintf("%f %d", clusterPower, clusterPowerHist.Len()), - "Sec Avg": fmt.Sprintf("%f", clusterMean)}).Log(elekLogTypes.CONSOLE, log.InfoLevel, "") + "Sec Avg": fmt.Sprintf("%f", clusterMean)}).Log(CONSOLE, log.InfoLevel, "") if clusterMean >= hiThreshold { - elekLog.Log(elekLogTypes.CONSOLE, log.InfoLevel, "Need to cap a node") + elekLog.Log(CONSOLE, log.InfoLevel, "Need to cap a node") - elekLog.WithFields(log.Fields{"Cap values of capped victims": fmt.Sprintf("%v", cappedVictims)}).Log(elekLogTypes.CONSOLE, log.InfoLevel, "") + elekLog.WithFields(log.Fields{"Cap values of capped victims": fmt.Sprintf("%v", cappedVictims)}).Log(CONSOLE, log.InfoLevel, "") - elekLog.WithFields(log.Fields{"Cap values of victims to uncap": fmt.Sprintf("%v", orderCappedVictims)}).Log(elekLogTypes.CONSOLE, log.InfoLevel, "") + elekLog.WithFields(log.Fields{"Cap values of victims to uncap": fmt.Sprintf("%v", orderCappedVictims)}).Log(CONSOLE, log.InfoLevel, "") // Create statics for all victims and choose one to cap victims := make([]pcp.Victim, 0, 8) @@ -173,10 +173,10 @@ func StartPCPLogAndProgressiveExtremaCap(quit chan struct{}, logging *bool, hiTh // Need to cap this victim. if err := rapl.Cap(victims[i].Host, "rapl", 50.0); err != nil { - elekLog.WithFields(log.Fields{"Error capping host": fmt.Sprintf("%s", victims[i].Host)}).Log(elekLogTypes.CONSOLE, log.ErrorLevel, "") + elekLog.WithFields(log.Fields{"Error capping host": fmt.Sprintf("%s", victims[i].Host)}).Log(CONSOLE, log.ErrorLevel, "") } else { - elekLog.Logf(elekLogTypes.CONSOLE, log.InfoLevel, "Capped host[%s] at %f", victims[i].Host, 50.0) + elekLog.Logf(CONSOLE, log.InfoLevel, "Capped host[%s] at %f", victims[i].Host, 50.0) // Keeping track of this victim and it's cap value cappedVictims[victims[i].Host] = 50.0 newVictimFound = true @@ -200,10 +200,10 @@ func StartPCPLogAndProgressiveExtremaCap(quit chan struct{}, logging *bool, hiTh newCapValue := getNextCapValue(capValue, 2) if err := rapl.Cap(alreadyCappedHosts[i], "rapl", newCapValue); err != nil { - elekLog.WithFields(log.Fields{"Error capping host": fmt.Sprintf("%s", alreadyCappedHosts[i])}).Log(elekLogTypes.CONSOLE, log.ErrorLevel, "") + elekLog.WithFields(log.Fields{"Error capping host": fmt.Sprintf("%s", alreadyCappedHosts[i])}).Log(CONSOLE, log.ErrorLevel, "") } else { // Successful cap - elekLog.Logf(elekLogTypes.CONSOLE, log.InfoLevel, + elekLog.Logf(CONSOLE, log.InfoLevel, "Capped host[%s] at %f", alreadyCappedHosts[i], newCapValue) // Checking whether this victim can be capped further if newCapValue <= constants.LowerCapLimit { @@ -227,15 +227,15 @@ func StartPCPLogAndProgressiveExtremaCap(quit chan struct{}, logging *bool, hiTh } } if !canCapAlreadyCappedVictim { - elekLog.Log(elekLogTypes.CONSOLE, log.InfoLevel, "No Victim left to cap") + elekLog.Log(CONSOLE, log.InfoLevel, "No Victim left to cap") } } } else if clusterMean < loThreshold { - elekLog.Log(elekLogTypes.CONSOLE, log.InfoLevel, "Need to uncap a node") - elekLog.WithFields(log.Fields{"Cap values of capped victims": fmt.Sprintf("%v", cappedVictims)}).Log(elekLogTypes.CONSOLE, log.InfoLevel, "") - elekLog.WithFields(log.Fields{"Cap values of victims to uncap": fmt.Sprintf("%v", orderCappedVictims)}).Log(elekLogTypes.CONSOLE, log.InfoLevel, "") + elekLog.Log(CONSOLE, log.InfoLevel, "Need to uncap a node") + elekLog.WithFields(log.Fields{"Cap values of capped victims": fmt.Sprintf("%v", cappedVictims)}).Log(CONSOLE, log.InfoLevel, "") + elekLog.WithFields(log.Fields{"Cap values of victims to uncap": fmt.Sprintf("%v", orderCappedVictims)}).Log(CONSOLE, log.InfoLevel, "") if len(orderCapped) > 0 { // We pick the host that is capped the most to uncap. orderCappedToSort := utilities.GetPairList(orderCappedVictims) @@ -246,10 +246,10 @@ func StartPCPLogAndProgressiveExtremaCap(quit chan struct{}, logging *bool, hiTh newUncapValue := orderCappedVictims[hostToUncap] * 2.0 if err := rapl.Cap(hostToUncap, "rapl", newUncapValue); err != nil { - elekLog.WithFields(log.Fields{"Error uncapping host": fmt.Sprintf("%s", hostToUncap)}).Log(elekLogTypes.CONSOLE, log.ErrorLevel, "") + elekLog.WithFields(log.Fields{"Error uncapping host": fmt.Sprintf("%s", hostToUncap)}).Log(CONSOLE, log.ErrorLevel, "") } else { // Successful uncap - elekLog.Logf(elekLogTypes.CONSOLE, log.InfoLevel, "Uncapped host[%s] to %f", hostToUncap, newUncapValue) + elekLog.Logf(CONSOLE, log.InfoLevel, "Uncapped host[%s] to %f", hostToUncap, newUncapValue) // Can we uncap this host further. If not, then we remove its entry from orderCapped if newUncapValue >= 100.0 { // can compare using == // Deleting entry from orderCapped @@ -270,7 +270,7 @@ func StartPCPLogAndProgressiveExtremaCap(quit chan struct{}, logging *bool, hiTh } } } else { - elekLog.Log(elekLogTypes.CONSOLE, log.InfoLevel, "No host staged for Uncapped") + elekLog.Log(CONSOLE, log.InfoLevel, "No host staged for Uncapped") } } } @@ -279,7 +279,7 @@ func StartPCPLogAndProgressiveExtremaCap(quit chan struct{}, logging *bool, hiTh }(logging, hiThreshold, loThreshold) - elekLog.Log(elekLogTypes.CONSOLE, log.InfoLevel, "PCP logging started") + elekLog.Log(CONSOLE, log.InfoLevel, "PCP logging started") if err := cmd.Start(); err != nil { log.Fatal(err) } @@ -288,7 +288,7 @@ func StartPCPLogAndProgressiveExtremaCap(quit chan struct{}, logging *bool, hiTh select { case <-quit: - elekLog.Log(elekLogTypes.CONSOLE, log.InfoLevel, "Stopping PCP logging in 5 seconds") + elekLog.Log(CONSOLE, log.InfoLevel, "Stopping PCP logging in 5 seconds") time.Sleep(5 * time.Second) // http://stackoverflow.com/questions/22470193/why-wont-go-kill-a-child-process-correctly diff --git a/scheduler.go b/scheduler.go index 92b2e87..3b7261f 100644 --- a/scheduler.go +++ b/scheduler.go @@ -32,7 +32,7 @@ import ( log "github.com/sirupsen/logrus" "github.com/spdfg/elektron/def" elekLog "github.com/spdfg/elektron/logging" - elekLogTypes "github.com/spdfg/elektron/logging/types" + . "github.com/spdfg/elektron/logging/types" "github.com/spdfg/elektron/pcp" "github.com/spdfg/elektron/powerCap" "github.com/spdfg/elektron/schedulers" @@ -285,8 +285,8 @@ func main() { // Starting the scheduler driver. if status, err := driver.Run(); err != nil { - elekLog.WithFields(log.Fields{"status": status.String(), "error": err.Error()}).Log(elekLogTypes.CONSOLE, + elekLog.WithFields(log.Fields{"status": status.String(), "error": err.Error()}).Log(CONSOLE, log.ErrorLevel, "Framework stopped ") } - elekLog.Log(elekLogTypes.CONSOLE, log.InfoLevel, "Exiting...") + elekLog.Log(CONSOLE, log.InfoLevel, "Exiting...") } diff --git a/schedulers/base.go b/schedulers/base.go index cfb350b..f25a256 100644 --- a/schedulers/base.go +++ b/schedulers/base.go @@ -31,7 +31,7 @@ import ( log "github.com/sirupsen/logrus" "github.com/spdfg/elektron/def" elekLog "github.com/spdfg/elektron/logging" - elekLogTypes "github.com/spdfg/elektron/logging/types" + . "github.com/spdfg/elektron/logging/types" "github.com/spdfg/elektron/utilities" "github.com/spdfg/elektron/utilities/schedUtils" ) @@ -250,29 +250,29 @@ func (s *BaseScheduler) StatusUpdate(driver sched.SchedulerDriver, status *mesos func (s *BaseScheduler) LogTaskStarting(ts *def.Task, offer *mesos.Offer) { if ts == nil { - elekLog.WithFields(log.Fields{"host": fmt.Sprintf("%s", offer.GetHostname())}).Log(elekLogTypes.CONSOLE, log.InfoLevel, "TASKS STARTING...") + elekLog.WithFields(log.Fields{"host": fmt.Sprintf("%s", offer.GetHostname())}).Log(CONSOLE, log.InfoLevel, "TASKS STARTING...") } else { elekLog.WithFields(log.Fields{"task": fmt.Sprintf("%s", ts.Name), "Instance": fmt.Sprintf("%d", *ts.Instances), - "host": fmt.Sprintf("%s", offer.GetHostname())}).Log(elekLogTypes.CONSOLE, log.InfoLevel, "TASK STARTING... ") + "host": fmt.Sprintf("%s", offer.GetHostname())}).Log(CONSOLE, log.InfoLevel, "TASK STARTING... ") } } func (s *BaseScheduler) LogTaskWattsConsideration(ts def.Task, host string, wattsToConsider float64) { - elekLog.WithFields(log.Fields{"task": ts.Name, "host": host, "Watts": fmt.Sprintf("%f", wattsToConsider)}).Log(elekLogTypes.CONSOLE, log.InfoLevel, "Watts considered for ") + elekLog.WithFields(log.Fields{"task": ts.Name, "host": host, "Watts": fmt.Sprintf("%f", wattsToConsider)}).Log(CONSOLE, log.InfoLevel, "Watts considered for ") } func (s *BaseScheduler) LogOffersReceived(offers []*mesos.Offer) { - elekLog.WithFields(log.Fields{"Resource offers received": fmt.Sprintf("%d", len(offers))}).Log(elekLogTypes.CONSOLE, + elekLog.WithFields(log.Fields{"Resource offers received": fmt.Sprintf("%d", len(offers))}).Log(CONSOLE, log.InfoLevel, "") } func (s *BaseScheduler) LogNoPendingTasksDeclineOffers(offer *mesos.Offer) { - elekLog.WithFields(log.Fields{"DECLINING OFFER for host": fmt.Sprintf("%s", offer.GetHostname())}).Log(elekLogTypes.CONSOLE, + elekLog.WithFields(log.Fields{"DECLINING OFFER for host": fmt.Sprintf("%s", offer.GetHostname())}).Log(CONSOLE, log.WarnLevel, "No tasks left to schedule ") } func (s *BaseScheduler) LogNumberOfRunningTasks() { - elekLog.WithFields(log.Fields{"Number of tasks still Running": fmt.Sprintf("%d", s.tasksRunning)}).Log(elekLogTypes.CONSOLE, + elekLog.WithFields(log.Fields{"Number of tasks still Running": fmt.Sprintf("%d", s.tasksRunning)}).Log(CONSOLE, log.InfoLevel, "") } @@ -283,67 +283,67 @@ func (s *BaseScheduler) LogCoLocatedTasks(slaveID string) { buffer.WriteString(fmt.Sprintln(taskName)) } s.TasksRunningMutex.Unlock() - elekLog.WithFields(log.Fields{"Colocated with": fmt.Sprintf("%s", buffer.String())}).Log(elekLogTypes.CONSOLE, + elekLog.WithFields(log.Fields{"Colocated with": fmt.Sprintf("%s", buffer.String())}).Log(CONSOLE, log.InfoLevel, "") } func (s *BaseScheduler) LogSchedTrace(taskToSchedule *mesos.TaskInfo, offer *mesos.Offer) { - elekLog.WithFields(log.Fields{offer.GetHostname(): fmt.Sprintf("%s", taskToSchedule.GetTaskId().GetValue())}).Log(elekLogTypes.SCHED_TRACE, log.InfoLevel, "") + elekLog.WithFields(log.Fields{offer.GetHostname(): fmt.Sprintf("%s", taskToSchedule.GetTaskId().GetValue())}).Log(SCHED_TRACE, log.InfoLevel, "") } func (s *BaseScheduler) LogTerminateScheduler() { - elekLog.Log(elekLogTypes.CONSOLE, log.InfoLevel, "Done scheduling all tasks!") + elekLog.Log(CONSOLE, log.InfoLevel, "Done scheduling all tasks!") } func (s *BaseScheduler) LogInsufficientResourcesDeclineOffer(offer *mesos.Offer, offerResources ...interface{}) { buffer := bytes.Buffer{} buffer.WriteString(fmt.Sprintf("", offerResources...)) - elekLog.WithFields(log.Fields{"Offer Resources": fmt.Sprintf("%s", buffer.String())}).Log(elekLogTypes.CONSOLE, + elekLog.WithFields(log.Fields{"Offer Resources": fmt.Sprintf("%s", buffer.String())}).Log(CONSOLE, log.WarnLevel, "DECLINING OFFER... Offer has insufficient resources to launch a task") } func (s *BaseScheduler) LogOfferRescinded(offerID *mesos.OfferID) { - elekLog.WithFields(log.Fields{"OfferID": fmt.Sprintf("%s", offerID)}).Log(elekLogTypes.CONSOLE, + elekLog.WithFields(log.Fields{"OfferID": fmt.Sprintf("%s", offerID)}).Log(CONSOLE, log.ErrorLevel, "OFFER RESCINDED") } func (s *BaseScheduler) LogSlaveLost(slaveID *mesos.SlaveID) { - elekLog.WithFields(log.Fields{"SlaveID": fmt.Sprintf("%s", slaveID)}).Log(elekLogTypes.CONSOLE, + elekLog.WithFields(log.Fields{"SlaveID": fmt.Sprintf("%s", slaveID)}).Log(CONSOLE, log.ErrorLevel, "SLAVE LOST") } func (s *BaseScheduler) LogExecutorLost(executorID *mesos.ExecutorID, slaveID *mesos.SlaveID) { - elekLog.WithFields(log.Fields{"ExecutorID": fmt.Sprintf("%s", executorID), "SlaveID": fmt.Sprintf("%s", slaveID)}).Log(elekLogTypes.CONSOLE, log.ErrorLevel, "EXECUTOR LOST") + elekLog.WithFields(log.Fields{"ExecutorID": fmt.Sprintf("%s", executorID), "SlaveID": fmt.Sprintf("%s", slaveID)}).Log(CONSOLE, log.ErrorLevel, "EXECUTOR LOST") } func (s *BaseScheduler) LogFrameworkMessage(executorID *mesos.ExecutorID, slaveID *mesos.SlaveID, message string) { - elekLog.WithFields(log.Fields{"Received Framework message from executor": executorID}).Log(elekLogTypes.CONSOLE, + elekLog.WithFields(log.Fields{"Received Framework message from executor": executorID}).Log(CONSOLE, log.InfoLevel, message) } func (s *BaseScheduler) LogMesosError(err string) { - elekLog.WithFields(log.Fields{"MESOS CONSOLE": fmt.Sprintf("%v", err)}).Log(elekLogTypes.CONSOLE, + elekLog.WithFields(log.Fields{"MESOS CONSOLE": fmt.Sprintf("%v", err)}).Log(CONSOLE, log.ErrorLevel, "") } func (s *BaseScheduler) LogElectronError(err error) { - elekLog.WithFields(log.Fields{"ELECTRON CONSOLE": fmt.Sprintf("%v", err)}).Log(elekLogTypes.CONSOLE, log.ErrorLevel, "") + elekLog.WithFields(log.Fields{"ELECTRON CONSOLE": fmt.Sprintf("%v", err)}).Log(CONSOLE, log.ErrorLevel, "") } func (s *BaseScheduler) LogFrameworkRegistered(frameworkID *mesos.FrameworkID, masterInfo *mesos.MasterInfo) { - elekLog.WithFields(log.Fields{"frameworkID": fmt.Sprintf("%s", frameworkID), "master": fmt.Sprintf("%v", masterInfo)}).Log(elekLogTypes.CONSOLE, log.InfoLevel, "FRAMEWORK REGISTERED!") + elekLog.WithFields(log.Fields{"frameworkID": fmt.Sprintf("%s", frameworkID), "master": fmt.Sprintf("%v", masterInfo)}).Log(CONSOLE, log.InfoLevel, "FRAMEWORK REGISTERED!") } func (s *BaseScheduler) LogFrameworkReregistered(masterInfo *mesos.MasterInfo) { - elekLog.WithFields(log.Fields{"master": fmt.Sprintf("%v", masterInfo)}).Log(elekLogTypes.CONSOLE, + elekLog.WithFields(log.Fields{"master": fmt.Sprintf("%v", masterInfo)}).Log(CONSOLE, log.InfoLevel, "Framework re-registered") } func (s *BaseScheduler) LogDisconnected() { - elekLog.Log(elekLogTypes.CONSOLE, log.WarnLevel, "Framework disconnected with master") + elekLog.Log(CONSOLE, log.WarnLevel, "Framework disconnected with master") } func (s *BaseScheduler) LogTaskStatusUpdate(status *mesos.TaskStatus) { @@ -355,12 +355,12 @@ func (s *BaseScheduler) LogTaskStatusUpdate(status *mesos.TaskStatus) { default: level = log.InfoLevel } - elekLog.WithFields(log.Fields{"task": fmt.Sprintf("%s", *status.TaskId.Value), "state": NameFor(status.State)}).Log(elekLogTypes.CONSOLE, level, "Task Status received") + elekLog.WithFields(log.Fields{"task": fmt.Sprintf("%s", *status.TaskId.Value), "state": NameFor(status.State)}).Log(CONSOLE, level, "Task Status received") } func (s *BaseScheduler) LogSchedPolicySwitch(name string, nextPolicy SchedPolicyState) { logSPS := func() { - elekLog.WithFields(log.Fields{"Name": name}).Log(elekLogTypes.SPS, log.InfoLevel, "") + elekLog.WithFields(log.Fields{"Name": name}).Log(SPS, log.InfoLevel, "") } if s.hasReceivedResourceOffers && (s.curSchedPolicy != nextPolicy) { logSPS() @@ -369,10 +369,10 @@ func (s *BaseScheduler) LogSchedPolicySwitch(name string, nextPolicy SchedPolicy } // Logging the size of the scheduling window and the scheduling policy // that is going to schedule the tasks in the scheduling window. - elekLog.WithFields(log.Fields{"Window size": fmt.Sprintf("%d", s.schedWindowSize), "Name": name}).Log(elekLogTypes.SCHED_WINDOW, log.InfoLevel, "") + elekLog.WithFields(log.Fields{"Window size": fmt.Sprintf("%d", s.schedWindowSize), "Name": name}).Log(SCHED_WINDOW, log.InfoLevel, "") } func (s *BaseScheduler) LogClsfnAndTaskDistOverhead(overhead time.Duration) { // Logging the overhead in microseconds. - elekLog.WithFields(log.Fields{"Overhead in microseconds": fmt.Sprintf("%f", float64(overhead.Nanoseconds())/1000.0)}).Log(elekLogTypes.CLSFN_TASKDISTR_OVERHEAD, log.InfoLevel, "") + elekLog.WithFields(log.Fields{"Overhead in microseconds": fmt.Sprintf("%f", float64(overhead.Nanoseconds())/1000.0)}).Log(CLSFN_TASKDISTR_OVERHEAD, log.InfoLevel, "") } diff --git a/schedulers/helpers.go b/schedulers/helpers.go index 803fc58..802c7a7 100644 --- a/schedulers/helpers.go +++ b/schedulers/helpers.go @@ -28,7 +28,7 @@ import ( "github.com/spdfg/elektron/constants" "github.com/spdfg/elektron/def" elekLog "github.com/spdfg/elektron/logging" - elekLogTypes "github.com/spdfg/elektron/logging/types" + . "github.com/spdfg/elektron/logging/types" "github.com/spdfg/elektron/utilities" "github.com/spdfg/elektron/utilities/mesosUtils" ) @@ -36,10 +36,10 @@ import ( func coLocated(tasks map[string]bool, s BaseScheduler) { for _, task := range tasks { - elekLog.WithFields(log.Fields{"Task": task}).Log(elekLogTypes.CONSOLE, log.InfoLevel, "") + elekLog.WithFields(log.Fields{"Task": task}).Log(CONSOLE, log.InfoLevel, "") } - elekLog.Log(elekLogTypes.CONSOLE, log.InfoLevel, "---------------------") + elekLog.Log(CONSOLE, log.InfoLevel, "---------------------") } // Get the powerClass of the given hostname. diff --git a/schedulers/schedPolicy.go b/schedulers/schedPolicy.go index 3dc7bd9..dddcb72 100644 --- a/schedulers/schedPolicy.go +++ b/schedulers/schedPolicy.go @@ -27,7 +27,7 @@ import ( log "github.com/sirupsen/logrus" "github.com/spdfg/elektron/def" elekLog "github.com/spdfg/elektron/logging" - elekLogTypes "github.com/spdfg/elektron/logging/types" + . "github.com/spdfg/elektron/logging/types" ) type SchedPolicyContext interface { @@ -90,7 +90,7 @@ func switchTaskDistBased(baseSchedRef *BaseScheduler) string { // Determine the distribution of tasks in the new scheduling window. taskDist, err := def.GetTaskDistributionInWindow(baseSchedRef.schedWindowSize, baseSchedRef.tasks) baseSchedRef.LogClsfnAndTaskDistOverhead(time.Now().Sub(startTime)) - elekLog.WithFields(log.Fields{"Task Distribution": fmt.Sprintf("%f", taskDist)}).Log(elekLogTypes.CONSOLE, + elekLog.WithFields(log.Fields{"Task Distribution": fmt.Sprintf("%f", taskDist)}).Log(CONSOLE, log.InfoLevel, "Switching... ") if err != nil { // All the tasks in the window were only classified into 1 cluster. diff --git a/utilities/offerUtils/offerUtils.go b/utilities/offerUtils/offerUtils.go index 5a3fb35..69abec7 100644 --- a/utilities/offerUtils/offerUtils.go +++ b/utilities/offerUtils/offerUtils.go @@ -25,7 +25,7 @@ import ( log "github.com/sirupsen/logrus" "github.com/spdfg/elektron/constants" elekLog "github.com/spdfg/elektron/logging" - elekLogTypes "github.com/spdfg/elektron/logging/types" + . "github.com/spdfg/elektron/logging/types" ) func OfferAgg(offer *mesos.Offer) (float64, float64, float64) { @@ -90,12 +90,12 @@ func UpdateEnvironment(offer *mesos.Offer) { var host = offer.GetHostname() // If this host is not present in the set of hosts. if _, ok := constants.Hosts[host]; !ok { - elekLog.WithFields(log.Fields{"Adding host": host}).Log(elekLogTypes.CONSOLE, log.InfoLevel, "New host detected") + elekLog.WithFields(log.Fields{"Adding host": host}).Log(CONSOLE, log.InfoLevel, "New host detected") // Add this host. constants.Hosts[host] = struct{}{} // Get the power class of this host. class := PowerClass(offer) - elekLog.WithFields(log.Fields{"host": host, "PowerClass": class}).Log(elekLogTypes.CONSOLE, + elekLog.WithFields(log.Fields{"host": host, "PowerClass": class}).Log(CONSOLE, log.InfoLevel, "Registering the power class...") // If new power class, register the power class. if _, ok := constants.PowerClasses[class]; !ok { diff --git a/utilities/schedUtils/schedUtils.go b/utilities/schedUtils/schedUtils.go index bde4dcc..534651d 100644 --- a/utilities/schedUtils/schedUtils.go +++ b/utilities/schedUtils/schedUtils.go @@ -22,7 +22,7 @@ import ( log "github.com/sirupsen/logrus" "github.com/spdfg/elektron/def" elekLog "github.com/spdfg/elektron/logging" - elekLogTypes "github.com/spdfg/elektron/logging/types" + . "github.com/spdfg/elektron/logging/types" "github.com/spdfg/elektron/utilities" ) @@ -78,7 +78,7 @@ func (s *fillNextOfferCycle) apply(taskQueue []def.Task) (int, int) { for _, task := range taskQueue { numberOfTasksTraversed++ for i := *task.Instances; i > 0; i-- { - elekLog.Logf(elekLogTypes.CONSOLE, log.InfoLevel, + elekLog.Logf(CONSOLE, log.InfoLevel, "Checking if Instance #%d of Task[%s] can be scheduled "+ "during the next offer cycle...", i, task.Name) if canSchedule(task) { -- 2.47.2 From 12f827c0feed7106b22e2f5474e73b1d8e2da9a0 Mon Sep 17 00:00:00 2001 From: Pradyumna Kaushik Date: Thu, 5 Dec 2019 22:33:28 -0500 Subject: [PATCH 33/48] Used WithField() and Logf() where required. Used elektronLogger#WithField(...) for single key-value pair. Used elektronLogger#Logf(...) where formatted string is required. --- powerCap/extrema.go | 26 +++++------ powerCap/progressiveExtrema.go | 30 +++++++------ scheduler.go | 6 ++- schedulers/base.go | 72 +++++++++++++++++------------- schedulers/helpers.go | 2 +- schedulers/schedPolicy.go | 19 ++++---- utilities/offerUtils/offerUtils.go | 8 ++-- 7 files changed, 91 insertions(+), 72 deletions(-) diff --git a/powerCap/extrema.go b/powerCap/extrema.go index 066d409..34121d4 100644 --- a/powerCap/extrema.go +++ b/powerCap/extrema.go @@ -111,8 +111,10 @@ func StartPCPLogAndExtremaDynamicCap(quit chan struct{}, logging *bool, hiThresh powerHistories[host].Value = power powerHistories[host] = powerHistories[host].Next() - elekLog.WithFields(log.Fields{"Host": fmt.Sprintf("%s", indexToHost[powerIndex]), - "Power": fmt.Sprintf("%f", (power * pcp.RAPLUnits))}).Log(CONSOLE, log.InfoLevel, "") + elekLog.WithFields(log.Fields{ + "Host": indexToHost[powerIndex], + "Power": fmt.Sprintf("%f", power*pcp.RAPLUnits), + }).Log(CONSOLE, log.InfoLevel, "") totalPower += power } @@ -123,12 +125,13 @@ func StartPCPLogAndExtremaDynamicCap(quit chan struct{}, logging *bool, hiThresh clusterMean := pcp.AverageClusterPowerHistory(clusterPowerHist) - elekLog.WithFields(log.Fields{"Total power": fmt.Sprintf("%f %d", clusterPower, clusterPowerHist.Len()), - "Sec Avg": fmt.Sprintf("%f", clusterMean)}).Log(CONSOLE, log.InfoLevel, "") + elekLog.WithFields(log.Fields{ + "Total power": fmt.Sprintf("%f %d Sec", clusterPower, clusterPowerHist.Len()), + "Avg": fmt.Sprintf("%f", clusterMean), + }).Log(CONSOLE, log.InfoLevel, "") if clusterMean > hiThreshold { - elekLog.Log(CONSOLE, - log.InfoLevel, "Need to cap a node") + elekLog.Log(CONSOLE, log.InfoLevel, "Need to cap a node") // Create statics for all victims and choose one to cap victims := make([]pcp.Victim, 0, 8) @@ -149,12 +152,10 @@ func StartPCPLogAndExtremaDynamicCap(quit chan struct{}, logging *bool, hiThresh if !cappedHosts[victim.Host] { cappedHosts[victim.Host] = true orderCapped = append(orderCapped, victim.Host) - elekLog.WithFields(log.Fields{"Capping Victim": fmt.Sprintf("%s", victim.Host), - "Avg. Wattage": fmt.Sprintf("%f", victim.Watts*pcp.RAPLUnits)}).Log(CONSOLE, log.InfoLevel, "") + elekLog.WithField("Avg. Wattage", + fmt.Sprintf("%f", victim.Watts*pcp.RAPLUnits)).Logf(CONSOLE, log.InfoLevel, "Capping Victim %s", victim.Host) if err := rapl.Cap(victim.Host, "rapl", 50); err != nil { - elekLog.Log(CONSOLE, - log.ErrorLevel, - "Error capping host") + elekLog.Log(CONSOLE, log.ErrorLevel, "Error capping host") } break // Only cap one machine at at time. } @@ -167,8 +168,7 @@ func StartPCPLogAndExtremaDynamicCap(quit chan struct{}, logging *bool, hiThresh orderCapped = orderCapped[:len(orderCapped)-1] cappedHosts[host] = false // User RAPL package to send uncap. - log.Printf("Uncapping host %s", host) - elekLog.WithFields(log.Fields{"Uncapped host": host}).Log(CONSOLE, log.InfoLevel, "") + elekLog.Logf(CONSOLE, log.InfoLevel, "Uncapping host %s", host) if err := rapl.Cap(host, "rapl", 100); err != nil { elekLog.Log(CONSOLE, log.ErrorLevel, "Error capping host") } diff --git a/powerCap/progressiveExtrema.go b/powerCap/progressiveExtrema.go index 2de1bf7..6102c39 100644 --- a/powerCap/progressiveExtrema.go +++ b/powerCap/progressiveExtrema.go @@ -126,8 +126,10 @@ func StartPCPLogAndProgressiveExtremaCap(quit chan struct{}, logging *bool, hiTh powerHistories[host].Value = power powerHistories[host] = powerHistories[host].Next() - elekLog.WithFields(log.Fields{"Host": fmt.Sprintf("%s", indexToHost[powerIndex]), - "Power": fmt.Sprintf("%f", (power * pcp.RAPLUnits))}).Log(CONSOLE, log.InfoLevel, "") + elekLog.WithFields(log.Fields{ + "Host": indexToHost[powerIndex], + "Power": fmt.Sprintf("%f", power*pcp.RAPLUnits), + }).Log(CONSOLE, log.InfoLevel, "") totalPower += power } clusterPower := totalPower * pcp.RAPLUnits @@ -137,15 +139,16 @@ func StartPCPLogAndProgressiveExtremaCap(quit chan struct{}, logging *bool, hiTh clusterMean := pcp.AverageClusterPowerHistory(clusterPowerHist) - elekLog.WithFields(log.Fields{"Total power": fmt.Sprintf("%f %d", clusterPower, clusterPowerHist.Len()), - "Sec Avg": fmt.Sprintf("%f", clusterMean)}).Log(CONSOLE, log.InfoLevel, "") + elekLog.WithFields(log.Fields{ + "Total power": fmt.Sprintf("%f %d Sec", clusterPower, clusterPowerHist.Len()), + "Avg": fmt.Sprintf("%f", clusterMean), + }).Log(CONSOLE, log.InfoLevel, "") if clusterMean >= hiThreshold { elekLog.Log(CONSOLE, log.InfoLevel, "Need to cap a node") + elekLog.Logf(CONSOLE, log.InfoLevel, "Cap values of capped victims %v", cappedVictims) + elekLog.Logf(CONSOLE, log.InfoLevel, "Cap values of victims to uncap %v", orderCappedVictims) - elekLog.WithFields(log.Fields{"Cap values of capped victims": fmt.Sprintf("%v", cappedVictims)}).Log(CONSOLE, log.InfoLevel, "") - - elekLog.WithFields(log.Fields{"Cap values of victims to uncap": fmt.Sprintf("%v", orderCappedVictims)}).Log(CONSOLE, log.InfoLevel, "") // Create statics for all victims and choose one to cap victims := make([]pcp.Victim, 0, 8) @@ -173,7 +176,7 @@ func StartPCPLogAndProgressiveExtremaCap(quit chan struct{}, logging *bool, hiTh // Need to cap this victim. if err := rapl.Cap(victims[i].Host, "rapl", 50.0); err != nil { - elekLog.WithFields(log.Fields{"Error capping host": fmt.Sprintf("%s", victims[i].Host)}).Log(CONSOLE, log.ErrorLevel, "") + elekLog.Logf(CONSOLE, log.ErrorLevel, "Error capping host %s", victims[i].Host) } else { elekLog.Logf(CONSOLE, log.InfoLevel, "Capped host[%s] at %f", victims[i].Host, 50.0) @@ -200,11 +203,10 @@ func StartPCPLogAndProgressiveExtremaCap(quit chan struct{}, logging *bool, hiTh newCapValue := getNextCapValue(capValue, 2) if err := rapl.Cap(alreadyCappedHosts[i], "rapl", newCapValue); err != nil { - elekLog.WithFields(log.Fields{"Error capping host": fmt.Sprintf("%s", alreadyCappedHosts[i])}).Log(CONSOLE, log.ErrorLevel, "") + elekLog.Logf(CONSOLE, log.ErrorLevel, "Error capping host %s", alreadyCappedHosts[i]) } else { // Successful cap - elekLog.Logf(CONSOLE, log.InfoLevel, - "Capped host[%s] at %f", alreadyCappedHosts[i], newCapValue) + elekLog.Logf(CONSOLE, log.InfoLevel, "Capped host[%s] at %f", alreadyCappedHosts[i], newCapValue) // Checking whether this victim can be capped further if newCapValue <= constants.LowerCapLimit { // Deleting victim from cappedVictims. @@ -234,8 +236,8 @@ func StartPCPLogAndProgressiveExtremaCap(quit chan struct{}, logging *bool, hiTh } else if clusterMean < loThreshold { elekLog.Log(CONSOLE, log.InfoLevel, "Need to uncap a node") - elekLog.WithFields(log.Fields{"Cap values of capped victims": fmt.Sprintf("%v", cappedVictims)}).Log(CONSOLE, log.InfoLevel, "") - elekLog.WithFields(log.Fields{"Cap values of victims to uncap": fmt.Sprintf("%v", orderCappedVictims)}).Log(CONSOLE, log.InfoLevel, "") + elekLog.Logf(CONSOLE, log.InfoLevel, "Cap values of capped victims - %v", cappedVictims) + elekLog.Logf(CONSOLE, log.InfoLevel, "Cap values of victims to uncap - %v", orderCappedVictims) if len(orderCapped) > 0 { // We pick the host that is capped the most to uncap. orderCappedToSort := utilities.GetPairList(orderCappedVictims) @@ -246,7 +248,7 @@ func StartPCPLogAndProgressiveExtremaCap(quit chan struct{}, logging *bool, hiTh newUncapValue := orderCappedVictims[hostToUncap] * 2.0 if err := rapl.Cap(hostToUncap, "rapl", newUncapValue); err != nil { - elekLog.WithFields(log.Fields{"Error uncapping host": fmt.Sprintf("%s", hostToUncap)}).Log(CONSOLE, log.ErrorLevel, "") + elekLog.Logf(CONSOLE, log.ErrorLevel, "Error uncapping host %s", hostToUncap) } else { // Successful uncap elekLog.Logf(CONSOLE, log.InfoLevel, "Uncapped host[%s] to %f", hostToUncap, newUncapValue) diff --git a/scheduler.go b/scheduler.go index 3b7261f..89f77e3 100644 --- a/scheduler.go +++ b/scheduler.go @@ -285,8 +285,10 @@ func main() { // Starting the scheduler driver. if status, err := driver.Run(); err != nil { - elekLog.WithFields(log.Fields{"status": status.String(), "error": err.Error()}).Log(CONSOLE, - log.ErrorLevel, "Framework stopped ") + elekLog.WithFields(log.Fields{ + "status": status.String(), + "error": err.Error(), + }).Log(CONSOLE, log.ErrorLevel, "Framework stopped ") } elekLog.Log(CONSOLE, log.InfoLevel, "Exiting...") } diff --git a/schedulers/base.go b/schedulers/base.go index f25a256..eadf1f3 100644 --- a/schedulers/base.go +++ b/schedulers/base.go @@ -250,30 +250,34 @@ func (s *BaseScheduler) StatusUpdate(driver sched.SchedulerDriver, status *mesos func (s *BaseScheduler) LogTaskStarting(ts *def.Task, offer *mesos.Offer) { if ts == nil { - elekLog.WithFields(log.Fields{"host": fmt.Sprintf("%s", offer.GetHostname())}).Log(CONSOLE, log.InfoLevel, "TASKS STARTING...") + elekLog.WithField("host", offer.GetHostname()).Log(CONSOLE, log.InfoLevel, "TASKS STARTING...") } else { - elekLog.WithFields(log.Fields{"task": fmt.Sprintf("%s", ts.Name), "Instance": fmt.Sprintf("%d", *ts.Instances), - "host": fmt.Sprintf("%s", offer.GetHostname())}).Log(CONSOLE, log.InfoLevel, "TASK STARTING... ") + elekLog.WithFields(log.Fields{ + "task": ts.Name, + "Instance": fmt.Sprintf("%d", *ts.Instances), + "host": offer.GetHostname(), + }).Log(CONSOLE, log.InfoLevel, "TASK STARTING... ") } } func (s *BaseScheduler) LogTaskWattsConsideration(ts def.Task, host string, wattsToConsider float64) { - elekLog.WithFields(log.Fields{"task": ts.Name, "host": host, "Watts": fmt.Sprintf("%f", wattsToConsider)}).Log(CONSOLE, log.InfoLevel, "Watts considered for ") + elekLog.WithFields(log.Fields{ + "task": ts.Name, + "host": host, + "Watts": fmt.Sprintf("%f", wattsToConsider), + }).Log(CONSOLE, log.InfoLevel, "Watts considered for ") } func (s *BaseScheduler) LogOffersReceived(offers []*mesos.Offer) { - elekLog.WithFields(log.Fields{"Resource offers received": fmt.Sprintf("%d", len(offers))}).Log(CONSOLE, - log.InfoLevel, "") + elekLog.WithField("numOffers", fmt.Sprintf("%d", len(offers))).Log(CONSOLE, log.InfoLevel, "Resource offers received") } func (s *BaseScheduler) LogNoPendingTasksDeclineOffers(offer *mesos.Offer) { - elekLog.WithFields(log.Fields{"DECLINING OFFER for host": fmt.Sprintf("%s", offer.GetHostname())}).Log(CONSOLE, - log.WarnLevel, "No tasks left to schedule ") + elekLog.Logf(CONSOLE, log.WarnLevel, "DECLINING OFFER for host %s. No tasks left to schedule", offer.GetHostname()) } func (s *BaseScheduler) LogNumberOfRunningTasks() { - elekLog.WithFields(log.Fields{"Number of tasks still Running": fmt.Sprintf("%d", s.tasksRunning)}).Log(CONSOLE, - log.InfoLevel, "") + elekLog.Logf(CONSOLE, log.InfoLevel, "Number of tasks still running %d", s.tasksRunning) } func (s *BaseScheduler) LogCoLocatedTasks(slaveID string) { @@ -283,12 +287,11 @@ func (s *BaseScheduler) LogCoLocatedTasks(slaveID string) { buffer.WriteString(fmt.Sprintln(taskName)) } s.TasksRunningMutex.Unlock() - elekLog.WithFields(log.Fields{"Colocated with": fmt.Sprintf("%s", buffer.String())}).Log(CONSOLE, - log.InfoLevel, "") + elekLog.WithField("Tasks", buffer.String()).Log(CONSOLE, log.InfoLevel, "Colocated with") } func (s *BaseScheduler) LogSchedTrace(taskToSchedule *mesos.TaskInfo, offer *mesos.Offer) { - elekLog.WithFields(log.Fields{offer.GetHostname(): fmt.Sprintf("%s", taskToSchedule.GetTaskId().GetValue())}).Log(SCHED_TRACE, log.InfoLevel, "") + elekLog.WithField(offer.GetHostname(), taskToSchedule.GetTaskId().GetValue()).Log(SCHED_TRACE, log.InfoLevel, "") } func (s *BaseScheduler) LogTerminateScheduler() { @@ -299,47 +302,48 @@ func (s *BaseScheduler) LogInsufficientResourcesDeclineOffer(offer *mesos.Offer, offerResources ...interface{}) { buffer := bytes.Buffer{} buffer.WriteString(fmt.Sprintf("", offerResources...)) - elekLog.WithFields(log.Fields{"Offer Resources": fmt.Sprintf("%s", buffer.String())}).Log(CONSOLE, + elekLog.WithField("Offer Resources", buffer.String()).Log(CONSOLE, log.WarnLevel, "DECLINING OFFER... Offer has insufficient resources to launch a task") } func (s *BaseScheduler) LogOfferRescinded(offerID *mesos.OfferID) { - elekLog.WithFields(log.Fields{"OfferID": fmt.Sprintf("%s", offerID)}).Log(CONSOLE, - log.ErrorLevel, "OFFER RESCINDED") + elekLog.WithField("OfferID", *offerID.Value).Log(CONSOLE, log.ErrorLevel, "OFFER RESCINDED") } func (s *BaseScheduler) LogSlaveLost(slaveID *mesos.SlaveID) { - elekLog.WithFields(log.Fields{"SlaveID": fmt.Sprintf("%s", slaveID)}).Log(CONSOLE, - log.ErrorLevel, "SLAVE LOST") + elekLog.WithField("SlaveID", *slaveID.Value).Log(CONSOLE, log.ErrorLevel, "SLAVE LOST") } func (s *BaseScheduler) LogExecutorLost(executorID *mesos.ExecutorID, slaveID *mesos.SlaveID) { - elekLog.WithFields(log.Fields{"ExecutorID": fmt.Sprintf("%s", executorID), "SlaveID": fmt.Sprintf("%s", slaveID)}).Log(CONSOLE, log.ErrorLevel, "EXECUTOR LOST") + elekLog.WithFields(log.Fields{ + "ExecutorID": executorID, + "SlaveID": slaveID, + }).Log(CONSOLE, log.ErrorLevel, "EXECUTOR LOST") } func (s *BaseScheduler) LogFrameworkMessage(executorID *mesos.ExecutorID, slaveID *mesos.SlaveID, message string) { - elekLog.WithFields(log.Fields{"Received Framework message from executor": executorID}).Log(CONSOLE, - log.InfoLevel, message) + elekLog.Logf(CONSOLE, log.InfoLevel, "Received Framework message from executor %v", executorID) } func (s *BaseScheduler) LogMesosError(err string) { - elekLog.WithFields(log.Fields{"MESOS CONSOLE": fmt.Sprintf("%v", err)}).Log(CONSOLE, - log.ErrorLevel, "") + elekLog.Logf(CONSOLE, log.ErrorLevel, "MESOS CONSOLE %v", err) } func (s *BaseScheduler) LogElectronError(err error) { - elekLog.WithFields(log.Fields{"ELECTRON CONSOLE": fmt.Sprintf("%v", err)}).Log(CONSOLE, log.ErrorLevel, "") + elekLog.Logf(CONSOLE, log.ErrorLevel, "ELEKTRON CONSOLE %v", err) } func (s *BaseScheduler) LogFrameworkRegistered(frameworkID *mesos.FrameworkID, masterInfo *mesos.MasterInfo) { - elekLog.WithFields(log.Fields{"frameworkID": fmt.Sprintf("%s", frameworkID), "master": fmt.Sprintf("%v", masterInfo)}).Log(CONSOLE, log.InfoLevel, "FRAMEWORK REGISTERED!") + elekLog.WithFields(log.Fields{ + "frameworkID": frameworkID, + "master": fmt.Sprintf("%v", masterInfo), + }).Log(CONSOLE, log.InfoLevel, "FRAMEWORK REGISTERED!") } func (s *BaseScheduler) LogFrameworkReregistered(masterInfo *mesos.MasterInfo) { - elekLog.WithFields(log.Fields{"master": fmt.Sprintf("%v", masterInfo)}).Log(CONSOLE, - log.InfoLevel, "Framework re-registered") + elekLog.WithField("master", fmt.Sprintf("%v", masterInfo)).Log(CONSOLE, log.InfoLevel, "Framework re-registered") } func (s *BaseScheduler) LogDisconnected() { @@ -355,12 +359,15 @@ func (s *BaseScheduler) LogTaskStatusUpdate(status *mesos.TaskStatus) { default: level = log.InfoLevel } - elekLog.WithFields(log.Fields{"task": fmt.Sprintf("%s", *status.TaskId.Value), "state": NameFor(status.State)}).Log(CONSOLE, level, "Task Status received") + elekLog.WithFields(log.Fields{ + "task": *status.TaskId.Value, + "state": NameFor(status.State), + }).Log(CONSOLE, level, "Task Status received") } func (s *BaseScheduler) LogSchedPolicySwitch(name string, nextPolicy SchedPolicyState) { logSPS := func() { - elekLog.WithFields(log.Fields{"Name": name}).Log(SPS, log.InfoLevel, "") + elekLog.WithField("Name", name).Log(SPS, log.InfoLevel, "") } if s.hasReceivedResourceOffers && (s.curSchedPolicy != nextPolicy) { logSPS() @@ -369,10 +376,13 @@ func (s *BaseScheduler) LogSchedPolicySwitch(name string, nextPolicy SchedPolicy } // Logging the size of the scheduling window and the scheduling policy // that is going to schedule the tasks in the scheduling window. - elekLog.WithFields(log.Fields{"Window size": fmt.Sprintf("%d", s.schedWindowSize), "Name": name}).Log(SCHED_WINDOW, log.InfoLevel, "") + elekLog.WithFields(log.Fields{ + "Window size": fmt.Sprintf("%d", s.schedWindowSize), + "Name": name, + }).Log(SCHED_WINDOW, log.InfoLevel, "") } func (s *BaseScheduler) LogClsfnAndTaskDistOverhead(overhead time.Duration) { // Logging the overhead in microseconds. - elekLog.WithFields(log.Fields{"Overhead in microseconds": fmt.Sprintf("%f", float64(overhead.Nanoseconds())/1000.0)}).Log(CLSFN_TASKDISTR_OVERHEAD, log.InfoLevel, "") + elekLog.WithField("Overhead in microseconds", fmt.Sprintf("%f", float64(overhead.Nanoseconds())/1000.0)).Log(CLSFN_TASKDISTR_OVERHEAD, log.InfoLevel, "") } diff --git a/schedulers/helpers.go b/schedulers/helpers.go index 802c7a7..f335f38 100644 --- a/schedulers/helpers.go +++ b/schedulers/helpers.go @@ -36,7 +36,7 @@ import ( func coLocated(tasks map[string]bool, s BaseScheduler) { for _, task := range tasks { - elekLog.WithFields(log.Fields{"Task": task}).Log(CONSOLE, log.InfoLevel, "") + elekLog.WithField("Task", fmt.Sprintf("%v", task)).Log(CONSOLE, log.InfoLevel, "") } elekLog.Log(CONSOLE, log.InfoLevel, "---------------------") diff --git a/schedulers/schedPolicy.go b/schedulers/schedPolicy.go index dddcb72..40f949c 100644 --- a/schedulers/schedPolicy.go +++ b/schedulers/schedPolicy.go @@ -90,8 +90,7 @@ func switchTaskDistBased(baseSchedRef *BaseScheduler) string { // Determine the distribution of tasks in the new scheduling window. taskDist, err := def.GetTaskDistributionInWindow(baseSchedRef.schedWindowSize, baseSchedRef.tasks) baseSchedRef.LogClsfnAndTaskDistOverhead(time.Now().Sub(startTime)) - elekLog.WithFields(log.Fields{"Task Distribution": fmt.Sprintf("%f", taskDist)}).Log(CONSOLE, - log.InfoLevel, "Switching... ") + elekLog.WithField("Task Distribution", fmt.Sprintf("%f", taskDist)).Log(CONSOLE, log.InfoLevel, "Switching... ") if err != nil { // All the tasks in the window were only classified into 1 cluster. // Max-Min and Max-GreedyMins would work the same way as Bin-Packing for this situation. @@ -219,9 +218,11 @@ func (bsps *baseSchedPolicyState) SwitchIfNecessary(spc SchedPolicyContext) { switchToPolicyName = switchBasedOn[baseSchedRef.schedPolSwitchCriteria](baseSchedRef) } else { // We continue working with the currently deployed scheduling policy. - log.Println("Continuing with the current scheduling policy...") - log.Printf("TasksScheduled[%d], SchedWindowSize[%d]", bsps.numTasksScheduled, - baseSchedRef.schedWindowSize) + elekLog.Log(CONSOLE, log.InfoLevel, "Continuing with the current scheduling policy...") + elekLog.WithFields(log.Fields{ + "TasksScheduled": fmt.Sprintf("%d", bsps.numTasksScheduled), + "SchedWindowSize": fmt.Sprintf("%d", baseSchedRef.schedWindowSize), + }).Log(CONSOLE, log.InfoLevel, "") return } } @@ -233,9 +234,11 @@ func (bsps *baseSchedPolicyState) SwitchIfNecessary(spc SchedPolicyContext) { bsps.numTasksScheduled = 0 } else { // We continue working with the currently deployed scheduling policy. - log.Println("Continuing with the current scheduling policy...") - log.Printf("TasksScheduled[%d], SchedWindowSize[%d]", bsps.numTasksScheduled, - baseSchedRef.schedWindowSize) + elekLog.Log(CONSOLE, log.InfoLevel, "Continuing with the current scheduling policy...") + elekLog.WithFields(log.Fields{ + "TasksScheduled": fmt.Sprintf("%d", bsps.numTasksScheduled), + "SchedWindowSize": fmt.Sprintf("%d", baseSchedRef.schedWindowSize), + }).Log(CONSOLE, log.InfoLevel, "") return } } diff --git a/utilities/offerUtils/offerUtils.go b/utilities/offerUtils/offerUtils.go index 69abec7..15919c3 100644 --- a/utilities/offerUtils/offerUtils.go +++ b/utilities/offerUtils/offerUtils.go @@ -90,13 +90,15 @@ func UpdateEnvironment(offer *mesos.Offer) { var host = offer.GetHostname() // If this host is not present in the set of hosts. if _, ok := constants.Hosts[host]; !ok { - elekLog.WithFields(log.Fields{"Adding host": host}).Log(CONSOLE, log.InfoLevel, "New host detected") + elekLog.WithField("host", host).Log(CONSOLE, log.InfoLevel, "New host detected") // Add this host. constants.Hosts[host] = struct{}{} // Get the power class of this host. class := PowerClass(offer) - elekLog.WithFields(log.Fields{"host": host, "PowerClass": class}).Log(CONSOLE, - log.InfoLevel, "Registering the power class...") + elekLog.WithFields(log.Fields{ + "host": host, + "PowerClass": class, + }).Log(CONSOLE, log.InfoLevel, "Registering the power class...") // If new power class, register the power class. if _, ok := constants.PowerClasses[class]; !ok { constants.PowerClasses[class] = make(map[string]struct{}) -- 2.47.2 From f084eddd68fd824fb0b0114b99890cb913164687 Mon Sep 17 00:00:00 2001 From: Pradyumna Kaushik Date: Thu, 5 Dec 2019 22:49:19 -0500 Subject: [PATCH 34/48] passing strings instead of pointers as values. --- schedulers/base.go | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/schedulers/base.go b/schedulers/base.go index eadf1f3..699ad90 100644 --- a/schedulers/base.go +++ b/schedulers/base.go @@ -316,8 +316,8 @@ func (s *BaseScheduler) LogSlaveLost(slaveID *mesos.SlaveID) { func (s *BaseScheduler) LogExecutorLost(executorID *mesos.ExecutorID, slaveID *mesos.SlaveID) { elekLog.WithFields(log.Fields{ - "ExecutorID": executorID, - "SlaveID": slaveID, + "ExecutorID": *executorID.Value, + "SlaveID": *slaveID.Value, }).Log(CONSOLE, log.ErrorLevel, "EXECUTOR LOST") } @@ -337,7 +337,7 @@ func (s *BaseScheduler) LogElectronError(err error) { func (s *BaseScheduler) LogFrameworkRegistered(frameworkID *mesos.FrameworkID, masterInfo *mesos.MasterInfo) { elekLog.WithFields(log.Fields{ - "frameworkID": frameworkID, + "frameworkID": *frameworkID.Value, "master": fmt.Sprintf("%v", masterInfo), }).Log(CONSOLE, log.InfoLevel, "FRAMEWORK REGISTERED!") } -- 2.47.2 From 5a53998942714c1606c7714621d4017c269826ce Mon Sep 17 00:00:00 2001 From: Pradyumna Kaushik Date: Thu, 5 Dec 2019 23:02:08 -0500 Subject: [PATCH 35/48] fixed visibility of structs. --- logging/clsfnTaskDistrOverheadLogger.go | 16 ++++++++-------- logging/consoleLogger.go | 16 ++++++++-------- ...ElektronFormatter.go => elektronFormatter.go} | 4 ++-- logging/logger.go | 16 ++++++++-------- logging/loggerConfig.go | 6 +++--- logging/pcpLogger.go | 16 ++++++++-------- logging/schedPolicySwitchLogger.go | 16 ++++++++-------- logging/schedTraceLogger.go | 16 ++++++++-------- logging/schedWindowLogger.go | 16 ++++++++-------- 9 files changed, 61 insertions(+), 61 deletions(-) rename logging/{ElektronFormatter.go => elektronFormatter.go} (87%) diff --git a/logging/clsfnTaskDistrOverheadLogger.go b/logging/clsfnTaskDistrOverheadLogger.go index 2d2777b..69e2ab0 100644 --- a/logging/clsfnTaskDistrOverheadLogger.go +++ b/logging/clsfnTaskDistrOverheadLogger.go @@ -8,19 +8,19 @@ import ( log "github.com/sirupsen/logrus" ) -type ClsfnTaskDistrOverheadLogger struct { +type clsfnTaskDistrOverheadLogger struct { baseElektronLogger } -func NewClsfnTaskDistrOverheadLogger( - config *LoggerConfig, +func newClsfnTaskDistrOverheadLogger( + config *loggerConfig, b *baseLogData, logType int, prefix string, logger *log.Logger, - logDir *logDirectory) *ClsfnTaskDistrOverheadLogger { + logDir *logDirectory) *clsfnTaskDistrOverheadLogger { - cLog := &ClsfnTaskDistrOverheadLogger{ + cLog := &clsfnTaskDistrOverheadLogger{ baseElektronLogger: baseElektronLogger{ baseLogData: b, config: struct { @@ -42,7 +42,7 @@ func NewClsfnTaskDistrOverheadLogger( cLog.createLogFile(prefix) return cLog } -func (cLog ClsfnTaskDistrOverheadLogger) Log(logType int, level log.Level, message string) { +func (cLog clsfnTaskDistrOverheadLogger) Log(logType int, level log.Level, message string) { if cLog.logType == logType { if cLog.isEnabled() { if cLog.config.AllowOnConsole { @@ -63,7 +63,7 @@ func (cLog ClsfnTaskDistrOverheadLogger) Log(logType int, level log.Level, messa } } -func (cLog ClsfnTaskDistrOverheadLogger) Logf(logType int, level log.Level, msgFmtString string, args ...interface{}) { +func (cLog clsfnTaskDistrOverheadLogger) Logf(logType int, level log.Level, msgFmtString string, args ...interface{}) { if cLog.logType == logType { if cLog.isEnabled() { if cLog.config.AllowOnConsole { @@ -83,7 +83,7 @@ func (cLog ClsfnTaskDistrOverheadLogger) Logf(logType int, level log.Level, msgF } } -func (cLog *ClsfnTaskDistrOverheadLogger) createLogFile(prefix string) { +func (cLog *clsfnTaskDistrOverheadLogger) createLogFile(prefix string) { if cLog.isEnabled() { filename := strings.Join([]string{prefix, cLog.config.FilenameExtension}, "") diff --git a/logging/consoleLogger.go b/logging/consoleLogger.go index ab449b9..2bc7666 100644 --- a/logging/consoleLogger.go +++ b/logging/consoleLogger.go @@ -8,20 +8,20 @@ import ( "strings" ) -type ConsoleLogger struct { +type consoleLogger struct { baseElektronLogger MinLogLevel string } -func NewConsoleLogger( - config *LoggerConfig, +func newConsoleLogger( + config *loggerConfig, b *baseLogData, logType int, prefix string, logger *log.Logger, - logDir *logDirectory) *ConsoleLogger { + logDir *logDirectory) *consoleLogger { - cLog := &ConsoleLogger{ + cLog := &consoleLogger{ baseElektronLogger: baseElektronLogger{ baseLogData: b, config: struct { @@ -46,7 +46,7 @@ func NewConsoleLogger( return cLog } -func (cLog ConsoleLogger) Log(logType int, level log.Level, message string) { +func (cLog consoleLogger) Log(logType int, level log.Level, message string) { if logType <= cLog.logType { if cLog.isEnabled() { cLog.logger.SetOutput(os.Stdout) @@ -65,7 +65,7 @@ func (cLog ConsoleLogger) Log(logType int, level log.Level, message string) { } } -func (cLog ConsoleLogger) Logf(logType int, level log.Level, msgFmtString string, args ...interface{}) { +func (cLog consoleLogger) Logf(logType int, level log.Level, msgFmtString string, args ...interface{}) { if logType <= cLog.logType { if cLog.isEnabled() { cLog.logger.SetOutput(os.Stdout) @@ -83,7 +83,7 @@ func (cLog ConsoleLogger) Logf(logType int, level log.Level, msgFmtString string } } -func (cLog *ConsoleLogger) createLogFile(prefix string) { +func (cLog *consoleLogger) createLogFile(prefix string) { // Create log file for the type if it is enabled. if cLog.isEnabled() { filename := strings.Join([]string{prefix, cLog.config.FilenameExtension}, "") diff --git a/logging/ElektronFormatter.go b/logging/elektronFormatter.go similarity index 87% rename from logging/ElektronFormatter.go rename to logging/elektronFormatter.go index 1ea7ea0..8116110 100644 --- a/logging/ElektronFormatter.go +++ b/logging/elektronFormatter.go @@ -8,11 +8,11 @@ import ( log "github.com/sirupsen/logrus" ) -type ElektronFormatter struct { +type elektronFormatter struct { TimestampFormat string } -func (f ElektronFormatter) Format(entry *log.Entry) ([]byte, error) { +func (f elektronFormatter) Format(entry *log.Entry) ([]byte, error) { var b *bytes.Buffer if entry.Buffer != nil { diff --git a/logging/logger.go b/logging/logger.go index 413fffb..b8c65d1 100644 --- a/logging/logger.go +++ b/logging/logger.go @@ -10,8 +10,8 @@ import ( . "github.com/spdfg/elektron/logging/types" ) -// var config LoggerConfig -var formatter ElektronFormatter +// var config loggerConfig +var formatter elektronFormatter var elektronLoggerInstance elektronLogger type elektronLogger interface { @@ -103,12 +103,12 @@ func BuildLogger(prefix string, logConfigFilename string) error { if config, err := GetConfig(logConfigFilename); err != nil { return errors.Wrap(err, "Failed to build logger") } else { - cLog := NewConsoleLogger(config, b, CONSOLE, prefix, logger, logDir) - pLog := NewPCPLogger(config, b, PCP, prefix, logger, logDir) - schedTraceLog := NewSchedTraceLogger(config, b, SCHED_TRACE, prefix, logger, logDir) - spsLog := NewSchedPolicySwitchLogger(config, b, SPS, prefix, logger, logDir) - schedWindowLog := NewSchedWindowLogger(config, b, SCHED_WINDOW, prefix, logger, logDir) - tskDistLog := NewClsfnTaskDistrOverheadLogger(config, b, CLSFN_TASKDISTR_OVERHEAD, prefix, logger, logDir) + cLog := newConsoleLogger(config, b, CONSOLE, prefix, logger, logDir) + pLog := newPCPLogger(config, b, PCP, prefix, logger, logDir) + schedTraceLog := newSchedTraceLogger(config, b, SCHED_TRACE, prefix, logger, logDir) + spsLog := newSchedPolicySwitchLogger(config, b, SPS, prefix, logger, logDir) + schedWindowLog := newSchedWindowLogger(config, b, SCHED_WINDOW, prefix, logger, logDir) + tskDistLog := newClsfnTaskDistrOverheadLogger(config, b, CLSFN_TASKDISTR_OVERHEAD, prefix, logger, logDir) head.setNext(cLog) cLog.setNext(pLog) diff --git a/logging/loggerConfig.go b/logging/loggerConfig.go index cbf3cbc..49297cc 100644 --- a/logging/loggerConfig.go +++ b/logging/loggerConfig.go @@ -7,7 +7,7 @@ import ( "io/ioutil" ) -type LoggerConfig struct { +type loggerConfig struct { SchedTraceConfig struct { Enabled bool `yaml:"enabled"` FilenameExtension string `yaml:"filenameExtension"` @@ -48,14 +48,14 @@ type LoggerConfig struct { Format []string `yaml:"format"` } -func GetConfig(logConfigFilename string) (*LoggerConfig, error) { +func GetConfig(logConfigFilename string) (*loggerConfig, error) { yamlFile, err := ioutil.ReadFile(logConfigFilename) if err != nil { return nil, errors.Wrap(err, "failed to read log config file") } - c := &LoggerConfig{} + c := &loggerConfig{} err = yaml.Unmarshal(yamlFile, c) if err != nil { log.Fatalf("Error in unmarshalling yaml: %v", err) diff --git a/logging/pcpLogger.go b/logging/pcpLogger.go index 52c1fbe..7767f4d 100644 --- a/logging/pcpLogger.go +++ b/logging/pcpLogger.go @@ -8,19 +8,19 @@ import ( log "github.com/sirupsen/logrus" ) -type PCPLogger struct { +type pcpLogger struct { baseElektronLogger } -func NewPCPLogger( - config *LoggerConfig, +func newPCPLogger( + config *loggerConfig, b *baseLogData, logType int, prefix string, logger *log.Logger, - logDir *logDirectory) *PCPLogger { + logDir *logDirectory) *pcpLogger { - pLog := &PCPLogger{ + pLog := &pcpLogger{ baseElektronLogger: baseElektronLogger{ baseLogData: b, config: struct { @@ -43,7 +43,7 @@ func NewPCPLogger( return pLog } -func (pLog PCPLogger) Log(logType int, level log.Level, message string) { +func (pLog pcpLogger) Log(logType int, level log.Level, message string) { if pLog.logType == logType { if pLog.isEnabled() { if pLog.config.AllowOnConsole { @@ -63,7 +63,7 @@ func (pLog PCPLogger) Log(logType int, level log.Level, message string) { } } -func (pLog PCPLogger) Logf(logType int, level log.Level, msgFmtString string, args ...interface{}) { +func (pLog pcpLogger) Logf(logType int, level log.Level, msgFmtString string, args ...interface{}) { if pLog.logType == logType { if pLog.isEnabled() { if pLog.config.AllowOnConsole { @@ -84,7 +84,7 @@ func (pLog PCPLogger) Logf(logType int, level log.Level, msgFmtString string, ar } } -func (pLog *PCPLogger) createLogFile(prefix string) { +func (pLog *pcpLogger) createLogFile(prefix string) { if pLog.isEnabled() { filename := strings.Join([]string{prefix, pLog.config.FilenameExtension}, "") dirName := pLog.logDir.getDirName() diff --git a/logging/schedPolicySwitchLogger.go b/logging/schedPolicySwitchLogger.go index 98a5094..a112db3 100644 --- a/logging/schedPolicySwitchLogger.go +++ b/logging/schedPolicySwitchLogger.go @@ -8,19 +8,19 @@ import ( log "github.com/sirupsen/logrus" ) -type SchedPolicySwitchLogger struct { +type schedPolicySwitchLogger struct { baseElektronLogger } -func NewSchedPolicySwitchLogger( - config *LoggerConfig, +func newSchedPolicySwitchLogger( + config *loggerConfig, b *baseLogData, logType int, prefix string, logger *log.Logger, - logDir *logDirectory) *SchedPolicySwitchLogger { + logDir *logDirectory) *schedPolicySwitchLogger { - sLog := &SchedPolicySwitchLogger{ + sLog := &schedPolicySwitchLogger{ baseElektronLogger: baseElektronLogger{ baseLogData: b, config: struct { @@ -43,7 +43,7 @@ func NewSchedPolicySwitchLogger( return sLog } -func (sLog SchedPolicySwitchLogger) Log(logType int, level log.Level, message string) { +func (sLog schedPolicySwitchLogger) Log(logType int, level log.Level, message string) { if sLog.logType == logType { if sLog.isEnabled() { if sLog.config.AllowOnConsole { @@ -63,7 +63,7 @@ func (sLog SchedPolicySwitchLogger) Log(logType int, level log.Level, message st } } -func (sLog SchedPolicySwitchLogger) Logf(logType int, level log.Level, msgFmtString string, args ...interface{}) { +func (sLog schedPolicySwitchLogger) Logf(logType int, level log.Level, msgFmtString string, args ...interface{}) { if sLog.logType == logType { if sLog.isEnabled() { if sLog.config.AllowOnConsole { @@ -84,7 +84,7 @@ func (sLog SchedPolicySwitchLogger) Logf(logType int, level log.Level, msgFmtStr } } -func (sLog *SchedPolicySwitchLogger) createLogFile(prefix string) { +func (sLog *schedPolicySwitchLogger) createLogFile(prefix string) { if sLog.isEnabled() { filename := strings.Join([]string{prefix, sLog.config.FilenameExtension}, "") dirName := sLog.logDir.getDirName() diff --git a/logging/schedTraceLogger.go b/logging/schedTraceLogger.go index 292dff8..ac08f27 100644 --- a/logging/schedTraceLogger.go +++ b/logging/schedTraceLogger.go @@ -8,19 +8,19 @@ import ( log "github.com/sirupsen/logrus" ) -type SchedTraceLogger struct { +type schedTraceLogger struct { baseElektronLogger } -func NewSchedTraceLogger( - config *LoggerConfig, +func newSchedTraceLogger( + config *loggerConfig, b *baseLogData, logType int, prefix string, logger *log.Logger, - logDir *logDirectory) *SchedTraceLogger { + logDir *logDirectory) *schedTraceLogger { - sLog := &SchedTraceLogger{ + sLog := &schedTraceLogger{ baseElektronLogger: baseElektronLogger{ baseLogData: b, config: struct { @@ -43,7 +43,7 @@ func NewSchedTraceLogger( return sLog } -func (sLog SchedTraceLogger) Log(logType int, level log.Level, message string) { +func (sLog schedTraceLogger) Log(logType int, level log.Level, message string) { if sLog.logType == logType { if sLog.isEnabled() { if sLog.config.AllowOnConsole { @@ -63,7 +63,7 @@ func (sLog SchedTraceLogger) Log(logType int, level log.Level, message string) { } } -func (sLog SchedTraceLogger) Logf(logType int, level log.Level, msgFmtString string, args ...interface{}) { +func (sLog schedTraceLogger) Logf(logType int, level log.Level, msgFmtString string, args ...interface{}) { if sLog.logType == logType { if sLog.isEnabled() { if sLog.config.AllowOnConsole { @@ -84,7 +84,7 @@ func (sLog SchedTraceLogger) Logf(logType int, level log.Level, msgFmtString str } } -func (sLog *SchedTraceLogger) createLogFile(prefix string) { +func (sLog *schedTraceLogger) createLogFile(prefix string) { if sLog.isEnabled() { filename := strings.Join([]string{prefix, sLog.config.FilenameExtension}, "") dirName := sLog.logDir.getDirName() diff --git a/logging/schedWindowLogger.go b/logging/schedWindowLogger.go index 9627e5e..5a1ce1a 100644 --- a/logging/schedWindowLogger.go +++ b/logging/schedWindowLogger.go @@ -8,19 +8,19 @@ import ( log "github.com/sirupsen/logrus" ) -type SchedWindowLogger struct { +type schedWindowLogger struct { baseElektronLogger } -func NewSchedWindowLogger( - config *LoggerConfig, +func newSchedWindowLogger( + config *loggerConfig, b *baseLogData, logType int, prefix string, logger *log.Logger, - logDir *logDirectory) *SchedWindowLogger { + logDir *logDirectory) *schedWindowLogger { - sLog := &SchedWindowLogger{ + sLog := &schedWindowLogger{ baseElektronLogger: baseElektronLogger{ baseLogData: b, config: struct { @@ -43,7 +43,7 @@ func NewSchedWindowLogger( return sLog } -func (sLog SchedWindowLogger) Log(logType int, level log.Level, message string) { +func (sLog schedWindowLogger) Log(logType int, level log.Level, message string) { if sLog.logType == logType { if sLog.isEnabled() { if sLog.config.AllowOnConsole { @@ -64,7 +64,7 @@ func (sLog SchedWindowLogger) Log(logType int, level log.Level, message string) } } -func (sLog SchedWindowLogger) Logf(logType int, level log.Level, msgFmtString string, args ...interface{}) { +func (sLog schedWindowLogger) Logf(logType int, level log.Level, msgFmtString string, args ...interface{}) { if sLog.logType == logType { if sLog.isEnabled() { if sLog.config.AllowOnConsole { @@ -84,7 +84,7 @@ func (sLog SchedWindowLogger) Logf(logType int, level log.Level, msgFmtString st } } -func (sLog *SchedWindowLogger) createLogFile(prefix string) { +func (sLog *schedWindowLogger) createLogFile(prefix string) { if sLog.isEnabled() { filename := strings.Join([]string{prefix, sLog.config.FilenameExtension}, "") dirName := sLog.logDir.getDirName() -- 2.47.2 From 02abb1e8820b91e8a6195d3d452a8fbd6daed027 Mon Sep 17 00:00:00 2001 From: balandi1 Date: Fri, 6 Dec 2019 12:59:35 -0500 Subject: [PATCH 36/48] Added functions to access members Functions to access all members of baseElektronLogger.config --- logging/clsfnTaskDistrOverheadLogger.go | 6 +++--- logging/consoleLogger.go | 2 +- logging/logger.go | 10 ++++++++++ logging/pcpLogger.go | 6 +++--- logging/schedPolicySwitchLogger.go | 6 +++--- logging/schedTraceLogger.go | 6 +++--- logging/schedWindowLogger.go | 6 +++--- 7 files changed, 26 insertions(+), 16 deletions(-) diff --git a/logging/clsfnTaskDistrOverheadLogger.go b/logging/clsfnTaskDistrOverheadLogger.go index 69e2ab0..79d0afc 100644 --- a/logging/clsfnTaskDistrOverheadLogger.go +++ b/logging/clsfnTaskDistrOverheadLogger.go @@ -45,7 +45,7 @@ func newClsfnTaskDistrOverheadLogger( func (cLog clsfnTaskDistrOverheadLogger) Log(logType int, level log.Level, message string) { if cLog.logType == logType { if cLog.isEnabled() { - if cLog.config.AllowOnConsole { + if cLog.isAllowedOnConsole() { cLog.logger.SetOutput(os.Stdout) cLog.logger.WithFields(cLog.data).Log(level, message) } @@ -66,7 +66,7 @@ func (cLog clsfnTaskDistrOverheadLogger) Log(logType int, level log.Level, messa func (cLog clsfnTaskDistrOverheadLogger) Logf(logType int, level log.Level, msgFmtString string, args ...interface{}) { if cLog.logType == logType { if cLog.isEnabled() { - if cLog.config.AllowOnConsole { + if cLog.isAllowedOnConsole() { cLog.logger.SetOutput(os.Stdout) cLog.logger.WithFields(cLog.data).Logf(level, msgFmtString, args...) } @@ -86,7 +86,7 @@ func (cLog clsfnTaskDistrOverheadLogger) Logf(logType int, level log.Level, msgF func (cLog *clsfnTaskDistrOverheadLogger) createLogFile(prefix string) { if cLog.isEnabled() { - filename := strings.Join([]string{prefix, cLog.config.FilenameExtension}, "") + filename := strings.Join([]string{prefix, cLog.getFilenameExtension()}, "") dirName := cLog.logDir.getDirName() if dirName != "" { if logFile, err := os.Create(filepath.Join(dirName, filename)); err != nil { diff --git a/logging/consoleLogger.go b/logging/consoleLogger.go index 2bc7666..2a2f389 100644 --- a/logging/consoleLogger.go +++ b/logging/consoleLogger.go @@ -86,7 +86,7 @@ func (cLog consoleLogger) Logf(logType int, level log.Level, msgFmtString string func (cLog *consoleLogger) createLogFile(prefix string) { // Create log file for the type if it is enabled. if cLog.isEnabled() { - filename := strings.Join([]string{prefix, cLog.config.FilenameExtension}, "") + filename := strings.Join([]string{prefix, cLog.getFilenameExtension()}, "") dirName := cLog.logDir.getDirName() fmt.Println(dirName) if dirName != "" { diff --git a/logging/logger.go b/logging/logger.go index b8c65d1..b0a5bf9 100644 --- a/logging/logger.go +++ b/logging/logger.go @@ -17,6 +17,8 @@ var elektronLoggerInstance elektronLogger type elektronLogger interface { setNext(next elektronLogger) isEnabled() bool + isAllowedOnConsole() bool + getFilenameExtension() string Log(logType int, level log.Level, message string) Logf(logType int, level log.Level, msgFmtString string, args ...interface{}) WithFields(logData log.Fields) elektronLogger @@ -47,6 +49,14 @@ func (l baseElektronLogger) isEnabled() bool { return l.config.Enabled } +func (l baseElektronLogger) isAllowedOnConsole() bool { + return l.config.AllowOnConsole +} + +func (l baseElektronLogger) getFilenameExtension() string { + return l.config.FilenameExtension +} + func (l *baseElektronLogger) WithFields(logData log.Fields) elektronLogger { l.data = logData return l diff --git a/logging/pcpLogger.go b/logging/pcpLogger.go index 7767f4d..9770db5 100644 --- a/logging/pcpLogger.go +++ b/logging/pcpLogger.go @@ -46,7 +46,7 @@ func newPCPLogger( func (pLog pcpLogger) Log(logType int, level log.Level, message string) { if pLog.logType == logType { if pLog.isEnabled() { - if pLog.config.AllowOnConsole { + if pLog.isAllowedOnConsole() { pLog.logger.SetOutput(os.Stdout) pLog.logger.WithFields(pLog.data).Log(level, message) } @@ -66,7 +66,7 @@ func (pLog pcpLogger) Log(logType int, level log.Level, message string) { func (pLog pcpLogger) Logf(logType int, level log.Level, msgFmtString string, args ...interface{}) { if pLog.logType == logType { if pLog.isEnabled() { - if pLog.config.AllowOnConsole { + if pLog.isAllowedOnConsole() { pLog.logger.SetOutput(os.Stdout) pLog.logger.WithFields(pLog.data).Logf(level, msgFmtString, args...) } @@ -86,7 +86,7 @@ func (pLog pcpLogger) Logf(logType int, level log.Level, msgFmtString string, ar func (pLog *pcpLogger) createLogFile(prefix string) { if pLog.isEnabled() { - filename := strings.Join([]string{prefix, pLog.config.FilenameExtension}, "") + filename := strings.Join([]string{prefix, pLog.getFilenameExtension()}, "") dirName := pLog.logDir.getDirName() if dirName != "" { if logFile, err := os.Create(filepath.Join(dirName, filename)); err != nil { diff --git a/logging/schedPolicySwitchLogger.go b/logging/schedPolicySwitchLogger.go index a112db3..d7c23c3 100644 --- a/logging/schedPolicySwitchLogger.go +++ b/logging/schedPolicySwitchLogger.go @@ -46,7 +46,7 @@ func newSchedPolicySwitchLogger( func (sLog schedPolicySwitchLogger) Log(logType int, level log.Level, message string) { if sLog.logType == logType { if sLog.isEnabled() { - if sLog.config.AllowOnConsole { + if sLog.isAllowedOnConsole() { sLog.logger.SetOutput(os.Stdout) sLog.logger.WithFields(sLog.data).Log(level, message) } @@ -66,7 +66,7 @@ func (sLog schedPolicySwitchLogger) Log(logType int, level log.Level, message st func (sLog schedPolicySwitchLogger) Logf(logType int, level log.Level, msgFmtString string, args ...interface{}) { if sLog.logType == logType { if sLog.isEnabled() { - if sLog.config.AllowOnConsole { + if sLog.isAllowedOnConsole() { sLog.logger.SetOutput(os.Stdout) sLog.logger.WithFields(sLog.data).Logf(level, msgFmtString, args...) } @@ -86,7 +86,7 @@ func (sLog schedPolicySwitchLogger) Logf(logType int, level log.Level, msgFmtStr func (sLog *schedPolicySwitchLogger) createLogFile(prefix string) { if sLog.isEnabled() { - filename := strings.Join([]string{prefix, sLog.config.FilenameExtension}, "") + filename := strings.Join([]string{prefix, sLog.getFilenameExtension()}, "") dirName := sLog.logDir.getDirName() if dirName != "" { if logFile, err := os.Create(filepath.Join(dirName, filename)); err != nil { diff --git a/logging/schedTraceLogger.go b/logging/schedTraceLogger.go index ac08f27..d90f82c 100644 --- a/logging/schedTraceLogger.go +++ b/logging/schedTraceLogger.go @@ -46,7 +46,7 @@ func newSchedTraceLogger( func (sLog schedTraceLogger) Log(logType int, level log.Level, message string) { if sLog.logType == logType { if sLog.isEnabled() { - if sLog.config.AllowOnConsole { + if sLog.isAllowedOnConsole() { sLog.logger.SetOutput(os.Stdout) sLog.logger.WithFields(sLog.data).Log(level, message) } @@ -66,7 +66,7 @@ func (sLog schedTraceLogger) Log(logType int, level log.Level, message string) { func (sLog schedTraceLogger) Logf(logType int, level log.Level, msgFmtString string, args ...interface{}) { if sLog.logType == logType { if sLog.isEnabled() { - if sLog.config.AllowOnConsole { + if sLog.isAllowedOnConsole() { sLog.logger.SetOutput(os.Stdout) sLog.logger.WithFields(sLog.data).Logf(level, msgFmtString, args...) } @@ -86,7 +86,7 @@ func (sLog schedTraceLogger) Logf(logType int, level log.Level, msgFmtString str func (sLog *schedTraceLogger) createLogFile(prefix string) { if sLog.isEnabled() { - filename := strings.Join([]string{prefix, sLog.config.FilenameExtension}, "") + filename := strings.Join([]string{prefix, sLog.getFilenameExtension()}, "") dirName := sLog.logDir.getDirName() if dirName != "" { if logFile, err := os.Create(filepath.Join(dirName, filename)); err != nil { diff --git a/logging/schedWindowLogger.go b/logging/schedWindowLogger.go index 5a1ce1a..ffa5437 100644 --- a/logging/schedWindowLogger.go +++ b/logging/schedWindowLogger.go @@ -46,7 +46,7 @@ func newSchedWindowLogger( func (sLog schedWindowLogger) Log(logType int, level log.Level, message string) { if sLog.logType == logType { if sLog.isEnabled() { - if sLog.config.AllowOnConsole { + if sLog.isAllowedOnConsole() { sLog.logger.SetOutput(os.Stdout) sLog.logger.WithFields(sLog.data).Log(level, message) } @@ -67,7 +67,7 @@ func (sLog schedWindowLogger) Log(logType int, level log.Level, message string) func (sLog schedWindowLogger) Logf(logType int, level log.Level, msgFmtString string, args ...interface{}) { if sLog.logType == logType { if sLog.isEnabled() { - if sLog.config.AllowOnConsole { + if sLog.isAllowedOnConsole() { sLog.logger.SetOutput(os.Stdout) sLog.logger.WithFields(sLog.data).Logf(level, msgFmtString, args...) } @@ -86,7 +86,7 @@ func (sLog schedWindowLogger) Logf(logType int, level log.Level, msgFmtString st func (sLog *schedWindowLogger) createLogFile(prefix string) { if sLog.isEnabled() { - filename := strings.Join([]string{prefix, sLog.config.FilenameExtension}, "") + filename := strings.Join([]string{prefix, sLog.getFilenameExtension()}, "") dirName := sLog.logDir.getDirName() if dirName != "" { if logFile, err := os.Create(filepath.Join(dirName, filename)); err != nil { -- 2.47.2 From 027adef642de044cac5ccf086b905500fb96b325 Mon Sep 17 00:00:00 2001 From: balandi1 Date: Mon, 9 Dec 2019 10:55:34 -0500 Subject: [PATCH 37/48] Code and formatting fixes Changed the shorthand for log config flag. Fixed formatting as mentioned. Removed unnecessary function declarations from elektronLogger interface. Disabled schedWindow and clsfnTaskDistrOverhead in config file. --- logConfig.yaml | 4 ++-- logging/consoleLogger.go | 5 ++--- logging/logger.go | 3 --- scheduler.go | 2 +- utilities/schedUtils/schedUtils.go | 3 +-- 5 files changed, 6 insertions(+), 11 deletions(-) diff --git a/logConfig.yaml b/logConfig.yaml index 70d5260..c2ba631 100644 --- a/logConfig.yaml +++ b/logConfig.yaml @@ -16,11 +16,11 @@ pcp: filenameExtension: .pcplog allowOnConsole: false schedWindow: - enabled: true + enabled: false filenameExtension: _schedWindow.log allowOnConsole: true clsfnTaskDistrOverhead: - enabled: true + enabled: false filenameExtension: _classificationOverhead.log allowOnConsole: true diff --git a/logging/consoleLogger.go b/logging/consoleLogger.go index 2a2f389..3f6fb7a 100644 --- a/logging/consoleLogger.go +++ b/logging/consoleLogger.go @@ -1,11 +1,11 @@ package logging import ( - "fmt" - log "github.com/sirupsen/logrus" "os" "path/filepath" "strings" + + log "github.com/sirupsen/logrus" ) type consoleLogger struct { @@ -88,7 +88,6 @@ func (cLog *consoleLogger) createLogFile(prefix string) { if cLog.isEnabled() { filename := strings.Join([]string{prefix, cLog.getFilenameExtension()}, "") dirName := cLog.logDir.getDirName() - fmt.Println(dirName) if dirName != "" { if logFile, err := os.Create(filepath.Join(dirName, filename)); err != nil { log.Fatal("Unable to create logFile: ", err) diff --git a/logging/logger.go b/logging/logger.go index b0a5bf9..7b4a267 100644 --- a/logging/logger.go +++ b/logging/logger.go @@ -16,9 +16,6 @@ var elektronLoggerInstance elektronLogger type elektronLogger interface { setNext(next elektronLogger) - isEnabled() bool - isAllowedOnConsole() bool - getFilenameExtension() string Log(logType int, level log.Level, message string) Logf(logType int, level log.Level, msgFmtString string, args ...interface{}) WithFields(logData log.Fields) elektronLogger diff --git a/scheduler.go b/scheduler.go index 89f77e3..0293835 100644 --- a/scheduler.go +++ b/scheduler.go @@ -78,7 +78,7 @@ func init() { flag.BoolVar(fixSchedWindow, "fixSw", false, "Fix the size of the scheduling window that every deployed scheduling policy should schedule, provided switching is enabled (shorthand).") flag.IntVar(schedWindowSize, "swSize", 200, "Size of the scheduling window if fixSchedWindow is set (shorthand).") flag.StringVar(schedPolSwitchCriteria, "spsCriteria", "taskDist", "Scheduling policy switching criteria (shorthand).") - flag.StringVar(logConfigFilename, "lgConfigName", "logConfig.yaml", "Log Configuration file name (shorthand).") + flag.StringVar(logConfigFilename, "lgCfg", "logConfig.yaml", "Log Configuration file name (shorthand).") } func listAllSchedulingPolicies() { diff --git a/utilities/schedUtils/schedUtils.go b/utilities/schedUtils/schedUtils.go index 534651d..97a37b4 100644 --- a/utilities/schedUtils/schedUtils.go +++ b/utilities/schedUtils/schedUtils.go @@ -79,8 +79,7 @@ func (s *fillNextOfferCycle) apply(taskQueue []def.Task) (int, int) { numberOfTasksTraversed++ for i := *task.Instances; i > 0; i-- { elekLog.Logf(CONSOLE, log.InfoLevel, - "Checking if Instance #%d of Task[%s] can be scheduled "+ - "during the next offer cycle...", i, task.Name) + "Checking if Instance #%d of Task[%s] can be scheduled "+"during the next offer cycle...", i, task.Name) if canSchedule(task) { filledCPU += task.CPU filledRAM += task.RAM -- 2.47.2 From 0ecbe55398e15e85b03f36205a388d2de9a13fcb Mon Sep 17 00:00:00 2001 From: balandi1 Date: Mon, 9 Dec 2019 11:03:40 -0500 Subject: [PATCH 38/48] Function renaming Renamed 'GetConfig()' to 'getConfig()', so that it is not exposed outside the package. --- logging/logger.go | 2 +- logging/loggerConfig.go | 2 +- 2 files changed, 2 insertions(+), 2 deletions(-) diff --git a/logging/logger.go b/logging/logger.go index 7b4a267..ffa2d96 100644 --- a/logging/logger.go +++ b/logging/logger.go @@ -107,7 +107,7 @@ func BuildLogger(prefix string, logConfigFilename string) error { head := &baseElektronLogger{baseLogData: b} // Read configuration from yaml. - if config, err := GetConfig(logConfigFilename); err != nil { + if config, err := getConfig(logConfigFilename); err != nil { return errors.Wrap(err, "Failed to build logger") } else { cLog := newConsoleLogger(config, b, CONSOLE, prefix, logger, logDir) diff --git a/logging/loggerConfig.go b/logging/loggerConfig.go index 49297cc..3f993b6 100644 --- a/logging/loggerConfig.go +++ b/logging/loggerConfig.go @@ -48,7 +48,7 @@ type loggerConfig struct { Format []string `yaml:"format"` } -func GetConfig(logConfigFilename string) (*loggerConfig, error) { +func getConfig(logConfigFilename string) (*loggerConfig, error) { yamlFile, err := ioutil.ReadFile(logConfigFilename) if err != nil { -- 2.47.2 From 053fc02ac02d413702e540035d9e4e71e87fa886 Mon Sep 17 00:00:00 2001 From: Bhargavi Hanumant Alandikar <44841561+balandi1@users.noreply.github.com> Date: Mon, 9 Dec 2019 11:21:27 -0500 Subject: [PATCH 39/48] Updated log format for schedTrace --- docs/data/ScheduledTrace.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/docs/data/ScheduledTrace.md b/docs/data/ScheduledTrace.md index 4d62bc0..380d072 100644 --- a/docs/data/ScheduledTrace.md +++ b/docs/data/ScheduledTrace.md @@ -9,6 +9,6 @@ The scheduled trace logs are written to a file named _\\_\ : +[]: = ``` -- 2.47.2 From ad78b7827e7282b62e6e07a963436496198796a7 Mon Sep 17 00:00:00 2001 From: Bhargavi Hanumant Alandikar <44841561+balandi1@users.noreply.github.com> Date: Mon, 9 Dec 2019 11:24:47 -0500 Subject: [PATCH 40/48] Updated log format for SPS --- docs/data/withSpsEnabled/SchedulingPolicySwitchTrace.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/docs/data/withSpsEnabled/SchedulingPolicySwitchTrace.md b/docs/data/withSpsEnabled/SchedulingPolicySwitchTrace.md index 4cf2984..b1dc90c 100644 --- a/docs/data/withSpsEnabled/SchedulingPolicySwitchTrace.md +++ b/docs/data/withSpsEnabled/SchedulingPolicySwitchTrace.md @@ -8,7 +8,7 @@ The logs are written to a file named _\\_\\_schedPol The format of the data logged is as shown below. ``` - +[]: ``` _Note: The names of the scheduling policies can be found [here](https://gitlab.com/spdf/elektron/blob/master/schedulers/store.go#L14)_ -- 2.47.2 From 6a577a413567075b3f00e3c8070ab0c15323e0ea Mon Sep 17 00:00:00 2001 From: Bhargavi Hanumant Alandikar <44841561+balandi1@users.noreply.github.com> Date: Mon, 9 Dec 2019 11:27:33 -0500 Subject: [PATCH 41/48] Updated log format for SCHED_WINDOW --- docs/data/withSpsEnabled/SchedulingWindow.md | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/docs/data/withSpsEnabled/SchedulingWindow.md b/docs/data/withSpsEnabled/SchedulingWindow.md index 0b47bf2..284b09c 100644 --- a/docs/data/withSpsEnabled/SchedulingWindow.md +++ b/docs/data/withSpsEnabled/SchedulingWindow.md @@ -8,5 +8,5 @@ The logs are written to a file named _\\_\\_schedWin The format of the data logged is as shown below. ``` - -``` \ No newline at end of file +[]: Window size=, Name= +``` -- 2.47.2 From 57d0ea278d68ce99f11d54d03fdeb361441bad3b Mon Sep 17 00:00:00 2001 From: Bhargavi Hanumant Alandikar <44841561+balandi1@users.noreply.github.com> Date: Mon, 9 Dec 2019 11:28:37 -0500 Subject: [PATCH 42/48] Minor format fix --- docs/data/withSpsEnabled/SchedulingPolicySwitchTrace.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/docs/data/withSpsEnabled/SchedulingPolicySwitchTrace.md b/docs/data/withSpsEnabled/SchedulingPolicySwitchTrace.md index b1dc90c..b0c1cb8 100644 --- a/docs/data/withSpsEnabled/SchedulingPolicySwitchTrace.md +++ b/docs/data/withSpsEnabled/SchedulingPolicySwitchTrace.md @@ -8,7 +8,7 @@ The logs are written to a file named _\\_\\_schedPol The format of the data logged is as shown below. ``` -[]: +[]: Name= ``` _Note: The names of the scheduling policies can be found [here](https://gitlab.com/spdf/elektron/blob/master/schedulers/store.go#L14)_ -- 2.47.2 From 49cc32134b3d0584d1ecc518c36e4d36e215e9d1 Mon Sep 17 00:00:00 2001 From: Bhargavi Hanumant Alandikar <44841561+balandi1@users.noreply.github.com> Date: Mon, 9 Dec 2019 11:32:29 -0500 Subject: [PATCH 43/48] Updated log format for CLSFN_TASKDISTR_OVERHEAD --- docs/data/withSpsEnabled/TaskClassificationOverhead.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/docs/data/withSpsEnabled/TaskClassificationOverhead.md b/docs/data/withSpsEnabled/TaskClassificationOverhead.md index 98a52af..a15eb47 100644 --- a/docs/data/withSpsEnabled/TaskClassificationOverhead.md +++ b/docs/data/withSpsEnabled/TaskClassificationOverhead.md @@ -8,7 +8,7 @@ The logs are written to a file named _\\_\\_classifi The format of the data logged is as shown below. ``` - +[]: Overhead in microseconds= ``` _Note: The classification overhead is logged in **microseconds**._ -- 2.47.2 From 01c130561b592bdbd5878adbe3e92dfa9e668d8b Mon Sep 17 00:00:00 2001 From: Bhargavi Hanumant Alandikar <44841561+balandi1@users.noreply.github.com> Date: Mon, 9 Dec 2019 11:39:21 -0500 Subject: [PATCH 44/48] Updated log format for PCP --- docs/data/PCP.md | 12 ++++++------ 1 file changed, 6 insertions(+), 6 deletions(-) diff --git a/docs/data/PCP.md b/docs/data/PCP.md index 790102f..9e5a432 100644 --- a/docs/data/PCP.md +++ b/docs/data/PCP.md @@ -25,12 +25,12 @@ myhost:kernel.all.cpu.sys When we run the `pmdumptext` command mentioned above for 5 seconds, the PCP log from _Elektron_ would be as shown below. ``` - myhost:kernel.all.cpu.user,myhost:kernel.all.cpu.sys - , - , - , - , - , +[]: myhost:kernel.all.cpu.user,myhost:kernel.all.cpu.sys +[]: , +[]: , +[]: , +[]: , +[]: , ``` ## Power Measurements -- 2.47.2 From 67af2b72ba7a831b58e7d146b770d3f737f0ee81 Mon Sep 17 00:00:00 2001 From: Bhargavi Hanumant Alandikar <44841561+balandi1@users.noreply.github.com> Date: Mon, 9 Dec 2019 11:40:58 -0500 Subject: [PATCH 45/48] Renamed log type Renamed CLSFN_TASKDIST_OVERHEAD to CLSFN_TASKDISTR_OVERHEAD --- docs/Logs.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/docs/Logs.md b/docs/Logs.md index da2bc0f..972fe78 100644 --- a/docs/Logs.md +++ b/docs/Logs.md @@ -11,4 +11,4 @@ _Elektron_ logs can be categorized into the following. * _**Scheduling Policy Switching Logs**_ - When scheduling policy switching is enabled (`-switchSchedPol` is used when launching _Elektron_), the following information is logged. * [**Scheduling Policy Switch trace (SPS)**](data/withSpsEnabled/SchedulingPolicySwitchTrace.md) - Every time _Elektron_ switches to a different scheduling policy, the _name_ of the scheduling policy and the corresponding _time stamp_ is logged.
* [**SCHED_WINDOW**](data/withSpsEnabled/SchedulingWindow.md) - For every switch, the size of the scheduling window and the name of the scheduling policy is logged. - * [**CLSFN_TASKDIST_OVERHEAD**](data/withSpsEnabled/TaskClassificationOverhead.md) - If the switching criteria is task distribution based, then the time taken to classify the tasks into low power consuming and high power consuming, and then to determine the task distribution is logged. + * [**CLSFN_TASKDISTR_OVERHEAD**](data/withSpsEnabled/TaskClassificationOverhead.md) - If the switching criteria is task distribution based, then the time taken to classify the tasks into low power consuming and high power consuming, and then to determine the task distribution is logged. -- 2.47.2 From 38c5142d01d733e5ad33cd1597a4692fa0f570e0 Mon Sep 17 00:00:00 2001 From: Bhargavi Hanumant Alandikar <44841561+balandi1@users.noreply.github.com> Date: Mon, 9 Dec 2019 12:38:28 -0500 Subject: [PATCH 46/48] Added documentation for log configurations --- docs/Logs.md | 14 ++++++++++++++ 1 file changed, 14 insertions(+) diff --git a/docs/Logs.md b/docs/Logs.md index 972fe78..97554b4 100644 --- a/docs/Logs.md +++ b/docs/Logs.md @@ -12,3 +12,17 @@ _Elektron_ logs can be categorized into the following. * [**Scheduling Policy Switch trace (SPS)**](data/withSpsEnabled/SchedulingPolicySwitchTrace.md) - Every time _Elektron_ switches to a different scheduling policy, the _name_ of the scheduling policy and the corresponding _time stamp_ is logged.
* [**SCHED_WINDOW**](data/withSpsEnabled/SchedulingWindow.md) - For every switch, the size of the scheduling window and the name of the scheduling policy is logged. * [**CLSFN_TASKDISTR_OVERHEAD**](data/withSpsEnabled/TaskClassificationOverhead.md) - If the switching criteria is task distribution based, then the time taken to classify the tasks into low power consuming and high power consuming, and then to determine the task distribution is logged. + +_Elektron_ logs can be configured through [Log config file](../logConfig.yaml). The following is the format for configuration. +``` +: + enabled: + filenameExtension: + minLogLevel: + allowOnConsole: +``` +The file has default configurations set. One can also configure the above fields for every log type. +* `enabled` - Enable or disable a specific log type. +* `filenameExtension` - Provide the file extension for specific log type. +* `minLogLevel` - Provide a minimum log level above which all logs should be logged. This is available only for Console log type. The default value is debug). +* `allowOnConsole` - Allow or Disallow a specific log type on the console. -- 2.47.2 From 2edd0532aac37a85af95bfd219d4689eb8ba4b41 Mon Sep 17 00:00:00 2001 From: balandi1 Date: Mon, 9 Dec 2019 12:52:45 -0500 Subject: [PATCH 47/48] Removed format from logConfig.yaml Not used anywhere --- logConfig.yaml | 6 ------ 1 file changed, 6 deletions(-) diff --git a/logConfig.yaml b/logConfig.yaml index c2ba631..480fd16 100644 --- a/logConfig.yaml +++ b/logConfig.yaml @@ -23,10 +23,4 @@ clsfnTaskDistrOverhead: enabled: false filenameExtension: _classificationOverhead.log allowOnConsole: true - -format: - - level - - timestamp - - message - - fields -- 2.47.2 From 66c4d490b2458fc7dbbe8a5d4d9a324bcd89ff7a Mon Sep 17 00:00:00 2001 From: balandi1 Date: Mon, 9 Dec 2019 20:05:28 -0500 Subject: [PATCH 48/48] Added license to the new go files --- logging/clsfnTaskDistrOverheadLogger.go | 18 ++++++++++++++++++ logging/consoleLogger.go | 18 ++++++++++++++++++ logging/createLogDir.go | 18 ++++++++++++++++++ logging/elektronFormatter.go | 18 ++++++++++++++++++ logging/logger.go | 18 ++++++++++++++++++ logging/loggerConfig.go | 18 ++++++++++++++++++ logging/pcpLogger.go | 18 ++++++++++++++++++ logging/schedPolicySwitchLogger.go | 18 ++++++++++++++++++ logging/schedTraceLogger.go | 18 ++++++++++++++++++ logging/schedWindowLogger.go | 18 ++++++++++++++++++ logging/types/types.go | 18 ++++++++++++++++++ 11 files changed, 198 insertions(+) diff --git a/logging/clsfnTaskDistrOverheadLogger.go b/logging/clsfnTaskDistrOverheadLogger.go index 79d0afc..0f3fcc6 100644 --- a/logging/clsfnTaskDistrOverheadLogger.go +++ b/logging/clsfnTaskDistrOverheadLogger.go @@ -1,3 +1,21 @@ +// Copyright (C) 2018 spdfg +// +// This file is part of Elektron. +// +// Elektron is free software: you can redistribute it and/or modify +// it under the terms of the GNU General Public License as published by +// the Free Software Foundation, either version 3 of the License, or +// (at your option) any later version. +// +// Elektron is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +// GNU General Public License for more details. +// +// You should have received a copy of the GNU General Public License +// along with Elektron. If not, see . +// + package logging import ( diff --git a/logging/consoleLogger.go b/logging/consoleLogger.go index 3f6fb7a..9f6cfdc 100644 --- a/logging/consoleLogger.go +++ b/logging/consoleLogger.go @@ -1,3 +1,21 @@ +// Copyright (C) 2018 spdfg +// +// This file is part of Elektron. +// +// Elektron is free software: you can redistribute it and/or modify +// it under the terms of the GNU General Public License as published by +// the Free Software Foundation, either version 3 of the License, or +// (at your option) any later version. +// +// Elektron is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +// GNU General Public License for more details. +// +// You should have received a copy of the GNU General Public License +// along with Elektron. If not, see . +// + package logging import ( diff --git a/logging/createLogDir.go b/logging/createLogDir.go index e6730f4..d41487d 100644 --- a/logging/createLogDir.go +++ b/logging/createLogDir.go @@ -1,3 +1,21 @@ +// Copyright (C) 2018 spdfg +// +// This file is part of Elektron. +// +// Elektron is free software: you can redistribute it and/or modify +// it under the terms of the GNU General Public License as published by +// the Free Software Foundation, either version 3 of the License, or +// (at your option) any later version. +// +// Elektron is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +// GNU General Public License for more details. +// +// You should have received a copy of the GNU General Public License +// along with Elektron. If not, see . +// + package logging import ( diff --git a/logging/elektronFormatter.go b/logging/elektronFormatter.go index 8116110..3454e40 100644 --- a/logging/elektronFormatter.go +++ b/logging/elektronFormatter.go @@ -1,3 +1,21 @@ +// Copyright (C) 2018 spdfg +// +// This file is part of Elektron. +// +// Elektron is free software: you can redistribute it and/or modify +// it under the terms of the GNU General Public License as published by +// the Free Software Foundation, either version 3 of the License, or +// (at your option) any later version. +// +// Elektron is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +// GNU General Public License for more details. +// +// You should have received a copy of the GNU General Public License +// along with Elektron. If not, see . +// + package logging import ( diff --git a/logging/logger.go b/logging/logger.go index ffa2d96..6839d01 100644 --- a/logging/logger.go +++ b/logging/logger.go @@ -1,3 +1,21 @@ +// Copyright (C) 2018 spdfg +// +// This file is part of Elektron. +// +// Elektron is free software: you can redistribute it and/or modify +// it under the terms of the GNU General Public License as published by +// the Free Software Foundation, either version 3 of the License, or +// (at your option) any later version. +// +// Elektron is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +// GNU General Public License for more details. +// +// You should have received a copy of the GNU General Public License +// along with Elektron. If not, see . +// + package logging import ( diff --git a/logging/loggerConfig.go b/logging/loggerConfig.go index 3f993b6..4685301 100644 --- a/logging/loggerConfig.go +++ b/logging/loggerConfig.go @@ -1,3 +1,21 @@ +// Copyright (C) 2018 spdfg +// +// This file is part of Elektron. +// +// Elektron is free software: you can redistribute it and/or modify +// it under the terms of the GNU General Public License as published by +// the Free Software Foundation, either version 3 of the License, or +// (at your option) any later version. +// +// Elektron is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +// GNU General Public License for more details. +// +// You should have received a copy of the GNU General Public License +// along with Elektron. If not, see . +// + package logging import ( diff --git a/logging/pcpLogger.go b/logging/pcpLogger.go index 9770db5..2f35382 100644 --- a/logging/pcpLogger.go +++ b/logging/pcpLogger.go @@ -1,3 +1,21 @@ +// Copyright (C) 2018 spdfg +// +// This file is part of Elektron. +// +// Elektron is free software: you can redistribute it and/or modify +// it under the terms of the GNU General Public License as published by +// the Free Software Foundation, either version 3 of the License, or +// (at your option) any later version. +// +// Elektron is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +// GNU General Public License for more details. +// +// You should have received a copy of the GNU General Public License +// along with Elektron. If not, see . +// + package logging import ( diff --git a/logging/schedPolicySwitchLogger.go b/logging/schedPolicySwitchLogger.go index d7c23c3..a7fcc45 100644 --- a/logging/schedPolicySwitchLogger.go +++ b/logging/schedPolicySwitchLogger.go @@ -1,3 +1,21 @@ +// Copyright (C) 2018 spdfg +// +// This file is part of Elektron. +// +// Elektron is free software: you can redistribute it and/or modify +// it under the terms of the GNU General Public License as published by +// the Free Software Foundation, either version 3 of the License, or +// (at your option) any later version. +// +// Elektron is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +// GNU General Public License for more details. +// +// You should have received a copy of the GNU General Public License +// along with Elektron. If not, see . +// + package logging import ( diff --git a/logging/schedTraceLogger.go b/logging/schedTraceLogger.go index d90f82c..9af4bd5 100644 --- a/logging/schedTraceLogger.go +++ b/logging/schedTraceLogger.go @@ -1,3 +1,21 @@ +// Copyright (C) 2018 spdfg +// +// This file is part of Elektron. +// +// Elektron is free software: you can redistribute it and/or modify +// it under the terms of the GNU General Public License as published by +// the Free Software Foundation, either version 3 of the License, or +// (at your option) any later version. +// +// Elektron is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +// GNU General Public License for more details. +// +// You should have received a copy of the GNU General Public License +// along with Elektron. If not, see . +// + package logging import ( diff --git a/logging/schedWindowLogger.go b/logging/schedWindowLogger.go index ffa5437..d7fc4f2 100644 --- a/logging/schedWindowLogger.go +++ b/logging/schedWindowLogger.go @@ -1,3 +1,21 @@ +// Copyright (C) 2018 spdfg +// +// This file is part of Elektron. +// +// Elektron is free software: you can redistribute it and/or modify +// it under the terms of the GNU General Public License as published by +// the Free Software Foundation, either version 3 of the License, or +// (at your option) any later version. +// +// Elektron is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +// GNU General Public License for more details. +// +// You should have received a copy of the GNU General Public License +// along with Elektron. If not, see . +// + package logging import ( diff --git a/logging/types/types.go b/logging/types/types.go index 44b8484..1022de9 100644 --- a/logging/types/types.go +++ b/logging/types/types.go @@ -1,3 +1,21 @@ +// Copyright (C) 2018 spdfg +// +// This file is part of Elektron. +// +// Elektron is free software: you can redistribute it and/or modify +// it under the terms of the GNU General Public License as published by +// the Free Software Foundation, either version 3 of the License, or +// (at your option) any later version. +// +// Elektron is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +// GNU General Public License for more details. +// +// You should have received a copy of the GNU General Public License +// along with Elektron. If not, see . +// + package types const ( -- 2.47.2