func (s *syslogSuite) TestConfigChange(c *gc.C) {
// Create a machine and an agent for it.
m, password := s.Factory.MakeMachineReturningPassword(c, &factory.MachineParams{
Nonce: agent.BootstrapNonce,
Jobs: []state.MachineJob{state.JobManageModel},
})
s.PrimeAgent(c, m.Tag(), password)
agentConf := agentcmd.NewAgentConf(s.DataDir())
agentConf.ReadConfig(m.Tag().String())
machineAgentFactory := agentcmd.MachineAgentFactoryFn(agentConf, s.logsCh, c.MkDir())
a := machineAgentFactory(m.Id())
// Ensure there's no logs to begin with.
// Start the agent.
go func() { c.Check(a.Run(nil), jc.ErrorIsNil) }()
defer a.Stop()
done := make(chan struct{})
received := make(chan rfc5424test.Message)
addr := s.createSyslogServer(c, received, done)
err := s.State.UpdateModelConfig(map[string]interface{}{
"logforward-enabled": true,
"syslog-host": addr,
"syslog-ca-cert": coretesting.CACert,
"syslog-client-cert": coretesting.ServerCert,
"syslog-client-key": coretesting.ServerKey,
}, nil, nil)
c.Assert(err, jc.ErrorIsNil)
s.assertLogRecordForwarded(c, received)
}
// Main registers subcommands for the jujud executable, and hands over control
// to the cmd package.
func jujuDMain(args []string, ctx *cmd.Context) (code int, err error) {
// Assuming an average of 200 bytes per log message, use up to
// 200MB for the log buffer.
logCh, err := logsender.InstallBufferedLogWriter(1048576)
if err != nil {
return 1, errors.Trace(err)
}
jujud := jujucmd.NewSuperCommand(cmd.SuperCommandParams{
Name: "jujud",
Doc: jujudDoc,
})
jujud.Log.Factory = &writerFactory{}
jujud.Register(NewBootstrapCommand())
// TODO(katco-): AgentConf type is doing too much. The
// MachineAgent type has called out the separate concerns; the
// AgentConf should be split up to follow suit.
agentConf := agentcmd.NewAgentConf("")
machineAgentFactory := agentcmd.MachineAgentFactoryFn(
agentConf, logCh, looputil.NewLoopDeviceManager(),
)
jujud.Register(agentcmd.NewMachineAgentCmd(ctx, machineAgentFactory, agentConf, agentConf))
jujud.Register(agentcmd.NewUnitAgent(ctx, logCh))
code = cmd.Main(jujud, ctx, args[1:])
return code, nil
}
// Main registers subcommands for the jujud executable, and hands over control
// to the cmd package.
func jujuDMain(args []string, ctx *cmd.Context) (code int, err error) {
// Assuming an average of 200 bytes per log message, use up to
// 200MB for the log buffer.
defer logger.Debugf("jujud complete, code %d, err %v", code, err)
logCh, err := logsender.InstallBufferedLogWriter(1048576)
if err != nil {
return 1, errors.Trace(err)
}
jujud := jujucmd.NewSuperCommand(cmd.SuperCommandParams{
Name: "jujud",
Doc: jujudDoc,
})
jujud.Log.NewWriter = func(target io.Writer) loggo.Writer {
return &jujudWriter{target: target}
}
jujud.Register(NewBootstrapCommand())
// TODO(katco-): AgentConf type is doing too much. The
// MachineAgent type has called out the separate concerns; the
// AgentConf should be split up to follow suit.
agentConf := agentcmd.NewAgentConf("")
machineAgentFactory := agentcmd.MachineAgentFactoryFn(agentConf, logCh, "")
jujud.Register(agentcmd.NewMachineAgentCmd(ctx, machineAgentFactory, agentConf, agentConf))
jujud.Register(agentcmd.NewUnitAgent(ctx, logCh))
jujud.Register(NewUpgradeMongoCommand())
code = cmd.Main(jujud, ctx, args[1:])
return code, nil
}
func (s *syslogSuite) TestLogRecordForwarded(c *gc.C) {
// Create a machine and an agent for it.
m, password := s.Factory.MakeMachineReturningPassword(c, &factory.MachineParams{
Nonce: agent.BootstrapNonce,
Jobs: []state.MachineJob{state.JobManageModel},
})
s.PrimeAgent(c, m.Tag(), password)
agentConf := agentcmd.NewAgentConf(s.DataDir())
agentConf.ReadConfig(m.Tag().String())
machineAgentFactory := agentcmd.MachineAgentFactoryFn(agentConf, s.logsCh, c.MkDir())
a := machineAgentFactory(m.Id())
// Ensure there's no logs to begin with.
// Start the agent.
go func() { c.Check(a.Run(nil), jc.ErrorIsNil) }()
defer a.Stop()
err := s.State.UpdateModelConfig(map[string]interface{}{
"logforward-enabled": true,
}, nil, nil)
c.Assert(err, jc.ErrorIsNil)
s.assertLogRecordForwarded(c, s.received)
}
// Main registers subcommands for the jujud executable, and hands over control
// to the cmd package.
func jujuDMain(args []string, ctx *cmd.Context) (code int, err error) {
jujud := jujucmd.NewSuperCommand(cmd.SuperCommandParams{
Name: "jujud",
Doc: jujudDoc,
})
jujud.Log.Factory = &writerFactory{}
jujud.Register(NewBootstrapCommand())
// TODO(katco-): AgentConf type is doing too much. The
// MachineAgent type has called out the seperate concerns; the
// AgentConf should be split up to follow suite.
agentConf := agentcmd.NewAgentConf("")
machineAgentFactory := agentcmd.MachineAgentFactoryFn(agentConf, agentConf)
jujud.Register(agentcmd.NewMachineAgentCmd(ctx, machineAgentFactory, agentConf, agentConf))
jujud.Register(agentcmd.NewUnitAgent(ctx))
code = cmd.Main(jujud, ctx, args[1:])
return code, nil
}
func (s *dblogSuite) runMachineAgentTest(c *gc.C) bool {
// Create a machine and an agent for it.
m, password := s.Factory.MakeMachineReturningPassword(c, &factory.MachineParams{
Nonce: agent.BootstrapNonce,
})
s.PrimeAgent(c, m.Tag(), password, version.Current)
agentConf := agentcmd.NewAgentConf(s.DataDir())
agentConf.ReadConfig(m.Tag().String())
logsCh, err := logsender.InstallBufferedLogWriter(1000)
c.Assert(err, jc.ErrorIsNil)
machineAgentFactory := agentcmd.MachineAgentFactoryFn(agentConf, agentConf, logsCh, nil)
a := machineAgentFactory(m.Id())
// Ensure there's no logs to begin with.
c.Assert(s.getLogCount(c, m.Tag()), gc.Equals, 0)
// Start the agent.
go func() { c.Check(a.Run(nil), jc.ErrorIsNil) }()
defer a.Stop()
return s.waitForLogs(c, m.Tag())
}
// NewBootstrapCommand returns a new BootstrapCommand that has been initialized.
func NewBootstrapCommand() *BootstrapCommand {
return &BootstrapCommand{
AgentConf: agentcmd.NewAgentConf(""),
}
}
// NewCommand returns a new Command instance which implements the
// "juju-dumplogs" command.
func NewCommand() cmd.Command {
return &dumpLogsCommand{
agentConfig: jujudagent.NewAgentConf(""),
}
}
// TODO(mjs) - the following should maybe be part of AgentSuite
func (s *upgradeSuite) newAgent(c *gc.C, m *state.Machine) *agentcmd.MachineAgent {
agentConf := agentcmd.NewAgentConf(s.DataDir())
agentConf.ReadConfig(m.Tag().String())
machineAgentFactory := agentcmd.MachineAgentFactoryFn(agentConf, nil, c.MkDir())
return machineAgentFactory(m.Id())
}
func (s *leadershipSuite) SetUpTest(c *gc.C) {
s.AgentSuite.SetUpTest(c)
leaseManager, err := lease.NewLeaseManager(s.State)
c.Assert(err, jc.ErrorIsNil)
s.AddCleanup(func(c *gc.C) {
leaseManager.Kill()
c.Assert(leaseManager.Wait(), jc.ErrorIsNil)
})
file, _ := ioutil.TempFile("", "juju-run")
defer file.Close()
s.AgentSuite.PatchValue(&agentcmd.JujuRun, file.Name())
agenttesting.InstallFakeEnsureMongo(s)
s.PatchValue(&agentcmd.ProductionMongoWriteConcern, false)
// Create a machine to manage the environment.
stateServer, password := s.Factory.MakeMachineReturningPassword(c, &factory.MachineParams{
InstanceId: "id-1",
Nonce: agent.BootstrapNonce,
Jobs: []state.MachineJob{state.JobManageEnviron},
})
c.Assert(stateServer.PasswordValid(password), gc.Equals, true)
c.Assert(stateServer.SetMongoPassword(password), jc.ErrorIsNil)
// Create a machine to host some units.
unitHostMachine := s.Factory.MakeMachine(c, &factory.MachineParams{
Nonce: agent.BootstrapNonce,
Password: password,
})
// Create a service and an instance of that service so that we can
// create a client.
service := s.Factory.MakeService(c, &factory.ServiceParams{})
s.serviceId = service.Tag().Id()
unit := s.Factory.MakeUnit(c, &factory.UnitParams{Machine: unitHostMachine, Service: service})
s.unitId = unit.UnitTag().Id()
c.Assert(unit.SetPassword(password), jc.ErrorIsNil)
s.apiState = s.OpenAPIAs(c, unit.Tag(), password)
// Tweak and write out the config file for the state server.
writeStateAgentConfig(
c,
s.MongoInfo(c),
s.DataDir(),
stateServer.Tag(),
s.State.EnvironTag(),
password,
version.Current,
)
// Create & start a machine agent so the tests have something to call into.
agentConf := agentcmd.NewAgentConf(s.DataDir())
machineAgentFactory := agentcmd.MachineAgentFactoryFn(agentConf, agentConf, nil, nil)
s.machineAgent = machineAgentFactory(stateServer.Id())
// See comment in createMockJujudExecutable
if runtime.GOOS == "windows" {
dirToRemove := createMockJujudExecutable(c, s.DataDir(), s.machineAgent.Tag().String())
s.AddCleanup(func(*gc.C) { os.RemoveAll(dirToRemove) })
}
c.Log("Starting machine agent...")
go func() {
err := s.machineAgent.Run(coretesting.Context(c))
c.Assert(err, jc.ErrorIsNil)
}()
}
