msb2pilot2/log/log.go

   1 package log
   2
   3 import (
   4         "encoding/json"
   5         "fmt"
   6         "github.com/astaxie/beego/logs"
   7         "msb2pilot/util"
   8         "os"
   9         "path/filepath"
  10         "strconv"
  11         "strings"
  12 )
  13
  14 type ConsoleCfg struct {
  15         Level int `json:"level"`
  16 }
  17
  18 type FileCfg struct {
  19         FileName string `json:"filename"`
  20         Level    int    `json:"level"`
  21         MaxLines int    `json:"maxlines"`
  22         MaxSize  int    `josn:"maxsize"`
  23         Daily    bool   `json:"daily"`
  24         MaxDays  int    `json:"maxdays"`
  25         Rotate   bool   `json:"rotate"`
  26 }
  27
  28 type Cfg struct {
  29         Console ConsoleCfg `json:"console"`
  30         File    FileCfg    `json:"file"`
  31 }
  32
  33 const (
  34         cfgFileName         = "log.yml"
  35         defaultConsoleLevel = "Warn"
  36         defaultFileLevel    = "Info"
  37 )
  38
  39 var (
  40         Log         *logs.BeeLogger
  41         loggerLevel = map[string]int{"Emergency": 0, "Alert": 1, "Critical": 2, "Error": 3, "Warn": 4, "Notice": 5, "Info": 6, "Debug": 7}
  42 )
  43
  44 func init() {
  45         Log = logs.NewLogger()
  46         Log.EnableFuncCallDepth(true)
  47
  48         cfg := getConfig()
  49         setLogger(logs.AdapterConsole, &cfg.Console)
  50         checkLogDir(cfg.File.FileName)
  51         setLogger(logs.AdapterFile, &cfg.File)
  52 }
  53
  54 func setLogger(adapter string, cfg interface{}) bool {
  55         b, err := json.Marshal(cfg)
  56         if err != nil {
  57                 fmt.Printf(" cfg json trans error: %s\n", adapter, err.Error())
  58                 return false
  59         }
  60
  61         err = Log.SetLogger(adapter, string(b))
  62         if err != nil {
  63                 fmt.Printf("set %s failed: %s\n", adapter, err.Error())
  64                 return false
  65         }
  66
  67         return true
  68
  69 }
  70
  71 func checkLogDir(path string) {
  72         if path == "" {
  73                 return
  74         }
  75
  76         var index int
  77         pathSep := string(os.PathSeparator)
  78         if index = strings.LastIndex(path, pathSep); index <= 2 {
  79                 return
  80         }
  81
  82         perm, _ := strconv.ParseInt("0660", 8, 64)
  83         if err := os.MkdirAll(path[0:index], os.FileMode(perm)); err != nil {
  84                 return
  85         }
  86 }
  87
  88 func loadCustom() map[string]interface{} {
  89         fullPath := filepath.Join(util.GetCfgPath(), cfgFileName)
  90         fmt.Println("log config path is:" + fullPath)
  91         config, err := util.Read(fullPath)
  92         if err != nil {
  93                 fmt.Println("read config file error")
  94                 return nil
  95         }
  96
  97         cfg := make(map[string]interface{})
  98         err = util.UnmarshalYaml(config, &cfg)
  99
 100         if err != nil {
 101                 fmt.Printf("parse config file error: %s\n", err.Error())
 102                 return nil
 103         }
 104         return cfg
 105 }
 106
 107 func getConfig() (result *Cfg) {
 108         result = getDefaultCfg()
 109
 110         customs := loadCustom()
 111
 112         if customs == nil {
 113                 return
 114         }
 115
 116         var console map[interface{}]interface{}
 117         if cons, exist := customs["console"]; exist {
 118                 console = cons.(map[interface{}]interface{})
 119
 120                 if levelstr, exist := console["level"]; exist {
 121                         if level, ok := loggerLevel[levelstr.(string)]; ok {
 122                                 result.Console.Level = level
 123                         }
 124                 }
 125         }
 126         var file map[interface{}]interface{}
 127         if f, exist := customs["file"]; !exist {
 128                 return
 129         } else {
 130                 file = f.(map[interface{}]interface{})
 131         }
 132
 133         if filename, e := file["filename"]; e {
 134                 result.File.FileName = filename.(string)
 135         }
 136         if levelstr, e := file["level"]; e {
 137                 if level, exist := loggerLevel[levelstr.(string)]; exist {
 138                         result.File.Level = level
 139                 }
 140         }
 141         if maxlines, e := file["maxlines"]; e {
 142                 result.File.MaxLines = maxlines.(int)
 143         }
 144
 145         if maxsize, e := file["maxsize"]; e {
 146                 result.File.MaxSize = maxsize.(int) * 1024 * 1024
 147         }
 148
 149         if daily, e := file["daily"]; e {
 150                 result.File.Daily = daily.(bool)
 151         }
 152
 153         if maxdays, e := file["maxdays"]; e {
 154                 result.File.MaxDays = maxdays.(int)
 155         }
 156
 157         if rotate, e := file["rotate"]; e {
 158                 result.File.Rotate = rotate.(bool)
 159         }
 160
 161         return
 162 }
 163
 164 func getDefaultCfg() *Cfg {
 165         return &Cfg{
 166                 Console: ConsoleCfg{
 167                         Level: loggerLevel[defaultConsoleLevel],
 168                 },
 169                 File: FileCfg{
 170                         FileName: "msb2pilot.log",
 171                         Level:    loggerLevel[defaultFileLevel],
 172                         MaxLines: 300000,
 173                         MaxSize:  30 * 1024 * 1024,
 174                         Daily:    true,
 175                         MaxDays:  10,
 176                         Rotate:   true,
 177                 },
 178         }
 179 }