// Main is not redundant with main(), because it provides an entry point
// for testing with arbitrary command line arguments.
func Main(args []string) int {
defer func() {
if r := recover(); r != nil {
buf := make([]byte, 4096)
buf = buf[:runtime.Stack(buf, false)]
logger.Criticalf("Unhandled panic: \n%v\n%s", r, buf)
os.Exit(exit_panic)
}
}()
var code int = 1
ctx, err := cmd.DefaultContext()
if err != nil {
fmt.Fprintf(os.Stderr, "error: %v\n", err)
os.Exit(exit_err)
}
commandName := filepath.Base(args[0])
if commandName == names.Jujud {
code, err = jujuDMain(args, ctx)
} else if commandName == names.Jujuc {
fmt.Fprint(os.Stderr, jujudDoc)
code = exit_err
err = fmt.Errorf("jujuc should not be called directly")
} else if commandName == names.JujuRun {
code = cmd.Main(&RunCommand{}, ctx, args[1:])
} else if commandName == names.JujuDumpLogs {
code = cmd.Main(dumplogs.NewCommand(), ctx, args[1:])
} else {
code, err = jujuCMain(commandName, ctx, args)
}
if err != nil {
fmt.Fprintf(os.Stderr, "error: %v\n", err)
}
return code
}
func (s *dumpLogsCommandSuite) TestRun(c *gc.C) {
// Create a controller machine and an agent for it.
m, password := s.Factory.MakeMachineReturningPassword(c, &factory.MachineParams{
Jobs: []state.MachineJob{state.JobManageModel},
Nonce: agent.BootstrapNonce,
})
err := m.SetMongoPassword(password)
c.Assert(err, jc.ErrorIsNil)
s.PrimeStateAgent(c, m.Tag(), password)
// Create multiple environments and add some logs for each.
st1 := s.Factory.MakeModel(c, nil)
defer st1.Close()
st2 := s.Factory.MakeModel(c, nil)
defer st2.Close()
states := []*state.State{s.State, st1, st2}
t := time.Date(2015, 11, 4, 3, 2, 1, 0, time.UTC)
for _, st := range states {
w := state.NewDbLogger(st, names.NewMachineTag("42"))
defer w.Close()
for i := 0; i < 3; i++ {
err := w.Log(t, "module", "location", loggo.INFO, fmt.Sprintf("%d", i))
c.Assert(err, jc.ErrorIsNil)
}
}
// Run the juju-dumplogs command
command := dumplogs.NewCommand()
context, err := testing.RunCommand(c, command, "--data-dir", s.DataDir())
c.Assert(err, jc.ErrorIsNil)
// Check the log file for each environment
expectedLog := "machine-42: 2015-11-04 03:02:01 INFO module %d"
for _, st := range states {
logName := context.AbsPath(fmt.Sprintf("%s.log", st.ModelUUID()))
logFile, err := os.Open(logName)
c.Assert(err, jc.ErrorIsNil)
scanner := bufio.NewScanner(logFile)
for i := 0; scanner.Scan(); i++ {
c.Assert(scanner.Text(), gc.Equals, fmt.Sprintf(expectedLog, i))
}
c.Assert(scanner.Err(), jc.ErrorIsNil)
}
}
// Main is not redundant with main(), because it provides an entry point
// for testing with arbitrary command line arguments.
func Main(args []string) int {
defer func() {
if r := recover(); r != nil {
buf := make([]byte, 4096)
buf = buf[:runtime.Stack(buf, false)]
logger.Criticalf("Unhandled panic: \n%v\n%s", r, buf)
os.Exit(exit_panic)
}
}()
ctx, err := cmd.DefaultContext()
if err != nil {
fmt.Fprintf(os.Stderr, "error: %v\n", err)
os.Exit(exit_err)
}
code := 1
commandName := filepath.Base(args[0])
switch commandName {
case names.Jujud:
// start pprof server and defer cleanup
stop := pprof.Start()
defer stop()
code, err = jujuDMain(args, ctx)
case names.Jujuc:
fmt.Fprint(os.Stderr, jujudDoc)
code = exit_err
err = fmt.Errorf("jujuc should not be called directly")
case names.JujuRun:
code = cmd.Main(&RunCommand{}, ctx, args[1:])
case names.JujuDumpLogs:
code = cmd.Main(dumplogs.NewCommand(), ctx, args[1:])
default:
code, err = jujuCMain(commandName, ctx, args)
}
if err != nil {
fmt.Fprintf(os.Stderr, "error: %v\n", err)
}
return code
}