path: root/ethutil/config.go

package ethutil

import (
    "fmt"
    "log"
    "os"
    "os/user"
    "path"
    "runtime"
)

// Config struct
type config struct {
    Db Database

    Log          *Logger
    ExecPath     string
    Debug        bool
    Ver          string
    ClientString string
    Pubkey       []byte
    Identifier   string
}

var Config *config

// Read config
//
// Initialize the global Config variable with default settings
func ReadConfig(base string, logTypes LoggerType, id string) *config {
    if Config == nil {
        usr, _ := user.Current()
        path := path.Join(usr.HomeDir, base)

        if len(base) > 0 {
            //Check if the logging directory already exists, create it if not
            _, err := os.Stat(path)
            if err != nil {
                if os.IsNotExist(err) {
                    log.Printf("Debug logging directory %s doesn't exist, creating it\n", path)
                    os.Mkdir(path, 0777)
                }
            }
        }

        Config = &config{ExecPath: path, Debug: true, Ver: "0.5.0 RC10"}
        Config.Identifier = id
        Config.Log = NewLogger(logTypes, LogLevelDebug)
        Config.SetClientString("/Ethereum(G)")
    }

    return Config
}

// Set client string
//
func (c *config) SetClientString(str string) {
    id := runtime.GOOS
    if len(c.Identifier) > 0 {
        id = c.Identifier
    }
    Config.ClientString = fmt.Sprintf("%s nv%s/%s", str, c.Ver, id)
}

type LoggerType byte

const (
    LogFile = 0x1
    LogStd  = 0x2
)

type LogSystem interface {
    Println(v ...interface{})
    Printf(format string, v ...interface{})
}

type Logger struct {
    logSys   []LogSystem
    logLevel int
}

func NewLogger(flag LoggerType, level int) *Logger {
    var loggers []LogSystem

    flags := log.LstdFlags

    if flag&LogFile > 0 {
        file, err := os.OpenFile(path.Join(Config.ExecPath, "debug.log"), os.O_RDWR|os.O_CREATE|os.O_APPEND, os.ModePerm)
        if err != nil {
            log.Panic("unable to create file logger", err)
        }

        log := log.New(file, "", flags)

        loggers = append(loggers, log)
    }
    if flag&LogStd > 0 {
        log := log.New(os.Stdout, "", flags)
        loggers = append(loggers, log)
    }

    return &Logger{logSys: loggers, logLevel: level}
}

func (log *Logger) AddLogSystem(logger LogSystem) {
    log.logSys = append(log.logSys, logger)
}

const (
    LogLevelDebug = iota
    LogLevelInfo
)

func (log *Logger) Debugln(v ...interface{}) {
    if log.logLevel != LogLevelDebug {
        return
    }

    for _, logger := range log.logSys {
        logger.Println(v...)
    }
}

func (log *Logger) Debugf(format string, v ...interface{}) {
    if log.logLevel != LogLevelDebug {
        return
    }

    for _, logger := range log.logSys {
        logger.Printf(format, v...)
    }
}

func (log *Logger) Infoln(v ...interface{}) {
    if log.logLevel > LogLevelInfo {
        return
    }

    for _, logger := range log.logSys {
        logger.Println(v...)
    }
}

func (log *Logger) Infof(format string, v ...interface{}) {
    if log.logLevel > LogLevelInfo {
        return
    }

    for _, logger := range log.logSys {
        logger.Printf(format, v...)
    }
}

func (log *Logger) Fatal(v ...interface{}) {
    if log.logLevel > LogLevelInfo {
        return
    }

    for _, logger := range log.logSys {
        logger.Println(v...)
    }

    os.Exit(1)
}