// Copyright 2014 beego Author. All Rights Reserved. // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. package beego import ( "fmt" "html/template" "os" "path/filepath" "runtime" "strings" "github.com/astaxie/beego/config" "github.com/astaxie/beego/logs" "github.com/astaxie/beego/session" "github.com/astaxie/beego/utils" ) var ( // AccessLogs represent whether output the access logs, default is false AccessLogs bool // AdminHTTPAddr is address for admin AdminHTTPAddr string // AdminHTTPPort is listens port for admin AdminHTTPPort int // AppConfig is the instance of Config, store the config information from file AppConfig *beegoAppConfig // AppName represent Application name, always the project folder name AppName string // AppPath is the path to the application AppPath string // AppConfigPath is the path to the config files AppConfigPath string // AppConfigProvider is the provider for the config, default is ini AppConfigProvider string // AutoRender is a flag of render template automatically. It's always turn off in API application // default is true AutoRender bool // BeegoServerName exported in response header. BeegoServerName string // CopyRequestBody is just useful for raw request body in context. default is false CopyRequestBody bool // DirectoryIndex wheather display directory index. default is false. DirectoryIndex bool // EnableAdmin means turn on admin module to log every request info. EnableAdmin bool // EnableDocs enable generate docs & server docs API Swagger EnableDocs bool // EnableErrorsShow wheather show errors in page. if true, show error and trace info in page rendered with error template. EnableErrorsShow bool // EnableFcgi turn on the fcgi Listen, default is false EnableFcgi bool // EnableGzip means gzip the response EnableGzip bool // EnableHTTPListen represent whether turn on the HTTP, default is true EnableHTTPListen bool // EnableHTTPTLS represent whether turn on the HTTPS, default is true EnableHTTPTLS bool // EnableStdIo works with EnableFcgi Use FCGI via standard I/O EnableStdIo bool // EnableXSRF whether turn on xsrf. default is false EnableXSRF bool // FlashName is the name of the flash variable found in response header and cookie FlashName string // FlashSeperator used to seperate flash key:value, default is BEEGOFLASH FlashSeperator string // GlobalSessions is the instance for the session manager GlobalSessions *session.Manager // Graceful means use graceful module to start the server Graceful bool // workPath is always the same as AppPath, but sometime when it started with other // program, like supervisor workPath string // ListenTCP4 represent only Listen in TCP4, default is false ListenTCP4 bool // MaxMemory The whole request body is parsed and up to a total of maxMemory // bytes of its file parts are stored in memory, with the remainder stored on disk in temporary files MaxMemory int64 // HTTPAddr is the TCP network address addr for HTTP HTTPAddr string // HTTPPort is listens port for HTTP HTTPPort int // HTTPSPort is listens port for HTTPS HTTPSPort int // HTTPCertFile is the path to certificate file HTTPCertFile string // HTTPKeyFile is the path to private key file HTTPKeyFile string // HTTPServerTimeOut HTTP server timeout. default is 0, no timeout HTTPServerTimeOut int64 // RecoverPanic is a flag for auto recover panic, default is true RecoverPanic bool // RouterCaseSensitive means whether router case sensitive, default is true RouterCaseSensitive bool // RunMode represent the staging, "dev" or "prod" RunMode string // SessionOn means whether turn on the session auto when application started. default is false. SessionOn bool // SessionProvider means session provider, e.q memory, mysql, redis,etc. SessionProvider string // SessionName is the cookie name when saving session id into cookie. SessionName string // SessionGCMaxLifetime for auto cleaning expired session. SessionGCMaxLifetime int64 // SessionProviderConfig is for the provider config, define save path or connection info. SessionProviderConfig string // SessionCookieLifeTime means the life time of session id in cookie. SessionCookieLifeTime int // SessionAutoSetCookie auto setcookie SessionAutoSetCookie bool // SessionDomain means the cookie domain default is empty SessionDomain string // StaticDir store the static path, key is path, value is the folder StaticDir map[string]string // StaticExtensionsToGzip stores the extensions which need to gzip(.js,.css,etc) StaticExtensionsToGzip []string // TemplateCache store the caching template TemplateCache map[string]*template.Template // TemplateLeft left delimiter TemplateLeft string // TemplateRight right delimiter TemplateRight string // ViewsPath means the template folder ViewsPath string // XSRFKEY xsrf hash salt string. XSRFKEY string // XSRFExpire is the expiry of xsrf value. XSRFExpire int ) type beegoAppConfig struct { innerConfig config.Configer } func newAppConfig(AppConfigProvider, AppConfigPath string) (*beegoAppConfig, error) { ac, err := config.NewConfig(AppConfigProvider, AppConfigPath) if err != nil { return nil, err } rac := &beegoAppConfig{ac} return rac, nil } func (b *beegoAppConfig) Set(key, val string) error { err := b.innerConfig.Set(RunMode+"::"+key, val) if err == nil { return err } return b.innerConfig.Set(key, val) } func (b *beegoAppConfig) String(key string) string { v := b.innerConfig.String(RunMode + "::" + key) if v == "" { return b.innerConfig.String(key) } return v } func (b *beegoAppConfig) Strings(key string) []string { v := b.innerConfig.Strings(RunMode + "::" + key) if v[0] == "" { return b.innerConfig.Strings(key) } return v } func (b *beegoAppConfig) Int(key string) (int, error) { v, err := b.innerConfig.Int(RunMode + "::" + key) if err != nil { return b.innerConfig.Int(key) } return v, nil } func (b *beegoAppConfig) Int64(key string) (int64, error) { v, err := b.innerConfig.Int64(RunMode + "::" + key) if err != nil { return b.innerConfig.Int64(key) } return v, nil } func (b *beegoAppConfig) Bool(key string) (bool, error) { v, err := b.innerConfig.Bool(RunMode + "::" + key) if err != nil { return b.innerConfig.Bool(key) } return v, nil } func (b *beegoAppConfig) Float(key string) (float64, error) { v, err := b.innerConfig.Float(RunMode + "::" + key) if err != nil { return b.innerConfig.Float(key) } return v, nil } func (b *beegoAppConfig) DefaultString(key string, defaultval string) string { v := b.String(key) if v != "" { return v } return defaultval } func (b *beegoAppConfig) DefaultStrings(key string, defaultval []string) []string { v := b.Strings(key) if len(v) != 0 { return v } return defaultval } func (b *beegoAppConfig) DefaultInt(key string, defaultval int) int { v, err := b.Int(key) if err == nil { return v } return defaultval } func (b *beegoAppConfig) DefaultInt64(key string, defaultval int64) int64 { v, err := b.Int64(key) if err == nil { return v } return defaultval } func (b *beegoAppConfig) DefaultBool(key string, defaultval bool) bool { v, err := b.Bool(key) if err == nil { return v } return defaultval } func (b *beegoAppConfig) DefaultFloat(key string, defaultval float64) float64 { v, err := b.Float(key) if err == nil { return v } return defaultval } func (b *beegoAppConfig) DIY(key string) (interface{}, error) { return b.innerConfig.DIY(key) } func (b *beegoAppConfig) GetSection(section string) (map[string]string, error) { return b.innerConfig.GetSection(section) } func (b *beegoAppConfig) SaveConfigFile(filename string) error { return b.innerConfig.SaveConfigFile(filename) } func init() { workPath, _ = os.Getwd() workPath, _ = filepath.Abs(workPath) // initialize default configurations AppPath, _ = filepath.Abs(filepath.Dir(os.Args[0])) AppConfigPath = filepath.Join(AppPath, "conf", "app.conf") if workPath != AppPath { if utils.FileExists(AppConfigPath) { os.Chdir(AppPath) } else { AppConfigPath = filepath.Join(workPath, "conf", "app.conf") } } AppConfigProvider = "ini" StaticDir = make(map[string]string) StaticDir["/static"] = "static" StaticExtensionsToGzip = []string{".css", ".js"} TemplateCache = make(map[string]*template.Template) // set this to 0.0.0.0 to make this app available to externally EnableHTTPListen = true //default enable http Listen HTTPAddr = "" HTTPPort = 8080 HTTPSPort = 10443 AppName = "beego" RunMode = "dev" //default runmod AutoRender = true RecoverPanic = true ViewsPath = "views" SessionOn = false SessionProvider = "memory" SessionName = "beegosessionID" SessionGCMaxLifetime = 3600 SessionProviderConfig = "" SessionCookieLifeTime = 0 //set cookie default is the brower life SessionAutoSetCookie = true MaxMemory = 1 << 26 //64MB HTTPServerTimeOut = 0 EnableErrorsShow = true XSRFKEY = "beegoxsrf" XSRFExpire = 0 TemplateLeft = "{{" TemplateRight = "}}" BeegoServerName = "beegoServer:" + VERSION EnableAdmin = false AdminHTTPAddr = "127.0.0.1" AdminHTTPPort = 8088 FlashName = "BEEGO_FLASH" FlashSeperator = "BEEGOFLASH" RouterCaseSensitive = true runtime.GOMAXPROCS(runtime.NumCPU()) // init BeeLogger BeeLogger = logs.NewLogger(10000) err := BeeLogger.SetLogger("console", "") if err != nil { fmt.Println("init console log error:", err) } SetLogFuncCall(true) err = ParseConfig() if err != nil && os.IsNotExist(err) { // for init if doesn't have app.conf will not panic ac := config.NewFakeConfig() AppConfig = &beegoAppConfig{ac} Warning(err) } } // ParseConfig parsed default config file. // now only support ini, next will support json. func ParseConfig() (err error) { AppConfig, err = newAppConfig(AppConfigProvider, AppConfigPath) if err != nil { return err } envRunMode := os.Getenv("BEEGO_RUNMODE") // set the runmode first if envRunMode != "" { RunMode = envRunMode } else if runmode := AppConfig.String("RunMode"); runmode != "" { RunMode = runmode } HTTPAddr = AppConfig.String("HTTPAddr") if v, err := AppConfig.Int("HTTPPort"); err == nil { HTTPPort = v } if v, err := AppConfig.Bool("ListenTCP4"); err == nil { ListenTCP4 = v } if v, err := AppConfig.Bool("EnableHTTPListen"); err == nil { EnableHTTPListen = v } if maxmemory, err := AppConfig.Int64("MaxMemory"); err == nil { MaxMemory = maxmemory } if appname := AppConfig.String("AppName"); appname != "" { AppName = appname } if autorender, err := AppConfig.Bool("AutoRender"); err == nil { AutoRender = autorender } if autorecover, err := AppConfig.Bool("RecoverPanic"); err == nil { RecoverPanic = autorecover } if views := AppConfig.String("ViewsPath"); views != "" { ViewsPath = views } if sessionon, err := AppConfig.Bool("SessionOn"); err == nil { SessionOn = sessionon } if sessProvider := AppConfig.String("SessionProvider"); sessProvider != "" { SessionProvider = sessProvider } if sessName := AppConfig.String("SessionName"); sessName != "" { SessionName = sessName } if sessProvConfig := AppConfig.String("SessionProviderConfig"); sessProvConfig != "" { SessionProviderConfig = sessProvConfig } if sessMaxLifeTime, err := AppConfig.Int64("SessionGCMaxLifetime"); err == nil && sessMaxLifeTime != 0 { SessionGCMaxLifetime = sessMaxLifeTime } if sesscookielifetime, err := AppConfig.Int("SessionCookieLifeTime"); err == nil && sesscookielifetime != 0 { SessionCookieLifeTime = sesscookielifetime } if enableFcgi, err := AppConfig.Bool("EnableFcgi"); err == nil { EnableFcgi = enableFcgi } if enablegzip, err := AppConfig.Bool("EnableGzip"); err == nil { EnableGzip = enablegzip } if directoryindex, err := AppConfig.Bool("DirectoryIndex"); err == nil { DirectoryIndex = directoryindex } if timeout, err := AppConfig.Int64("HTTPServerTimeOut"); err == nil { HTTPServerTimeOut = timeout } if errorsshow, err := AppConfig.Bool("EnableErrorsShow"); err == nil { EnableErrorsShow = errorsshow } if copyrequestbody, err := AppConfig.Bool("CopyRequestBody"); err == nil { CopyRequestBody = copyrequestbody } if xsrfkey := AppConfig.String("XSRFKEY"); xsrfkey != "" { XSRFKEY = xsrfkey } if enablexsrf, err := AppConfig.Bool("EnableXSRF"); err == nil { EnableXSRF = enablexsrf } if expire, err := AppConfig.Int("XSRFExpire"); err == nil { XSRFExpire = expire } if tplleft := AppConfig.String("TemplateLeft"); tplleft != "" { TemplateLeft = tplleft } if tplright := AppConfig.String("TemplateRight"); tplright != "" { TemplateRight = tplright } if httptls, err := AppConfig.Bool("EnableHTTPTLS"); err == nil { EnableHTTPTLS = httptls } if httpsport, err := AppConfig.Int("HTTPSPort"); err == nil { HTTPSPort = httpsport } if certfile := AppConfig.String("HTTPCertFile"); certfile != "" { HTTPCertFile = certfile } if keyfile := AppConfig.String("HTTPKeyFile"); keyfile != "" { HTTPKeyFile = keyfile } if serverName := AppConfig.String("BeegoServerName"); serverName != "" { BeegoServerName = serverName } if flashname := AppConfig.String("FlashName"); flashname != "" { FlashName = flashname } if flashseperator := AppConfig.String("FlashSeperator"); flashseperator != "" { FlashSeperator = flashseperator } if sd := AppConfig.String("StaticDir"); sd != "" { for k := range StaticDir { delete(StaticDir, k) } sds := strings.Fields(sd) for _, v := range sds { if url2fsmap := strings.SplitN(v, ":", 2); len(url2fsmap) == 2 { StaticDir["/"+strings.TrimRight(url2fsmap[0], "/")] = url2fsmap[1] } else { StaticDir["/"+strings.TrimRight(url2fsmap[0], "/")] = url2fsmap[0] } } } if sgz := AppConfig.String("StaticExtensionsToGzip"); sgz != "" { extensions := strings.Split(sgz, ",") fileExts := []string{} for _, ext := range extensions { ext = strings.TrimSpace(ext) if ext == "" { continue } if !strings.HasPrefix(ext, ".") { ext = "." + ext } fileExts = append(fileExts, ext) } if len(fileExts) > 0 { StaticExtensionsToGzip = fileExts } } if enableadmin, err := AppConfig.Bool("EnableAdmin"); err == nil { EnableAdmin = enableadmin } if adminhttpaddr := AppConfig.String("AdminHTTPAddr"); adminhttpaddr != "" { AdminHTTPAddr = adminhttpaddr } if adminhttpport, err := AppConfig.Int("AdminHTTPPort"); err == nil { AdminHTTPPort = adminhttpport } if enabledocs, err := AppConfig.Bool("EnableDocs"); err == nil { EnableDocs = enabledocs } if casesensitive, err := AppConfig.Bool("RouterCaseSensitive"); err == nil { RouterCaseSensitive = casesensitive } if graceful, err := AppConfig.Bool("Graceful"); err == nil { Graceful = graceful } return nil }