Пример #1
0
func init() {
	//获取当天时间
	now := time.Now().Format("2006-01-02")
	file, err := os.OpenFile("/Users/mac/mygo/src/blog/log/"+now+".log", os.O_RDWR|os.O_APPEND, 0644)
	if err != nil {
		fd, err := os.Create("/Users/mac/mygo/src/blog/log/" + now + ".log")
		if err != nil {
			beego.Critical("openfile beepkg.log:", err)
			return
		}
		lg := log.New(fd, "", log.Ldate|log.Ltime)
		beego.SetLogger(lg)
	}
	lg := log.New(file, "", log.Ldate|log.Ltime)
	beego.SetLogger(lg)
}
Пример #2
0
func init() {
	/* 로그기록 */
	//NewLogger(10000)
	beego.SetLogger("file", `{"filename":"server.log"}`)

	/* 데이타베이스 드라이브 설정 */
	orm.RegisterDriver("mysql", orm.DR_MySQL)
	orm.RegisterDataBase("default", "mysql", "root:Kim616294.@/cluber?charset=utf8&loc=Asia%2FSeoul")

	/* 데이타베이스 테이블 등록 */
	orm.RegisterModel(new(models.User))
	orm.RegisterModel(new(models.Log))
	orm.RegisterModel(new(models.Contents))

	// 사용 데이타베이스
	name := "default"
	// 서버 시작시 테이블 재생성
	force := false
	// SQL 로그 확인
	verbose := true
	// 데이타베이스를 동기화 하고 에러 발생시 err 에 에러내용 입력
	err := orm.RunSyncdb(name, force, verbose)
	if err != nil {
		fmt.Println(err)
	}

}
Пример #3
0
func init() {
	// Try to have highest performance.
	runtime.GOMAXPROCS(runtime.NumCPU())

	// Set application log level.
	beego.SetLevel(beego.LevelTrace)

	// Initialize log file.
	os.Mkdir("./log", os.ModePerm)
	// Compute log file name as format '<year>-<month>-<day>.txt', eg.'2013-5-6.txt'.
	logName := fmt.Sprintf("./log/%d-%d-%d.txt", time.Now().Year(), time.Now().Month(), time.Now().Day())
	// Open or create log file.
	var fl *os.File
	var err error
	if utils.IsExist(logName) {
		fl, err = os.OpenFile(logName, os.O_RDWR|os.O_APPEND, 0644)
	} else {
		fl, err = os.Create(logName)
	}
	if err != nil {
		beego.Trace("Failed to init log file ->", err)
		return
	}
	beego.Info("Go Walker", VERSION)
	beego.SetLogger(log.New(fl, "", log.Ldate|log.Ltime))
}
Пример #4
0
func init() {
	beego.Router("/", &controllers.RootController{})
	beego.Router("/login/?:dest", &controllers.LoginController{})
	beego.Router("/logout/?:dest", &controllers.LogoutController{})
	beego.Router("/signup/?:dest", &controllers.SignupController{})
	beego.Router("/live-editor/", &controllers.LiveEditorController{})
	beego.Router("/graphics-animation/", &controllers.GraphicsController{})
	beego.Router("/external/:file", &controllers.LiveEditorController{})

	beego.SetStaticPath("/build", "bootstrap/live-editor/build")

	var FilterUser = func(ctx *context.Context) {
		_, ok := ctx.Input.Session("uid").(int)
		if !ok {
			ctx.Redirect(302, "/login")
		}
	}

	beego.InsertFilter("/user/:id([0-9]+)", beego.BeforeRouter, FilterUser)

	beego.ErrorController(&controllers.ErrorController{})
	beego.SetLogger("file", `{"filename":"log/spielplatz.log"}`)

	loadLanguages()
}
Пример #5
0
func main() {
	initDb()
	beego.InsertFilter("/*", beego.BeforeRouter, FilterUser)
	wbconf.LoadCategory()
	beego.SetLogger("file", `{"filename":"logs/running.log", "level":6 }`)
	beego.Run()

}
Пример #6
0
Файл: main.go Проект: lcbyz/Go
func main() {
	beego.SetLevel(beego.LevelInformational)
	beego.SetLogFuncCall(true)
	beego.SetLogger("file", `{"filename":"logs/test.log"}`)
	orm.Debug = true
	orm.RunSyncdb("default", false, true)
	beego.Run()
}
Пример #7
0
func main() {
	beego.SetLogger("file", `{"filename":"logs/output.log"}`)
	beego.SetLogFuncCall(true)

	controllers.DIYFunc()
	beego.ErrorController(&controllers.ErrorController{})

	beego.Run()
}
Пример #8
0
func Initialize(c conf.Logger) (err error) {

	switch c.Dist {
	case "file":

		if c.File.Minutes <= 0 {
			return
		}

		loggerErrChan := make(chan error)

		now := time.Now()

		m := now.Minute()
		i := (c.File.Minutes-(m-(m/c.File.Minutes*c.File.Minutes)))*60 - now.Second()

		go func(i int) {
			//Pre declaration need this for excluding redeclare any time variables in unlimited loop
			var dir, s string
			var err error
			var now time.Time

			for {

				now = time.Now()

				dir = c.File.Folder + fmt.Sprintf("%02d_%02d_%02d", now.Day(), now.Month(), now.Year())

				err = os.MkdirAll(dir, os.ModePerm)

				if err == nil {
					s = dir + "/" + fmt.Sprintf("%02d_%02d", now.Hour(), now.Minute()/c.File.Minutes*c.File.Minutes)
					if c.File.Ext != "" {
						s += "." + c.File.Ext
					}
					err = beego.SetLogger("file", `{"filename":"`+s+`"}`)
				}

				if err != nil {
					loggerErrChan <- err
				}

				time.Sleep(time.Millisecond * 1000 * time.Duration(i))
				i = c.File.Minutes * 60
			}
		}(i)

		go func() {
			for {
				beego.Error(<-loggerErrChan)
			}
		}()

	}

	return
}
Пример #9
0
func main() {
	//beego.EnableAdmin = true
	//beego.AdminHttpPort = 3001
	beego.SetLogger("console", "")
	beego.Router("/", &MainController{})
	if beego.AppConfig.String("imagepath") != imagePath {
		imagePath = beego.AppConfig.String("imagepath")
	}
	beego.Run()
}
Пример #10
0
func main() {
	beego.SetLogger("file", `{"filename":"logs/beego_bootstrap_api.log"}`)
	orm.RunCommand()
	if beego.BConfig.RunMode == "dev" {
		orm.Debug = true
		file, _ := os.OpenFile("logs/orm.log", os.O_APPEND|os.O_WRONLY, 0600)
		orm.DebugLog = orm.NewLog(file)
	}
	beego.Run()
}
Пример #11
0
func main() {
	orm.Debug = true
	//第二个参数表示数据表是不是每次启动的时候删除再重建,第三个参数是打印相关信息
	orm.RunSyncdb("default", false, true)

	fmt.Println("这是一个测试代码")

	beego.SetLogger("file", `{"filename":"logs/test.log"}`)
	beego.Run()
}
Пример #12
0
func main() {

	//initCache()
	orm.Debug, _ = beego.AppConfig.Bool("orm_debug")
	//logFile := beego.AppConfig.String("log_file")
	beego.SetLogger("file", `{"filename":"logs/o2oapi.log"}`)
	beego.SetLogFuncCall(true)

	beego.Run()

}
Пример #13
0
func init() {
	showNumberLine, _ := beego.AppConfig.Bool("logger.numberLine")
	levelString := beego.AppConfig.String("logger.level")
	logModels := beego.AppConfig.Strings("logger.logger")
	for _, logModel := range logModels {
		if logModel == "console" {
			beego.SetLogger("console", "")
		}
		if logModel == "file" {
			filename := beego.AppConfig.String("logger.filename")
			config := fmt.Sprintf(`{"filename":"%s","maxdays":30}`, filename)
			beego.SetLogger("file", config)
		}
	}
	if showNumberLine {
		beego.SetLogFuncCall(showNumberLine)
	}
	level, _ := Levelify(levelString)
	beego.SetLevel(level)
}
Пример #14
0
func InitLog() {
	if beego.BConfig.RunMode == "dev" {
		beego.Info("initiating log")
	}

	logconf, err := gofile.IoUtilReadFile(filepath.Join(beego.AppPath, "conf", "log.json"))
	if err != nil {
		panic(err)
	} else {
		beego.SetLogger("file", string(logconf))
	}
}
Пример #15
0
func main() {

	if beego.RunMode != "dev" {
		beego.BeeLogger.SetLevel(logs.LevelWarning)
		beego.BeeLogger.DelLogger("console")
		beego.SetLogger("file", `{"filename":"logs/app.log"}`)
	} else {
		beego.BeeLogger.SetLevel(logs.LevelDebug)
	}

	beego.Run()
}
Пример #16
0
Файл: main.go Проект: ilahsa/go
func init() {
	////// 初始化日志
	beego.SetLogger("file", `{"filename":"go_dg.log"}`)
	iniconf, err := config.NewConfig("ini", "config.conf")
	if err != nil {
		beego.Error("init config error", err)
		beego.BeeLogger.Flush()
		panic("init failed")
	}
	Config_Data_URL = iniconf.String("data_url")
	Config_PRS_URL = iniconf.String("prs_url")

}
Пример #17
0
func main() {
	beego.SessionOn = true
	beego.ErrorController(&controllers.ErrorController{})
	beego.AddFuncMap("i18n", i18n.Tr)

	beego.EnableAdmin = true // Port 8088

	beego.SetLogger("file", `{"filename":"logs/juna.log"}`)
	beego.SetLevel(beego.LevelInformational)
	beego.SetLogFuncCall(true)

	beego.AddFuncMap("news", news)
	beego.Run()
}
Пример #18
0
func main() {

	models.InitDb()
	beego.SessionOn = true
	beego.SetLogger("file", `{"filename":"`+common.Webconfig.LogFile+`"}`)
	beego.SetLevel(beego.LevelInformational)
	beego.SetLogFuncCall(true)
	beego.Info("begin setting router")

	beego.Router("/", &routers.HomeRouter{})
	beego.Router(`/page/:page([\d]+)`, &routers.HomeRouter{})

	beego.Router(`/article/:article([\w-]+)`, &routers.ArticleRouter{})

	beego.Router(`/tag/:tag([\S]+)/:page([\d]+)`, &routers.TagRouter{})
	beego.Router(`/tag/:tag([\S]+)`, &routers.TagRouter{})

	beego.Router(`/node/:node([\S]+)/:page([\d]+)`, &routers.NodeRouter{})
	beego.Router(`/node/:node([\S]+)`, &routers.NodeRouter{})

	beego.Router(`/category/:category([\S]+)/:page([\d]+)`, &routers.CategoryRouter{})
	beego.Router(`/category/:category([\S]+)`, &routers.CategoryRouter{})

	beego.Router("/subscribe", &routers.SubscribeRouter{})
	beego.Router(`/subscribe/:uid([\S]+)`, &routers.SubscribeRouter{})
	beego.Router(`/desubscribe/:uid([\S]+)`, &routers.SubscribeRouter{})

	beego.Router("/root", &root.RootMainRouter{})

	beego.Router("/root/category", &root.RootCategoryRouter{})

	beego.Router("/root/node", &root.RootNodeRouter{})

	beego.Router("/root/tag", &root.RootTagRouter{})

	beego.Router(`/root/article`, &root.RootArticleRouter{})
	//beego.Router(`/root/article/:opt([a-z]+)`, &root.RootArticleRouter{})
	beego.Router(`/root/article/:page([\d]+)`, &root.RootArticleRouter{})

	beego.Router("/root/upload", &root.RootUploadRouter{})

	beego.Router("/root/login", &root.LoginRouter{})
	beego.Router("/root/loginout", &root.LoginOutRouter{})

	beego.Router(`/prompt/:code([\w]+)`, &routers.PromptRouter{})

	beego.Info("starting server")
	beego.Run()
}
Пример #19
0
func init() {
	GlobalSessions, _ = session.NewManager("memory", `{
												"cookieName":"lte_securityid",
												"enableSetCookie,omitempty": true,
												"gclifetime":3600,
												"maxLifetime": 3600,
												"secure": true,
												"sessionIDHashFunc": "sha1",
												"sessionIDHashKey": "",
												"cookieLifeTime": 3600,
												"providerConfig": ""}`)
	go GlobalSessions.GC()
	beego.SetLogger("file", `{"filename":"logs/server.log"}`)
	beego.SetLevel(beego.LevelDebug)
}
Пример #20
0
// We have to call a initialize function manully
// because we use `bee bale` to pack static resources
// and we cannot make sure that which init() execute first.
func initialize() {
	setting.LoadConfig()

	//set logger
	if setting.IsProMode {
		beego.SetLogger("file", `{"filename":"logs/prod.log"}`)
		beego.SetLevel(beego.LevelInformational)
		beego.BeeLogger.DelLogger("console")
	} else {
		beego.SetLogger("file", `{"filename":"logs/dev.log"}`)
		beego.SetLevel(beego.LevelDebug)
		beego.BeeLogger.SetLogger("console", "")
	}
	beego.SetLogFuncCall(true)
	setting.SocialAuth = social.NewSocial("/login/", auth.SocialAuther)
	setting.SocialAuth.ConnectSuccessURL = "/settings/profile"
	setting.SocialAuth.ConnectFailedURL = "/settings/profile"
	setting.SocialAuth.ConnectRegisterURL = "/register/connect"
	setting.SocialAuth.LoginURL = "/login"

	//Qiniu
	ACCESS_KEY = setting.QiniuAccessKey
	SECRET_KEY = setting.QiniuSecurityKey
}
Пример #21
0
func init() {
	//ceshi
	//设置log格式
	beego.SetLogger("file", `{"filename":"logs/server.log"}`)
	beego.SetLevel(beego.LevelDebug)

	//设置session
	/*kkk
	beego.SessionOn = true
	beego.SessionProvider = "redis"
	beego.SessionSavePath = "192.168.15.43:6379"
	beego.SessionName = "LMSsessionID"
	beego.SessionGCMaxLifetime = 60
	beego.SessionCookieLifeTime = 60
	*/
}
Пример #22
0
func main() {
	beego.SetLogger("file", fmt.Sprintf("{\"filename\":\"%s/%s.log\"}", beego.AppConfig.String("log::FilePath"), beego.AppConfig.String("log::FileName")))

	app := cli.NewApp()
	app.Name = beego.AppConfig.String("appname")
	app.Usage = beego.AppConfig.String("usage")
	app.Version = beego.AppConfig.String("version")
	app.Author = "Meaglit Ma"
	app.Email = "*****@*****.**"

	app.Commands = []cli.Command{
		cmd.CmdWeb,
	}

	app.Flags = append(app.Flags, []cli.Flag{}...)
	app.Run(os.Args)
}
Пример #23
0
func init() {
	//设置log格式
	beego.SetLogger("file", `{"filename":"logs/server.log"}`)
	beego.SetLevel(beego.LevelDebug)

	//设置下载脚本目录
	beego.SetStaticPath("/script_download", "script_download")

	//设置session
	/*
		beego.SessionOn = true
		beego.SessionProvider = "redis"
		beego.SessionSavePath = "192.168.15.43:6379"
		beego.SessionName = "LMSsessionID"
		beego.SessionGCMaxLifetime = 60
		beego.SessionCookieLifeTime = 60
	*/
}
Пример #24
0
func main() {
	//setUserId()

	graceful, _ := beego.AppConfig.Bool("graceful")
	if !graceful {
		sigs := make(chan os.Signal, 1)
		signal.Notify(sigs, syscall.SIGINT, syscall.SIGTERM,
			syscall.SIGQUIT)
		go handleSignals(sigs)
	}

	beego.SetLogger("file", `{"filename":"logs/test.log"}`)
	mode := beego.AppConfig.String("runmode")
	if mode == "prod" {
		beego.SetLevel(beego.LevelInformational)
	}

	beego.Run()
}
Пример #25
0
func main() {
	beego.AddFuncMap("VaildError", vaildError)
	beego.SetStaticPath("amaze", "static/amaze")
	beego.SetStaticPath("hp", "static/hp")
	beego.SetStaticPath("term", "static/term")
	beego.SetStaticPath("static", "static")
	beego.ErrorController(&controllers.ErrorController{})
	router()
	loggerConfig := `{
		"filename":"log/beego.log",
		"maxlines" : 1000,
		"maxsize"  : 10240,
		"rotate": true,
		"daily":true,
		"maxdays":10
	}`
	beego.SetLogger("file", loggerConfig)
	beego.Run()
}
Пример #26
0
func main() {

	m.Connect()
	beego.ViewsPath = "views"
	beego.TemplateLeft = "<<<"
	beego.TemplateRight = ">>>"

	beego.AddTemplateExt("html")
	beego.SetStaticPath("/public", "public")

	beego.SetLogger("file", `{"filename":"logs/finprocess.log"}`)
	beego.SetLogFuncCall(true)

	logLevel, _ := beego.AppConfig.Int("log_level")
	beego.SetLevel(logLevel)

	//minutes for duration
	duration, _ := beego.AppConfig.Int("task_duration")

	go tasks.DailyTaskInit(duration) //启动task

	beego.Run()

}
Пример #27
0
func main() {
	beego.Info("ModuleAB server", version.Version, "starting...")
	logfile := beego.AppConfig.String("logFile")
	if logfile == "" {
		logfile = "logs/moduleab_server.log"
	}
	err := beego.SetLogger("file", fmt.Sprintf(`{"filename":"%s"}`, logfile))
	if err != nil {
		panic(err)
	}
	beego.SetLevel(beego.LevelInformational)

	beego.Info("Hello!")

	// 别用root运行我!
	if os.Getuid() == 0 {
		beego.Alert("Hey! You're running this server with user root!")
		panic("Don't run me with root!")
	}

	switch beego.BConfig.RunMode {
	case "initdb":
		beego.Info("Got runmode: Initialize database")
		err = orm.RunSyncdb("default", true, true)
		orm.Debug = true
		policies.InitDb()
		beego.Info("Database is ready")
		os.Exit(0)

	case "dev":
		beego.Info("Got runmode: Development")
		beego.SetLevel(beego.LevelDebug)
		beego.BConfig.WebConfig.DirectoryIndex = true
		beego.BConfig.WebConfig.StaticDir["/swagger"] = "swagger"

		beego.Debug("Now import database")
		orm.Debug = true
		err = orm.RunSyncdb("default", false, true)

	case "deb":
		beego.Info("Got runmode: Debug")
		beego.SetLevel(beego.LevelDebug)

		beego.Debug("Now import database")
		orm.Debug = true
		err = orm.RunSyncdb("default", false, true)

	default:
		beego.BeeLogger.DelLogger("console")
		err = orm.RunSyncdb("default", false, false)
	}
	if err != nil {
		beego.Alert("Database error:", err, ". go exit.")
		os.Exit(1)
	}
	beego.Debug("Current PID:", os.Getpid())
	ioutil.WriteFile(
		beego.AppConfig.String("pidFile"),
		[]byte(fmt.Sprint(os.Getpid())),
		0600,
	)
	beego.Info("Run check oas job...")
	go policies.CheckOasJob()
	beego.Info("All is ready, go running...")
	beego.BConfig.WebConfig.Session.SessionOn = true
	beego.BConfig.WebConfig.Session.SessionName = "Session_MobuleAB"
	beego.Run()
	defer func() {
		x := recover()
		if x != nil {
			beego.Error("Got fatal error:", x)
			stack := make([]byte, 0)
			runtime.Stack(stack, true)
			beego.Error("Stack trace:\n", string(stack))
			os.Exit(1)
		}
	}()
}
Пример #28
0
Файл: main.go Проект: xzdbd/blog
func main() {
	beego.SetLogger("file", `{"filename":"logs/server.log"}`)
	beego.BeeLogger.Async()
	beego.Run()
}
Пример #29
0
func init() {
	beego.SetLogger("file", `{"filename":"log"}`)

	//beego.SetLevel(beego.LevelInformational)
}
Пример #30
0
func main() {
	beego.SetLogger("file", `{"filename":"./log/inote.log"}`)
	beego.ErrorController(&controllers.ErrorController{})
	beego.Run()
}