func init() {
logger, err := log.LoggerFromConfigAsFile("seelog.xml")
if err != nil {
panic(err)
}
log.ReplaceLogger(logger)
}
func main() {
//err := LoadConfig("/system/etc/conf.json")
err := LoadConfig("./conf.json")
if err != nil {
fmt.Printf("LoadConfig failed: (%s)", err)
os.Exit(1)
}
//logger, err := log.LoggerFromConfigAsFile("/system/etc/log.xml")
logger, err := log.LoggerFromConfigAsFile("./log.xml")
if err != nil {
fmt.Printf("Load log config failed: (%s)\n", err)
os.Exit(1)
}
log.ReplaceLogger(logger)
//wg := &sync.WaitGroup{}
agent := NewAgent()
c := make(chan os.Signal, 1)
signal.Notify(c, os.Interrupt, syscall.SIGTERM, syscall.SIGQUIT)
wg := sync.WaitGroup{}
wg.Add(1)
go func() {
agent.Run()
log.Infof("agent quited")
wg.Done()
}()
sig := <-c
log.Infof("Received signal '%v', exiting\n", sig)
agent.Stop()
wg.Wait()
}
func initAppConfig() {
logger, err := seelog.LoggerFromConfigAsFile("./config/log.xml")
if err != nil {
log.Fatalln(err)
}
Logger = logger
}
func InitLogger(configFile string) {
fmt.Fprintln(os.Stderr, "Use "+configFile+" init Logger")
m.Lock()
defer m.Unlock()
if loggerInitd {
Errorf("Logger has been already inited.")
return
}
seelogger, err := seelog.LoggerFromConfigAsFile(configFile)
if err != nil {
log.Panicf("Can't init Logger,error:%s", err)
return
} else {
//确保取得正确的调用堆栈
seelogger.SetAdditionalStackDepth(2)
}
realLogger := logger.(*SeeLogLogger)
if realLogger.seelogger != nil {
realLogger.seelogger.Flush()
realLogger.seelogger.Close()
}
realLogger.seelogger = seelogger
loggerInitd = true
}
func SeelogConfig() seelog.LoggerInterface {
logger, err := seelog.LoggerFromConfigAsFile("seelog_config.xml")
if err != nil {
fmt.Println(err)
return nil
}
return logger
}
func LoadConf(configPath string) {
DisableLog()
logger, err := seelog.LoggerFromConfigAsFile(configPath)
if err != nil {
panic(err)
}
UseLogger(logger)
}
func InitLogger(configPath string) {
logger, err := seelog.LoggerFromConfigAsFile(configPath)
if err != nil {
fmt.Println(err)
os.Exit(-1)
}
seelog.ReplaceLogger(logger)
}
func loadAppConfig() {
logger, err := seelog.LoggerFromConfigAsFile("./seelog.xml")
if err != nil {
fmt.Println(err)
return
}
UseLogger(logger)
}
func updateLogger() error {
logger, err := log.LoggerFromConfigAsFile(LOGGER_CONFIG)
if err != nil {
return err
}
return log.ReplaceLogger(logger)
}
func InitSeeLog(seeLogCfgFile string) {
logger, err := log.LoggerFromConfigAsFile(seeLogCfgFile)
if err != nil {
log.Errorf("Parse seelog config file error: %s", err.Error)
os.Exit(1)
}
log.ReplaceLogger(logger)
}
func main() {
defer log.Flush()
logger, err := log.LoggerFromConfigAsFile("seelog.xml")
if nil != err {
log.Warn("Failed to load config", err)
}
log.ReplaceLogger(logger)
flag.Parse()
statsTransformChannel := make(chan *diskStat.DiskStat, 10)
statsOutputChannel := make(chan *diskStat.ExtendedIoStats, 10)
var output outputInterface.Output
proto := PStdOut
switch *protocolType {
case "protobuffers":
{
proto = PProtoBuffers
}
case "json":
{
proto = PJson
}
default:
{
if *outputType == "zmq" {
proto = PProtoBuffers
} else if *outputType == "stdout" {
proto = PStdOut
}
}
}
switch *outputType {
case "zmq":
output, err = zmqOutput.NewZmqOutput(queueUrl, proto)
case "nano":
output, err = nanoMsgOutput.NewNanoMsgOutput(queueUrl, proto)
default:
output = &logOutput.LogOutput{proto}
}
if nil != err {
log.Error("Failed to setup output ", err)
}
go ioStatTransform.TransformStat(statsTransformChannel, statsOutputChannel)
go statsOutput.Output(statsOutputChannel, output)
for {
readAndSendStats(statsTransformChannel)
time.Sleep(time.Second * time.Duration(*interval))
}
close(statsTransformChannel)
close(statsOutputChannel)
}
func log_init() {
defer log.Flush()
logger, e := log.LoggerFromConfigAsFile(GetConfigDir() + "/log.conf")
if e != nil {
log.Criticalf("Error %v", e)
}
log.ReplaceLogger(logger)
//TODO timer watch config file
}
func main() {
cfgfile := "conf.json"
begin := 0
count := 1
if len(os.Args) >= 3 {
begin, _ = strconv.Atoi(os.Args[1])
count, _ = strconv.Atoi(os.Args[2])
}
r, err := os.Open(cfgfile)
if err != nil {
fmt.Printf("failed to open config file %s", cfgfile)
os.Exit(1)
}
var config Config
decoder := json.NewDecoder(r)
err = decoder.Decode(&config)
if err != nil {
fmt.Printf("invalid config file")
os.Exit(1)
}
if config.ReadTimeout <= 0 {
config.ReadTimeout = time.Duration(20)
}
logger, err := log.LoggerFromConfigAsFile("log.xml")
if err != nil {
fmt.Printf("Load log config failed: (%s)\n", err)
os.Exit(1)
}
log.ReplaceLogger(logger)
server, _ := net.ResolveTCPAddr("tcp4", config.Server)
wg := &sync.WaitGroup{}
c := make(chan os.Signal, 1)
ctrl := make(chan bool, 1)
signal.Notify(c, os.Interrupt, syscall.SIGTERM, syscall.SIGQUIT)
running := true
wg.Add(1)
go func() {
sig := <-c
log.Infof("Received signal '%v', exiting\n", sig)
running = false
close(ctrl)
wg.Done()
}()
for n := begin; n < begin+count; n++ {
if !running {
break
}
go runClient(n, &config, wg, ctrl, nil, server)
time.Sleep(config.Interval * time.Millisecond)
}
wg.Wait()
}
func loadAppConfig() {
//logger, err := seelog.LoggerFromConfigAsBytes([]byte(appConfig))
logger, err := seelog.LoggerFromConfigAsFile("conf/seelog.xml")
if err != nil {
fmt.Println(err)
return
}
UseLogger(logger)
}
func NewLogger(cfgfile string) *BurrowLogger {
logger, err := log.LoggerFromConfigAsFile(cfgfile)
if err != nil {
log.Criticalf("Cannot start logger: %v", err)
os.Exit(1)
}
log.ReplaceLogger(logger)
return &BurrowLogger{logger}
}
func main() {
configFile := flag.String("cfg", "", "The config file")
testSummary := flag.Bool("testSummary", false, "Test summary mode")
flag.Parse()
file, err := os.Open(*configFile)
errHndlr(err, FATAL)
decoder := json.NewDecoder(file)
config := &StartupConfig{}
err = decoder.Decode(&config)
errHndlr(err, FATAL)
if config.RedisInterval == 0 {
config.RedisInterval = defaultRedisInterval
}
logger, err := log.LoggerFromConfigAsFile(config.SeelogConfig)
defer log.Flush()
if err != nil {
panic("error reading " + config.SeelogConfig)
}
fmt.Println("Replacing logger, see log file according to " + config.SeelogConfig)
if *testSummary {
fmt.Println("WARNING: testSummary is on!")
}
log.ReplaceLogger(logger)
runtime.GOMAXPROCS(runtime.NumCPU())
runningConfig, nil := getTmData(config, true)
go houseKeeping(runningConfig, *testSummary)
freeList := NewPool(16, config.RedisString)
<-time.NewTimer(time.Now().Truncate(time.Duration(config.RedisInterval) * time.Second).Add(time.Duration(config.RedisInterval) * time.Second).Sub(time.Now())).C
tickerChan := time.Tick(time.Duration(config.RedisInterval) * time.Second)
for now := range tickerChan {
if now.Second() == 30 {
trc, err := getTmData(config, false)
if err == nil {
runningConfig = trc
}
}
for cdnName, urls := range runningConfig.HealthUrls {
for _, url := range urls {
// log.Info(cdnName, " ", statName, " -> ", url)
if *testSummary {
fmt.Println("Skipping stat write - testSummary mode is ON!")
continue
}
go rascalToRedis(cdnName, url, runningConfig.CacheGroupMap, freeList, config)
}
}
}
}
func loadConfig() {
// PJ直下で実装した場合
logger, err := log.LoggerFromConfigAsFile("./conf/seelog/development.xml")
if err != nil {
panic("fail to load config")
}
log.ReplaceLogger(logger)
}
// init log by config
func (s *BaseService) initlog() {
if s.Cfg.Log != "" {
if logger, err := log.LoggerFromConfigAsFile(s.Cfg.Log); err == nil {
log.ReplaceLogger(logger)
}
}
// init echo log
s.echo.SetLogger(NewEchoLogger())
}
func initializeLogging() {
logger, err := log.LoggerFromConfigAsFile("config/logconfig.xml")
if err != nil {
log.Criticalf("An error occurred whilst initializing logging\n", err.Error())
panic(err)
}
log.ReplaceLogger(logger)
}
func loadLogConfig(configFile string) {
// check for custom logging
if logger, err := log.LoggerFromConfigAsFile(configFile); err != nil {
log.Errorf("[Server] Error loading custom logging config from %s: %v", configFile, err)
} else {
log.ReplaceLogger(logger)
glob.Logger = logger
log.Infof("[Server] Custom logging enabled from %s", configFile)
}
}
func main() {
var (
flConfig = flag.String("c", "./etc/conf.json", "Config file")
)
flag.Parse()
err := conf.LoadConfig(*flConfig)
if err != nil {
fmt.Printf("LoadConfig (%s) failed: (%s)\n", *flConfig, err)
os.Exit(1)
}
logger, err := log.LoggerFromConfigAsFile("./etc/log.xml")
if err != nil {
fmt.Printf("Load log config failed: (%s)\n", err)
os.Exit(1)
}
log.ReplaceLogger(logger)
waitGroup := &sync.WaitGroup{}
cometServer := comet.NewServer()
listener, err := cometServer.Init(conf.Config.Comet)
if err != nil {
log.Criticalf("Failed to start comet server: %s", err.Error())
os.Exit(1)
}
cometServer.SetAcceptTimeout(time.Duration(conf.Config.AcceptTimeout) * time.Second)
cometServer.SetReadTimeout(time.Duration(conf.Config.ReadTimeout) * time.Second)
cometServer.SetHeartbeatTimeout(time.Duration(conf.Config.HeartbeatTimeout) * time.Second)
c := make(chan os.Signal, 1)
signal.Notify(c, os.Interrupt, syscall.SIGTERM, syscall.SIGQUIT)
go func() {
sig := <-c
log.Infof("Received signal '%v', exiting\n", sig)
///utils.RemovePidFile(srv. runtime.config.Pidfile)
cometServer.Stop()
log.Infof("leave 1")
waitGroup.Done()
log.Infof("leave 2")
}()
go func() {
cometServer.Run(listener)
}()
waitGroup.Add(1)
go api.StartHttp(conf.Config.Web)
waitGroup.Wait()
}
//package 初始化
func init() {
//读取配置文件，创建logger
newLogger, err := log.LoggerFromConfigAsFile("conf/log.xml")
if err != nil {
fmt.Println("logger initial failed!")
return
}
log.ReplaceLogger(newLogger)
defaultLogger = log.Current
defaultLogger.Info("logger initial success!")
}
// Initialize logging from command arguments.
func initLogging(configFile string) {
var err error
log.RegisterReceiver("stderr", &CustomReceiver{})
if configFile == "" {
logger, err = log.LoggerFromConfigAsString(defaultLoggingConfig)
checkLogFatal("Failed to load default logging configuration: %s", err)
} else {
logger, err = log.LoggerFromConfigAsFile(configFile)
checkLogFatal("Failed to initialize custom logging file %s: %s", configFile, err)
}
}
func loadLogger() {
logger, err := log.LoggerFromConfigAsFile("logger.xml")
if err != nil {
log.Error("Can not load the logger configuration file, Please check if the file logger.xml exists on current directory", err)
os.Exit(1)
} else {
log.ReplaceLogger(logger)
logger.Flush()
}
}
func ChangeLogEnv(kind int) {
//开发环境
if kind == 1 {
logger, err := log.LoggerFromConfigAsFile("config/logconfig_debug.xml")
if err != nil {
log.Errorf("create log error,error is %s ", err.Error())
}
log.UseLogger(logger)
} else if kind == 2 { //生产环境
logger, err := log.LoggerFromConfigAsFile("config/logconfig_production.xml")
if err != nil {
log.Errorf("create log error,error is %s ", err.Error())
}
log.UseLogger(logger)
} else {
Error("can't recognize log environment")
}
}
func main() {
defer log.Flush()
logger, err := log.LoggerFromConfigAsFile("seelog.xml")
rep.ReporterConfig("ipc:///temp/testSender.ipc", 0)
r := rep.NewReporter()
defer r.Close()
if err != nil {
log.Warn("Failed to load config", err)
}
log.ReplaceLogger(logger)
start.Run()
}
func main() {
flag.Parse()
logger, err := log.LoggerFromConfigAsFile("seelog.xml")
if err != nil {
log.Critical("err parsing config file", err)
return
}
log.ReplaceLogger(logger)
count = readFile(*bidResFile)
http.HandleFunc(*path, DspServe)
http.ListenAndServe(":"+*port, nil)
}
func main() {
defer log.Flush()
logger, err := log.LoggerFromConfigAsFile("seelog.xml")
if err != nil {
log.Warn("Failed to load logger config", err)
} else {
log.ReplaceLogger(logger)
}
rest.StartServer()
}
func InitLoggerByConfig(fileName string) {
defer func() {
logConfigLocker.Unlock()
}()
logConfigLocker.Lock()
logger, err := log.LoggerFromConfigAsFile(fileName)
if err != nil {
log.Errorf("Can not create log from config file. FileName: %s", fileName)
return
}
log.ReplaceLogger(logger)
}
func main() {
logConfigFile := flag.String("l", "./conf/log.xml", "Log config file")
configFile := flag.String("c", "./conf/conf.json", "Config file")
flag.Parse()
logger, err := log.LoggerFromConfigAsFile(*logConfigFile)
if err != nil {
fmt.Printf("Load log config failed: (%s)\n", err)
os.Exit(1)
}
log.ReplaceLogger(logger)
err = conf.LoadConfig(*configFile)
if err != nil {
log.Warnf("LoadConfig (%s) failed: (%s)\n", *configFile, err)
os.Exit(1)
}
http.HandleFunc("/api/v1/notify", postNotify)
err = http.ListenAndServe(conf.Config.Notify.Addr, nil)
if err != nil {
log.Warnf("failed to ListenAndServe: ", err)
os.Exit(1)
}
}
