--- /dev/null
+// Copyright (c) 2012-2016 The Revel Framework Authors, All rights reserved.
+// Revel Framework source code and usage is governed by a MIT style
+// license that can be found in the LICENSE file.
+
+package revel
+
+import (
+ "go/build"
+ "log"
+ "path/filepath"
+ "strings"
+
+ "encoding/json"
+ "fmt"
+ "github.com/revel/config"
+ "github.com/revel/revel/logger"
+ "github.com/revel/revel/model"
+)
+
+const (
+ // RevelImportPath Revel framework import path
+ RevelImportPath = "github.com/revel/revel"
+)
+
+const (
+ TEST_MODE_FLAG = "testModeFlag"
+ SPECIAL_USE_FLAG = "specialUseFlag"
+)
+
+// App details
+var (
+ RevelConfig *model.RevelContainer
+ AppName string // e.g. "sample"
+ AppRoot string // e.g. "/app1"
+ BasePath string // e.g. "$GOPATH/src/corp/sample"
+ AppPath string // e.g. "$GOPATH/src/corp/sample/app"
+ ViewsPath string // e.g. "$GOPATH/src/corp/sample/app/views"
+ ImportPath string // e.g. "corp/sample"
+ SourcePath string // e.g. "$GOPATH/src"
+
+ Config *config.Context
+ RunMode string // Application-defined (by default, "dev" or "prod")
+ DevMode bool // if true, RunMode is a development mode.
+
+ // Revel installation details
+ RevelPath string // e.g. "$GOPATH/src/github.com/revel/revel"
+
+ // Where to look for templates
+ // Ordered by priority. (Earlier paths take precedence over later paths.)
+ CodePaths []string // Code base directories, for modules and app
+ TemplatePaths []string // Template path directories manually added
+
+ // ConfPaths where to look for configurations
+ // Config load order
+ // 1. framework (revel/conf/*)
+ // 2. application (conf/*)
+ // 3. user supplied configs (...) - User configs can override/add any from above
+ ConfPaths []string
+
+ // Server config.
+ //
+ // Alert: This is how the app is configured, which may be different from
+ // the current process reality. For example, if the app is configured for
+ // port 9000, HTTPPort will always be 9000, even though in dev mode it is
+ // run on a random port and proxied.
+ HTTPPort int // e.g. 9000
+ HTTPAddr string // e.g. "", "127.0.0.1"
+ HTTPSsl bool // e.g. true if using ssl
+ HTTPSslCert string // e.g. "/path/to/cert.pem"
+ HTTPSslKey string // e.g. "/path/to/key.pem"
+
+ // All cookies dropped by the framework begin with this prefix.
+ CookiePrefix string
+ // Cookie domain
+ CookieDomain string
+ // Cookie flags
+ CookieSecure bool
+
+ // Revel request access log, not exposed from package.
+ // However output settings can be controlled from app.conf
+
+ // True when revel engine has been initialized (Init has returned)
+ Initialized bool
+
+ // Private
+ secretKey []byte // Key used to sign cookies. An empty key disables signing.
+ packaged bool // If true, this is running from a pre-built package.
+ initEventList = []EventHandler{} // Event handler list for receiving events
+)
+
+// Init initializes Revel -- it provides paths for getting around the app.
+//
+// Params:
+// mode - the run mode, which determines which app.conf settings are used.
+// importPath - the Go import path of the application.
+// srcPath - the path to the source directory, containing Revel and the app.
+// If not specified (""), then a functioning Go installation is required.
+func Init(inputmode, importPath, srcPath string) {
+ RevelConfig = &model.RevelContainer{}
+ // Ignore trailing slashes.
+ ImportPath = strings.TrimRight(importPath, "/")
+ SourcePath = srcPath
+
+ RunMode = updateLog(inputmode)
+
+ // If the SourcePath is not specified, find it using build.Import.
+ var revelSourcePath string // may be different from the app source path
+ if SourcePath == "" {
+ revelSourcePath, SourcePath = findSrcPaths(importPath)
+ } else {
+ // If the SourcePath was specified, assume both Revel and the app are within it.
+ SourcePath = filepath.Clean(SourcePath)
+ revelSourcePath = SourcePath
+ packaged = true
+ }
+
+ RevelPath = filepath.Join(revelSourcePath, filepath.FromSlash(RevelImportPath))
+ BasePath = filepath.Join(SourcePath, filepath.FromSlash(importPath))
+ AppPath = filepath.Join(BasePath, "app")
+ ViewsPath = filepath.Join(AppPath, "views")
+
+ CodePaths = []string{AppPath}
+
+ if ConfPaths == nil {
+ ConfPaths = []string{}
+ }
+
+ // Config load order
+ // 1. framework (revel/conf/*)
+ // 2. application (conf/*)
+ // 3. user supplied configs (...) - User configs can override/add any from above
+ ConfPaths = append(
+ []string{
+ filepath.Join(RevelPath, "conf"),
+ filepath.Join(BasePath, "conf"),
+ },
+ ConfPaths...)
+
+ TemplatePaths = []string{
+ ViewsPath,
+ filepath.Join(RevelPath, "templates"),
+ }
+
+ // Load app.conf
+ var err error
+ Config, err = config.LoadContext("app.conf", ConfPaths)
+ if err != nil || Config == nil {
+ RevelLog.Fatal("Failed to load app.conf:", "error", err)
+ }
+
+ // After application config is loaded update the logger
+ updateLog(inputmode)
+
+ // Configure properties from app.conf
+ DevMode = Config.BoolDefault("mode.dev", false)
+ HTTPPort = Config.IntDefault("http.port", 9000)
+ HTTPAddr = Config.StringDefault("http.addr", "")
+ HTTPSsl = Config.BoolDefault("http.ssl", false)
+ HTTPSslCert = Config.StringDefault("http.sslcert", "")
+ HTTPSslKey = Config.StringDefault("http.sslkey", "")
+ if HTTPSsl {
+ if HTTPSslCert == "" {
+ RevelLog.Fatal("No http.sslcert provided.")
+ }
+ if HTTPSslKey == "" {
+ RevelLog.Fatal("No http.sslkey provided.")
+ }
+ }
+
+ AppName = Config.StringDefault("app.name", "(not set)")
+ AppRoot = Config.StringDefault("app.root", "")
+ CookiePrefix = Config.StringDefault("cookie.prefix", "REVEL")
+ CookieDomain = Config.StringDefault("cookie.domain", "")
+ CookieSecure = Config.BoolDefault("cookie.secure", HTTPSsl)
+ if secretStr := Config.StringDefault("app.secret", ""); secretStr != "" {
+ SetSecretKey([]byte(secretStr))
+ }
+
+ RaiseEvent(REVEL_BEFORE_MODULES_LOADED, nil)
+ loadModules()
+ RaiseEvent(REVEL_AFTER_MODULES_LOADED, nil)
+
+ Initialized = true
+ RevelLog.Info("Initialized Revel", "Version", Version, "BuildDate", BuildDate, "MinimumGoVersion", MinimumGoVersion)
+}
+
+// The input mode can be as simple as "prod" or it can be a JSON string like
+// {"mode":"%s","testModeFlag":true}
+// When this function is called it returns the true "inputmode" extracted from the parameter
+// and it sets the log context appropriately
+func updateLog(inputmode string) (returnMode string) {
+ if inputmode == "" {
+ returnMode = config.DefaultSection
+ return
+ } else {
+ returnMode = inputmode
+ }
+
+ // Check to see if the mode is a json object
+ modemap := map[string]interface{}{}
+
+ var testModeFlag, specialUseFlag bool
+ if err := json.Unmarshal([]byte(inputmode), &modemap); err == nil {
+ returnMode = modemap["mode"].(string)
+ if testmode, found := modemap[TEST_MODE_FLAG]; found {
+ testModeFlag, _ = testmode.(bool)
+ }
+ if specialUse, found := modemap[SPECIAL_USE_FLAG]; found {
+ specialUseFlag, _ = specialUse.(bool)
+ }
+ }
+
+ var newContext *config.Context
+ // If the Config is nil, set the logger to minimal log messages by adding the option
+ if Config == nil {
+ newContext = config.NewContext()
+ newContext.SetOption(TEST_MODE_FLAG, fmt.Sprint(true))
+ } else {
+ // Ensure that the selected runmode appears in app.conf.
+ // If empty string is passed as the mode, treat it as "DEFAULT"
+ if !Config.HasSection(returnMode) {
+ log.Fatalln("app.conf: No mode found:", returnMode)
+ }
+ Config.SetSection(returnMode)
+ newContext = Config
+ }
+
+ // Only set the testmode flag if it doesnt exist
+ if _, found := newContext.Bool(TEST_MODE_FLAG); !found {
+ newContext.SetOption(TEST_MODE_FLAG, fmt.Sprint(testModeFlag))
+ }
+ if _, found := newContext.Bool(SPECIAL_USE_FLAG); !found {
+ newContext.SetOption(SPECIAL_USE_FLAG, fmt.Sprint(specialUseFlag))
+ }
+
+ appHandle := logger.InitializeFromConfig(BasePath, newContext)
+
+ // Set all the log handlers
+ setAppLog(AppLog, appHandle)
+
+ return
+}
+
+// Set the secret key
+func SetSecretKey(newKey []byte) error {
+ secretKey = newKey
+ return nil
+}
+
+// ResolveImportPath returns the filesystem path for the given import path.
+// Returns an error if the import path could not be found.
+func ResolveImportPath(importPath string) (string, error) {
+ if packaged {
+ return filepath.Join(SourcePath, importPath), nil
+ }
+
+ modPkg, err := build.Import(importPath, RevelPath, build.FindOnly)
+ if err != nil {
+ return "", err
+ }
+ return modPkg.Dir, nil
+}
+
+// CheckInit method checks `revel.Initialized` if not initialized it panics
+func CheckInit() {
+ if !Initialized {
+ RevelLog.Panic("CheckInit: Revel has not been initialized!")
+ }
+}
+
+// findSrcPaths uses the "go/build" package to find the source root for Revel
+// and the app.
+func findSrcPaths(importPath string) (revelSourcePath, appSourcePath string) {
+ var (
+ gopaths = filepath.SplitList(build.Default.GOPATH)
+ goroot = build.Default.GOROOT
+ )
+
+ if len(gopaths) == 0 {
+ RevelLog.Fatal("GOPATH environment variable is not set. " +
+ "Please refer to http://golang.org/doc/code.html to configure your Go environment.")
+ }
+
+ if ContainsString(gopaths, goroot) {
+ RevelLog.Fatalf("GOPATH (%s) must not include your GOROOT (%s). "+
+ "Please refer to http://golang.org/doc/code.html to configure your Go environment.",
+ gopaths, goroot)
+ }
+
+ appPkg, err := build.Import(importPath, "", build.FindOnly)
+ if err != nil {
+ RevelLog.Panic("Failed to import "+importPath+" with error:", "error", err)
+ }
+
+ revelPkg, err := build.Import(RevelImportPath, appPkg.Dir, build.FindOnly)
+ if err != nil {
+ RevelLog.Fatal("Failed to find Revel with error:", "error", err)
+ }
+
+ return revelPkg.Dir[:len(revelPkg.Dir)-len(RevelImportPath)], appPkg.SrcRoot
+}
Code Review / iec.git / blobdiff