func init() {
Log = log.New()
var handler log.Handler
env := config.Viper.GetString("env")
lvl, err := log.LvlFromString(config.Viper.GetString("LogLevel"))
if err != nil {
panic("Could not read configuration for LogLevel, check the 'config-" + env +
".json' file: " + err.Error())
}
if env == "dev" || env == "qa" {
handler = logext.FatalHandler(log.LvlFilterHandler(lvl, log.CallerFileHandler(log.StdoutHandler)))
} else {
handler = logext.FatalHandler(log.LvlFilterHandler(lvl, log.CallerFileHandler(log.StreamHandler(os.Stdout, log.JsonFormat()))))
}
Log.SetHandler(handler)
}
func newLogger(c *Context) (log15.Logger, error) {
lvl := c.String(FlagLogLevel)
l := log15.New()
log.Println(fmt.Sprintf("Using log level %s", lvl))
v, err := log15.LvlFromString(lvl)
if err != nil {
return l, err
}
h := log15.LvlFilterHandler(v, log15.StreamHandler(os.Stdout, log15.LogfmtFormat()))
if lvl == "debug" {
h = log15.CallerFileHandler(h)
}
l.SetHandler(log15.LazyHandler(h))
return l, err
}
func TestErrorHandler(t *testing.T) {
t.Parallel()
h, r := testHandler()
lg := log.New()
lg.SetHandler(EscalateErrHandler(
log.LvlFilterHandler(log.LvlError, h)))
lg.Debug("some function result", "err", nil)
if r.Msg != "" {
t.Fatalf("Expected debug level message to be filtered")
}
lg.Debug("some function result", "err", errors.New("failed operation"))
if r.Msg != "some function result" {
t.Fatalf("Expected debug level message to be escalated and pass lvlfilter")
}
if r.Lvl != log.LvlError {
t.Fatalf("Expected debug level message to be escalated to LvlError")
}
}
// NewContext creates a new Context from the specified Config. This also
// creates a Logger.
func NewContext(config *Config) (*Context, error) {
var context = Context{
Config: *config,
}
// Logging
context.Log = log15.New()
if context.Config.Logging.File == "/dev/null" {
context.handler = log15.DiscardHandler()
} else if context.Config.Logging.File == "stderr" {
context.handler = log15.StderrHandler
} else {
handler, err := log15.FileHandler(
context.Config.Logging.File,
log15.LogfmtFormat(),
)
if err != nil {
return nil, err
}
context.handler = handler
}
level, err := log15.LvlFromString(context.Config.Logging.Level)
if err != nil {
return nil, err
}
context.handler = log15.LvlFilterHandler(level, context.handler)
context.Log.SetHandler(context.handler)
// Tracing
if context.Config.Tracing.Enabled {
s, err := os.Stat(context.Config.Tracing.File)
if os.IsNotExist(err) || s.Size() == 0 {
context.tracingFd, err = os.Create(context.Config.Tracing.File)
if err != nil {
return nil, err
}
context.EventCollector, err = NewWriterEventCollector(
context.tracingFd,
false,
)
if err != nil {
return nil, err
}
} else {
context.tracingFd, err = os.OpenFile(
context.Config.Tracing.File,
os.O_WRONLY|os.O_APPEND,
0664,
)
if err != nil {
return nil, err
}
context.EventCollector, err = NewWriterEventCollector(
context.tracingFd,
true,
)
if err != nil {
return nil, err
}
}
} else {
context.EventCollector = &NullEventCollector{}
}
hostname, err := os.Hostname()
if err != nil {
hostname = "main"
}
context.EventFactory = NewEventFactory(hostname, "main")
context.EventFactory.Register(context.EventCollector)
return &context, nil
}
func main() {
app.Writer(os.Stdout)
app.Version(VV)
app.HelpFlag.Short('h')
app.VersionFlag.Short('v')
command := kingpin.MustParse(app.Parse(os.Args[1:]))
err := ReadConfig(*configFile, *account)
if !strings.HasPrefix(command, "config") && !strings.HasPrefix(command, "update") {
// Makes sure the config file structure is valid
if err != nil {
fatalError("%s: Error reading config file: %s\n", filepath.Base(os.Args[0]), err.Error())
}
// Make sure the config file auth token is valid. Check now so we don't have to
// keep rechecking in code.
_, err := Config.Account.Client15()
if err != nil {
fatalError("Authentication error: %s", err.Error())
}
}
// Handle logging
logLevel := log15.LvlInfo
if *debug {
log.Logger.SetHandler(
log15.LvlFilterHandler(
log15.LvlDebug,
log15.StderrHandler))
httpclient.DumpFormat = httpclient.Debug
logLevel = log15.LvlDebug
}
handler := log15.LvlFilterHandler(logLevel, log15.StreamHandler(colorable.NewColorableStdout(), log15.TerminalFormat()))
log15.Root().SetHandler(handler)
if Config.GetBool("update.check") && !strings.HasPrefix(command, "update") {
defer UpdateCheck(VV, os.Stderr)
}
switch command {
case stShowCmd.FullCommand():
href, err := paramToHref("server_templates", *stShowNameOrHref, 0)
if err != nil {
fatalError("%s", err.Error())
}
stShow(href)
case stUploadCmd.FullCommand():
files, err := walkPaths(*stUploadPaths)
if err != nil {
fatalError("%s\n", err.Error())
}
stUpload(files, *stUploadPrefix)
case stDeleteCmd.FullCommand():
files, err := walkPaths(*stDeletePaths)
if err != nil {
fatalError("%s\n", err.Error())
}
stDelete(files, *stDeletePrefix)
case stDownloadCmd.FullCommand():
href, err := paramToHref("server_templates", *stDownloadNameOrHref, 0)
if err != nil {
fatalError("%s", err.Error())
}
stDownload(href, *stDownloadTo, *stDownloadPublished, *stDownloadMciSettings, *stDownloadScriptPath)
case stValidateCmd.FullCommand():
files, err := walkPaths(*stValidatePaths)
if err != nil {
fatalError("%s\n", err.Error())
}
stValidate(files)
case rightScriptShowCmd.FullCommand():
href, err := paramToHref("right_scripts", *rightScriptShowNameOrHref, 0)
if err != nil {
fatalError("%s", err.Error())
}
rightScriptShow(href)
case rightScriptUploadCmd.FullCommand():
files, err := walkPaths(*rightScriptUploadPaths)
if err != nil {
fatalError("%s\n", err.Error())
}
rightScriptUpload(files, *rightScriptUploadForce, *rightScriptUploadPrefix)
case rightScriptDeleteCmd.FullCommand():
files, err := walkPaths(*rightScriptDeletePaths)
if err != nil {
fatalError("%s\n", err.Error())
}
rightScriptDelete(files, *rightScriptDeletePrefix)
case rightScriptDownloadCmd.FullCommand():
href, err := paramToHref("right_scripts", *rightScriptDownloadNameOrHref, 0)
if err != nil {
fatalError("%s", err.Error())
}
rightScriptDownload(href, *rightScriptDownloadTo)
case rightScriptScaffoldCmd.FullCommand():
files, err := walkPaths(*rightScriptScaffoldPaths)
if err != nil {
fatalError("%s\n", err.Error())
}
rightScriptScaffold(files, !*rightScriptScaffoldNoBackup, *rightScriptScaffoldForce)
case rightScriptValidateCmd.FullCommand():
files, err := walkPaths(*rightScriptValidatePaths)
if err != nil {
fatalError("%s\n", err.Error())
}
rightScriptValidate(files)
case configAccountCmd.FullCommand():
err := Config.SetAccount(*configAccountName, *configAccountDefault, os.Stdin, os.Stdout)
if err != nil {
fatalError("%s\n", err.Error())
}
case configShowCmd.FullCommand():
err := Config.ShowConfiguration(os.Stdout)
if err != nil {
fatalError("%s\n", err.Error())
}
case updateListCmd.FullCommand():
err := UpdateList(VV, os.Stdout)
if err != nil {
fatalError("%s\n", err.Error())
}
case updateApplyCmd.FullCommand():
err := UpdateApply(VV, os.Stdout, *updateApplyMajorVersion, "")
if err != nil {
fatalError("%s\n", err.Error())
}
}
}