spdf/elektron
Archived
1
0
Fork 0
Code Issues 4 Pull requests 1 Projects Releases Packages Wiki Activity

move cfg to loggers + refactor + log fn wrappers

Browse source 
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.
This commit is contained in:
Pradyumna Kaushik 2019-12-05 21:32:37 -05:00
parent 5a6d1bed4a
commit 6fb0e4a3fe
20 changed files with 396 additions and 250 deletions
Download patch file Download diff file Expand all files Collapse all files

4
def/taskUtils.go
View file

@ -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.

51
logging/clsfnTaskDistrOverheadLogger.go
View file

@ -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
}
}
}

50
logging/consoleLogger.go
View file

@ -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
}
}
}

124
logging/logger.go
View file

@ -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)
}

56
logging/loggerChain.go
View file

@ -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{}
}

9
logging/loggerConfig.go
View file

@ -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
}

50
logging/pcpLogger.go
View file

@ -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
}
}
}

50
logging/schedPolicySwitchLogger.go
View file

@ -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
}
}
}

50
logging/schedTraceLogger.go
View file

@ -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
}
}
}

50
logging/schedWindowLogger.go
View file

@ -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
}
}
}

2
logging/types/types.go
View file

@ -1,4 +1,4 @@
package elektronLogging
package types
const (
CONSOLE = iota

8
pcp/pcp.go
View file

@ -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

26
powerCap/extrema.go
View file

@ -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

44
powerCap/progressiveExtrema.go
View file

@ -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

11
scheduler.go
View file

@ -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...")
}

49
schedulers/base.go
View file

@ -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("<CPU: %f, RAM: %f, Watts: %f>", 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, "")
}

4
schedulers/helpers.go
View file

@ -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.

2
schedulers/schedPolicy.go
View file

@ -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.

4
utilities/offerUtils/offerUtils.go
View file

@ -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 {

2
utilities/schedUtils/schedUtils.go
View file

@ -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) {