// 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(mode, importPath, srcPath string) {
// Ignore trailing slashes.
ImportPath = strings.TrimRight(importPath, "/")
sourcePath := srcPath
RunMode = mode
if runtime.GOOS == "windows" {
gocolorize.SetPlain(true)
}
// 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 = path.Clean(sourcePath)
revelSourcePath = sourcePath
packaged = true
}
basePath := path.Join(sourcePath, filepath.FromSlash(importPath))
InitDirectly(mode, revelSourcePath, basePath)
}
func Parse() {
if runtime.GOOS == "windows" {
gocolorize.SetPlain(true)
}
var err = gcfg.ReadFileInto(&AppCfg, "App.cfg")
if err != nil {
errorf("Missing App.cfg")
os.Exit(1)
}
fmt.Fprintf(os.Stdout, gocolorize.NewColor("Blue").Paint(AppCfg.App.Header))
flag.Usage = func() { usage(1) }
flag.Parse()
args := flag.Args()
if len(args) < 1 || args[0] == "help" {
if len(args) == 1 {
usage(0)
}
if len(args) > 1 {
for _, cmd := range commands {
if cmd.Name() == args[1] {
tmpl(os.Stdout, AppCfg.Template.helpTemplate, cmd)
return
}
}
}
usage(2)
}
// Commands use panic to abort execution when something goes wrong.
// Panics are logged at the point of error. Ignore those.
defer func() {
if err := recover(); err != nil {
if _, ok := err.(LoggedError); !ok {
// This panic was not expecred/logged.
panic(err)
}
os.Exit(1)
}
}()
for _, cmd := range commands {
if cmd.Name() == args[0] {
cmd.Run(args[1:])
return
}
}
errorf("Unknown command.\n Run '%q help' for usage", args[0])
}
func main() {
if !terminal.IsTerminal(int(os.Stdout.Fd())) {
gocolorize.SetPlain(true)
}
parser := flags.NewNamedParser("beanstool", flags.Default)
parser.AddCommand("stats", "print stats on all tubes", "", &cli.StatsCommand{})
parser.AddCommand("tail", "tails a tube and prints his content", "", &cli.TailCommand{})
parser.AddCommand("peek", "peeks a job from a queue", "", &cli.PeekCommand{})
parser.AddCommand("delete", "delete a job from a queue", "", &cli.DeleteCommand{})
parser.AddCommand("kick", "kicks jobs from buried back into ready", "", &cli.KickCommand{})
parser.AddCommand("put", "put a job into a tube", "", &cli.PutCommand{})
parser.AddCommand("bury", "bury existing jobs from ready state", "", &cli.BuryCommand{})
_, err := parser.Parse()
if err != nil {
if _, ok := err.(*flags.Error); ok {
parser.WriteHelp(os.Stdout)
}
os.Exit(1)
}
}
// 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(mode, importPath, srcPath string) {
// Ignore trailing slashes.
ImportPath = strings.TrimRight(importPath, "/")
SourcePath = srcPath
RunMode = mode
if runtime.GOOS == "windows" {
gocolorize.SetPlain(true)
}
// 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 = path.Clean(SourcePath)
revelSourcePath = SourcePath
packaged = true
}
RevelPath = path.Join(revelSourcePath, filepath.FromSlash(REVEL_IMPORT_PATH))
BasePath = path.Join(SourcePath, filepath.FromSlash(importPath))
AppPath = path.Join(BasePath, "app")
ViewsPath = path.Join(AppPath, "views")
CodePaths = []string{AppPath}
ConfPaths = []string{
path.Join(BasePath, "conf"),
path.Join(RevelPath, "conf"),
}
TemplatePaths = []string{
ViewsPath,
path.Join(RevelPath, "templates"),
}
// Load app.conf
var err error
Config, err = LoadConfig("app.conf")
if err != nil || Config == nil {
log.Fatalln("Failed to load app.conf:", err)
}
// Ensure that the selected runmode appears in app.conf.
// If empty string is passed as the mode, treat it as "DEFAULT"
if mode == "" {
mode = config.DEFAULT_SECTION
}
if !Config.HasSection(mode) {
log.Fatalln("app.conf: No mode found:", mode)
}
Config.SetSection(mode)
// 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 == "" {
log.Fatalln("No http.sslcert provided.")
}
if HttpSslKey == "" {
log.Fatalln("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", "")
CookieHttpOnly = Config.BoolDefault("cookie.httponly", false)
CookieSecure = Config.BoolDefault("cookie.secure", false)
TemplateDelims = Config.StringDefault("template.delimiters", "")
if secretStr := Config.StringDefault("app.secret", ""); secretStr != "" {
secretKey = []byte(secretStr)
}
// Configure logging
if !Config.BoolDefault("log.colorize", true) {
gocolorize.SetPlain(true)
}
TRACE = getLogger("trace")
INFO = getLogger("info")
WARN = getLogger("warn")
ERROR = getLogger("error")
loadModules()
Initialized = true
INFO.Printf("Initialized Revel v%s (%s) for %s", VERSION, BUILD_DATE, MINIMUM_GO)
}
// 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(mode, importPath, srcPath string) {
// Ignore trailing slashes.
ImportPath = strings.TrimRight(importPath, "/")
SourcePath = srcPath
RunMode = mode
if runtime.GOOS == "windows" {
gocolorize.SetPlain(true)
}
// 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 = path.Clean(SourcePath)
revelSourcePath = SourcePath
packaged = true
}
RevelPath = filepath.Join(revelSourcePath, filepath.FromSlash(REVEL_IMPORT_PATH))
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{
path.Join(RevelPath, "conf"),
path.Join(BasePath, "conf"),
},
ConfPaths...)
TemplatePaths = []string{
ViewsPath,
path.Join(RevelPath, "templates"),
}
// Load app.conf
var err error
Config, err = config.LoadContext("app.conf", ConfPaths)
if err != nil || Config == nil {
log.Fatalln("Failed to load app.conf:", err)
}
// Ensure that the selected runmode appears in app.conf.
// If empty string is passed as the mode, treat it as "DEFAULT"
if mode == "" {
mode = config.DEFAULT_SECTION
}
if !Config.HasSection(mode) {
log.Fatalln("app.conf: No mode found:", mode)
}
Config.SetSection(mode)
// 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 == "" {
log.Fatalln("No http.sslcert provided.")
}
if HttpSslKey == "" {
log.Fatalln("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", !DevMode)
TemplateDelims = Config.StringDefault("template.delimiters", "")
if secretStr := Config.StringDefault("app.secret", ""); secretStr != "" {
secretKey = []byte(secretStr)
}
// Configure logging
if !Config.BoolDefault("log.colorize", true) {
gocolorize.SetPlain(true)
}
TRACE = getLogger("trace")
INFO = getLogger("info")
WARN = getLogger("warn")
ERROR = getLogger("error")
// Revel request access logger, not exposed from package.
// However output settings can be controlled from app.conf
requestLog = getLogger("request")
loadModules()
Initialized = true
INFO.Printf("Initialized Revel v%s (%s) for %s", Version, BuildDate, MinimumGoVersion)
}
// InitDefaults initializes Mars based on runtime-loading of config files.
//
// Params:
// mode - the run mode, which determines which app.conf settings are used.
// basePath - the path to the configuration, messages, and view directories
func InitDefaults(mode, basePath string) {
RunMode = mode
if runtime.GOOS == "windows" {
gocolorize.SetPlain(true)
}
BasePath = filepath.FromSlash(basePath)
var cfgPath string
if filepath.IsAbs(ConfigFile) {
cfgPath = ConfigFile
} else {
cfgPath = filepath.Join(BasePath, ConfigFile)
}
if _, err := os.Stat(cfgPath); !os.IsNotExist(err) {
var err error
Config, err = LoadConfig(cfgPath)
if err != nil || Config == nil {
log.Fatalln("Failed to load app.conf:", err)
}
}
MimeConfig, _ = LoadConfig(path.Join(BasePath, MimeTypesFile))
// Ensure that the selected runmode appears in app.conf.
// If empty string is passed as the mode, treat it as "DEFAULT"
if mode == "" {
mode = config.DEFAULT_SECTION
}
if Config.HasSection(mode) {
Config.SetSection(mode)
}
// Configure properties from app.conf
DevMode = Config.BoolDefault("mode.dev", DevMode)
HttpPort = Config.IntDefault("http.port", HttpPort)
HttpAddr = Config.StringDefault("http.addr", HttpAddr)
HttpSsl = Config.BoolDefault("http.ssl", HttpSsl)
HttpSslCert = Config.StringDefault("http.sslcert", HttpSslCert)
HttpSslKey = Config.StringDefault("http.sslkey", HttpSslKey)
if HttpSsl {
if HttpSslCert == "" {
log.Fatalln("No http.sslcert provided.")
}
if HttpSslKey == "" {
log.Fatalln("No http.sslkey provided.")
}
}
AppName = Config.StringDefault("app.name", AppName)
AppRoot = Config.StringDefault("app.root", AppRoot)
CookiePrefix = Config.StringDefault("cookie.prefix", CookiePrefix)
CookieDomain = Config.StringDefault("cookie.domain", CookieDomain)
CookieHttpOnly = Config.BoolDefault("cookie.httponly", CookieHttpOnly)
CookieSecure = Config.BoolDefault("cookie.secure", CookieSecure)
if s := Config.StringDefault("app.secret", ""); s != "" {
SetAppSecret(s)
}
// Configure logging
if !Config.BoolDefault("log.colorize", true) {
gocolorize.SetPlain(true)
}
TRACE = getLogger("trace", TRACE)
INFO = getLogger("info", INFO)
WARN = getLogger("warn", WARN)
ERROR = getLogger("error", ERROR)
// The "watch" config variable can turn on and off all watching.
// (As a convenient way to control it all together.)
if Config.BoolDefault("watch", true) {
MainWatcher = NewWatcher()
Filters = append([]Filter{WatchFilter}, Filters...)
}
if MainTemplateLoader == nil {
SetupViews()
}
if MainRouter == nil {
SetupRouter()
}
INFO.Printf("Initialized Mars v%s (%s) for %s", VERSION, BUILD_DATE, MINIMUM_GO)
runStartupHooks()
}
func initialize(mode, revelSourcePath, basePath string) {
RevelPath = path.Join(revelSourcePath, filepath.FromSlash(REVEL_IMPORT_PATH))
BasePath = basePath
AppPath = path.Join(BasePath, "app")
ViewsPath = path.Join(AppPath, "views")
CodePaths = []string{AppPath}
ConfPaths = []string{
path.Join(BasePath, "conf"),
path.Join(RevelPath, "conf"),
}
TemplatePaths = []string{
ViewsPath,
path.Join(RevelPath, "templates"),
}
// Load app.conf
var err error
Config, err = LoadConfig("app.conf")
if err != nil || Config == nil {
log.Fatalln("Failed to load app.conf:", err)
}
// Ensure that the selected runmode appears in app.conf.
// If empty string is passed as the mode, treat it as "DEFAULT"
if mode == "" {
mode = config.DEFAULT_SECTION
}
if !Config.HasSection(mode) {
log.Fatalln("app.conf: No mode found:", mode)
}
Config.SetSection(mode)
// 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 == "" {
log.Fatalln("No http.sslcert provided.")
}
if HttpSslKey == "" {
log.Fatalln("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", "")
CookieHttpOnly = Config.BoolDefault("cookie.httponly", false)
CookieSecure = Config.BoolDefault("cookie.secure", false)
TemplateDelims = Config.StringDefault("template.delimiters", "")
if secretStr := Config.StringDefault("app.secret", ""); secretStr != "" {
secretKey = []byte(secretStr)
}
// Configure logging
if !Config.BoolDefault("log.colorize", true) {
gocolorize.SetPlain(true)
}
TRACE = getLogger("trace")
INFO = getLogger("info")
WARN = getLogger("warn")
ERROR = getLogger("error")
loadModules(revelSourcePath)
Initialized = true
INFO.Printf("Initialized Revel v%s (%s) for %s", VERSION, BUILD_DATE, MINIMUM_GO)
}