add log

Author: cserli

第一季 从零开始写游戏服务器 第二期/最新课节--课程代码/class3/src/classcode/conf/conf.go

@@ -0,0 +1,24 @@
+package conf
+
+import (
+	"log"
+	"time"
+)
+
+var (
+	// log conf
+	LogFlag = log.LstdFlags
+
+	// gate conf // 网关配置
+	PendingWriteNum        = 2000
+	MaxMsgLen       uint32 = 4096 // 消息的长度
+	HTTPTimeout            = 10 * time.Second
+	LenMsgLen              = 2
+	LittleEndian           = false
+
+	// skeleton conf  框架配置
+	GoLen              = 10000
+	TimerDispatcherLen = 10000
+	AsynCallLen        = 10000
+	ChanRPCLen         = 10000
+)

第一季 从零开始写游戏服务器 第二期/最新课节--课程代码/class3/src/classcode/conf/json.go

@@ -0,0 +1,32 @@
+package conf
+
+import (
+	"LollipopGo/LollipopGo/log"
+	"encoding/json"
+	"io/ioutil"
+)
+
+// 服务器结构
+var Server struct {
+	LogLevel    string
+	LogPath     string
+	WSAddr      string
+	CertFile    string
+	KeyFile     string
+	TCPAddr     string
+	MaxConnNum  int
+	ConsolePort int
+	ProfilePath string
+}
+
+// 加载服务器配置
+func init() {
+	data, err := ioutil.ReadFile("conf/server.json")
+	if err != nil {
+		log.Debug("-------------%v", err)
+	}
+	err = json.Unmarshal(data, &Server)
+	if err != nil {
+		log.Debug("+++++++++++++%v", err)
+	}
+}

第一季 从零开始写游戏服务器 第二期/最新课节--课程代码/class3/src/classcode/conf/server.json

@@ -0,0 +1,11 @@
+{
+    "LogLevel": "debug",
+    "LogPath": "",
+    "WSAddr": "127.0.0.1:8889",
+    "CertFile": "",
+    "KeyFile": "",
+    "TCPAddr": "127.0.0.1:8888",   
+    "MaxConnNum": 20000,
+    "ConsolePort": 8012,
+    "ProfilePath": ""
+}

第一季 从零开始写游戏服务器 第二期/最新课节--课程代码/class3/src/classcode/tmain.go

@@ -5,11 +5,22 @@ import (
 	"net/http"
 	"os"
 
+	LollipopGoconf "LollipopGo/LollipopGo/conf"
+	"classcode/conf" // 服务器配置——针对不同环境的配置
 	_ "net/http/pprof"
 
 	"code.google.com/p/go.net/websocket"
 )
 
+func init() {
+	// 加载配置
+	LollipopGoconf.LogLevel = conf.Server.LogLevel
+	LollipopGoconf.LogPath = conf.Server.LogPath
+	LollipopGoconf.LogFlag = conf.LogFlag
+	LollipopGoconf.ConsolePort = conf.Server.ConsolePort
+	LollipopGoconf.ProfilePath = conf.Server.ProfilePath
+}
+
 func main() {
 	// os.Args[0] == 执行文件的名字
 	// os.Args[1] == 第一个参数

第一季 从零开始写游戏服务器 第二期/最新课节--课程代码/vender/src/LollipopGo/LollipopGo/conf/conf.go

@@ -0,0 +1,22 @@
+package conf
+
+// 配置文件定义
+// 数据定义操作
+var (
+	LenStackBuf = 4096
+
+	// log
+	LogLevel string
+	LogPath  string
+	LogFlag  int
+
+	// console
+	ConsolePort   int
+	ConsolePrompt string = "Leaf# "
+	ProfilePath   string
+
+	// cluster
+	ListenAddr      string
+	ConnAddrs       []string
+	PendingWriteNum int
+)

第一季 从零开始写游戏服务器 第二期/最新课节--课程代码/vender/src/LollipopGo/LollipopGo/log/example_test.go

@@ -0,0 +1,30 @@
+package log_test
+
+import (
+	l "log"
+
+	"LollipopGo/LollipopGo/log"
+)
+
+func Example() {
+	name := "LollipopGo"
+
+	log.Debug("My name is %v", name)
+	log.Release("My name is %v", name)
+	log.Error("My name is %v", name)
+	// log.Fatal("My name is %v", name)
+
+	logger, err := log.New("release", "", l.LstdFlags)
+	if err != nil {
+		return
+	}
+	defer logger.Close()
+
+	logger.Debug("will not print")
+	logger.Release("My name is %v", name)
+
+	log.Export(logger)
+
+	log.Debug("will not print")
+	log.Release("My name is %v", name)
+}

第一季 从零开始写游戏服务器 第二期/最新课节--课程代码/vender/src/LollipopGo/LollipopGo/log/log.go

@@ -1,19 +1,153 @@
 package log
 
 import (
-	"flag"
-	"glog-master"
+	"errors"
+	"fmt"
+	"log"
+	"os"
+	"path"
+	"strings"
+	"time"
 )
 
-func init() {
-	// 程序当中执行：
-	flag.Set("alsologtostderr", "true") // 日志写入文件的同时，输出到stderr
-	flag.Set("log_dir", "./log")        // 日志文件的保存的目录
-	flag.Set("v", "3")                  // 配置日志输出的等级
-	flag.Parse()
+// levels
+const (
+	debugLevel   = 0
+	releaseLevel = 1
+	errorLevel   = 2
+	fatalLevel   = 3
+)
+
+const (
+	printDebugLevel   = "[debug  ] "
+	printReleaseLevel = "[release] "
+	printErrorLevel   = "[error  ] "
+	printFatalLevel   = "[fatal  ] "
+)
+
+type Logger struct {
+	level      int
+	baseLogger *log.Logger
+	baseFile   *os.File
+}
+
+func New(strLevel string, pathname string, flag int) (*Logger, error) {
+	// level
+	var level int
+	switch strings.ToLower(strLevel) {
+	case "debug":
+		level = debugLevel
+	case "release":
+		level = releaseLevel
+	case "error":
+		level = errorLevel
+	case "fatal":
+		level = fatalLevel
+	default:
+		return nil, errors.New("unknown level: " + strLevel)
+	}
+
+	// logger
+	var baseLogger *log.Logger
+	var baseFile *os.File
+	if pathname != "" {
+		now := time.Now()
+
+		filename := fmt.Sprintf("%d%02d%02d_%02d_%02d_%02d.log",
+			now.Year(),
+			now.Month(),
+			now.Day(),
+			now.Hour(),
+			now.Minute(),
+			now.Second())
+
+		file, err := os.Create(path.Join(pathname, filename))
+		if err != nil {
+			return nil, err
+		}
+
+		baseLogger = log.New(file, "", flag)
+		baseFile = file
+	} else {
+		baseLogger = log.New(os.Stdout, "", flag)
+	}
+
+	// new
+	logger := new(Logger)
+	logger.level = level
+	logger.baseLogger = baseLogger
+	logger.baseFile = baseFile
+
+	return logger, nil
+}
+
+// It's dangerous to call the method on logging
+func (logger *Logger) Close() {
+	if logger.baseFile != nil {
+		logger.baseFile.Close()
+	}
+
+	logger.baseLogger = nil
+	logger.baseFile = nil
+}
+
+func (logger *Logger) doPrintf(level int, printLevel string, format string, a ...interface{}) {
+	if level < logger.level {
+		return
+	}
+	if logger.baseLogger == nil {
+		panic("logger closed")
+	}
+
+	format = printLevel + format
+	logger.baseLogger.Output(3, fmt.Sprintf(format, a...))
+
+	if level == fatalLevel {
+		os.Exit(1)
+	}
+}
+
+func (logger *Logger) Debug(format string, a ...interface{}) {
+	logger.doPrintf(debugLevel, printDebugLevel, format, a...)
+}
+
+func (logger *Logger) Release(format string, a ...interface{}) {
+	logger.doPrintf(releaseLevel, printReleaseLevel, format, a...)
+}
+
+func (logger *Logger) Error(format string, a ...interface{}) {
+	logger.doPrintf(errorLevel, printErrorLevel, format, a...)
+}
+
+func (logger *Logger) Fatal(format string, a ...interface{}) {
+	logger.doPrintf(fatalLevel, printFatalLevel, format, a...)
+}
+
+var gLogger, _ = New("debug", "", log.LstdFlags)
+
+// It's dangerous to call the method on logging
+func Export(logger *Logger) {
+	if logger != nil {
+		gLogger = logger
+	}
+}
+
+func Debug(format string, a ...interface{}) {
+	gLogger.doPrintf(debugLevel, printDebugLevel, format, a...)
+}
+
+func Release(format string, a ...interface{}) {
+	gLogger.doPrintf(releaseLevel, printReleaseLevel, format, a...)
+}
+
+func Error(format string, a ...interface{}) {
+	gLogger.doPrintf(errorLevel, printErrorLevel, format, a...)
+}
+
+func Fatal(format string, a ...interface{}) {
+	gLogger.doPrintf(fatalLevel, printFatalLevel, format, a...)
 }
 
-func LollipopGoInfo(data interface{}) {
-	glog.Info(data)
-	return
+func Close() {
+	gLogger.Close()
 }

第一季 从零开始写游戏服务器 第二期/最新课节--课程代码/vender/src/LollipopGo/LollipopGo/lollipopGo.go

@@ -1,11 +1,20 @@
 package LollipopGo
 
 import (
+	"LollipopGo/LollipopGo/conf" // 配置文件
 	"LollipopGo/LollipopGo/log"
 )
 
-// 运行程序
 func Run() {
-	//  日志数据 -- 操作
-	log.LollipopGoInfo("Golang语言社区  LeafLtd %v starting up" + version)
+	// logger
+	if conf.LogLevel != "" {
+		logger, err := log.New(conf.LogLevel, conf.LogPath, conf.LogFlag)
+		if err != nil {
+			panic(err)
+		}
+		log.Export(logger)
+		defer logger.Close()
+	}
+
+	log.Release("Golang语言社区  LeafLtd %v starting up", version)
 }