// Start starts logging using the given Context.
func (l *Log) Start(ctx *Context) (err error) {
var target io.Writer
if l.Path != "" {
path := ctx.AbsPath(l.Path)
target, err = os.OpenFile(path, os.O_WRONLY|os.O_APPEND|os.O_CREATE, 0644)
if err != nil {
return err
}
} else if l.Verbose || l.Debug {
target = ctx.Stderr
}
if target != nil {
writer := loggo.NewSimpleWriter(target, &loggo.DefaultFormatter{})
_, err = loggo.ReplaceDefaultWriter(writer)
if err != nil {
return err
}
} else {
loggo.RemoveWriter("default")
}
if l.Verbose || l.Debug {
level := loggo.INFO
if l.Debug {
level = loggo.DEBUG
}
// Set the level on the root logger.
loggo.GetLogger("").SetLogLevel(level)
}
loggo.ConfigureLoggers(l.Config)
return nil
}
func (s *ConfigDeprecationSuite) setupLogger(c *gc.C) {
var err error
s.writer = &testWriter{}
s.oldWriter, s.oldLevel, err = loggo.RemoveWriter("default")
c.Assert(err, gc.IsNil)
err = loggo.RegisterWriter("test", s.writer, loggo.TRACE)
c.Assert(err, gc.IsNil)
}
func (s *suite) SetUpTest(c *C) {
var err error
s.writer = &testWriter{}
s.oldWriter, s.oldLevel, err = loggo.RemoveWriter("default")
c.Assert(err, IsNil)
err = loggo.RegisterWriter("test", s.writer, loggo.TRACE)
c.Assert(err, IsNil)
logger := loggo.GetLogger("juju")
logger.SetLogLevel(loggo.TRACE)
}
func (t *testSuite) TestLogger() {
//NOTE Logfile is not implemented yet
filename := ""
verbose := true
notVerbose := false
err := SetupLog("test", verbose, filename)
t.Nil(err)
err = SetupLog("test", notVerbose, filename)
t.Nil(err)
loggo.RemoveWriter("hivy.main")
}
func main() {
// Command line flags configuration
app := cli.NewApp()
app.Name = "hivy"
app.Usage = "Hive router system"
version := beacon.StableVersion()
app.Version = version.String()
// The 2 firsts are hivy's, the lasts are etcd's
app.Flags = []cli.Flag{
cli.BoolFlag{Name: "verbose", Usage: "verbose mode"},
cli.StringFlag{Name: "logfile", Value: "", Usage: "If specified, will write log there"},
cli.StringFlag{Name: "listen", Value: "127.0.0.1:8080", Usage: "url to listen to"},
cli.StringFlag{Name: "n", Value: "", Usage: "the node name (required)"},
cli.StringFlag{Name: "C", Value: "", Usage: "Node to join"},
cli.StringFlag{Name: "c", Value: "127.0.0.1:4001", Usage: "Etcd client ip to listen on"},
cli.StringFlag{Name: "s", Value: "127.0.0.1:7001", Usage: "Raft server ip to listen on"},
cli.StringFlag{Name: "d", Value: "default-node", Usage: "the directory to store etcd log and snapshot"},
cli.BoolFlag{Name: "f", Usage: "force new etcd node configuration if existing is found (WARNING: data loss!)"},
cli.BoolFlag{Name: "profile", Usage: "Profile requests and etcd perfs"},
}
// Main function as defined by the cli package
app.Action = func(c *cli.Context) {
// Current logger configuration
modules := []string{"hivy.app", "hivy.worker"}
beacon.SetupLog(modules, c.Bool("verbose"), c.String("logfile"))
defer loggo.RemoveWriter("hivy.main")
// Setup centralized configuration
// Need to be a new node in the cluster to be ran
stop := make(chan bool)
if c.String("n") != "" {
go beacon.RunEtcd(stop, c.String("n"), c.String("d"), c.String("c"), c.String("s"),
c.String("C"), c.Bool("f"), c.Bool("verbose"), c.Bool("profile"))
defer func() {
stop <- true
}()
} else {
stop = nil
}
// Properly shutdown the server when CTRL-C is received
// Send true on its given channel
beacon.CatchInterruption(stop)
// Map routes and start up Hivy server
serveApp(c.String("listen"), c.Bool("profile"))
}
app.Run(os.Args)
}
func (c *SyncToolsCommand) Run(ctx *cmd.Context) error {
// Register writer for output on screen.
loggo.RegisterWriter("synctools", sync.NewSyncLogWriter(ctx.Stdout, ctx.Stderr), loggo.INFO)
defer loggo.RemoveWriter("synctools")
// Prepare syncing.
sctx := &sync.SyncContext{
EnvName: c.EnvName,
AllVersions: c.allVersions,
DryRun: c.dryRun,
PublicBucket: c.publicBucket,
Dev: c.dev,
Source: c.source,
}
return syncTools(sctx)
}
// ensureToolsAvailability verifies the tools are available. If no tools are
// found, it will automatically synchronize them.
func (c *BootstrapCommand) ensureToolsAvailability(env environs.Environ, ctx *cmd.Context) error {
// Capture possible logging while syncing and write it on the screen.
loggo.RegisterWriter("bootstrap", sync.NewSyncLogWriter(ctx.Stdout, ctx.Stderr), loggo.INFO)
defer loggo.RemoveWriter("bootstrap")
// Try to find bootstrap tools.
_, err := environs.FindBootstrapTools(env, c.Constraints)
if errors.IsNotFoundError(err) {
// Not tools available, so synchronize.
sctx := &sync.SyncContext{
EnvName: c.EnvName,
Source: c.Source,
}
if err = syncTools(sctx); err != nil {
return err
}
// Synchronization done, try again.
_, err = environs.FindBootstrapTools(env, c.Constraints)
} else if err != nil {
return err
}
return err
}
func (s *ConfigDeprecationSuite) resetLogger(c *gc.C) {
_, _, err := loggo.RemoveWriter("test")
c.Assert(err, gc.IsNil)
err = loggo.RegisterWriter("default", s.oldWriter, s.oldLevel)
c.Assert(err, gc.IsNil)
}
func (s *suite) TearDownTest(c *C) {
_, _, err := loggo.RemoveWriter("test")
c.Assert(err, IsNil)
err = loggo.RegisterWriter("default", s.oldWriter, s.oldLevel)
c.Assert(err, IsNil)
}
