// NewWorker returns a worker that keeps track of
// the machine's authorised ssh keys and ensures the
// ~/.ssh/authorized_keys file is up to date.
func NewWorker(st *keyupdater.State, agentConfig agent.Config) worker.Worker {
if os.HostOS() == os.Windows {
return worker.NewNoOpWorker()
}
kw := &keyupdaterWorker{st: st, tag: agentConfig.Tag().(names.MachineTag)}
return worker.NewNotifyWorker(kw)
}
// NewWorker returns a worker that keeps track of
// the machine's authorised ssh keys and ensures the
// ~/.ssh/authorized_keys file is up to date.
func NewWorker(st *keyupdater.State, agentConfig agent.Config) worker.Worker {
if version.Current.OS == version.Windows {
return worker.NewNoOpWorker()
}
kw := &keyupdaterWorker{st: st, tag: agentConfig.Tag().(names.MachineTag)}
return worker.NewNotifyWorker(kw)
}
// NewRsyslogConfigWorker returns a worker.Worker that uses
// WatchForRsyslogChanges and updates rsyslog configuration based
// on changes. The worker will remove the configuration file
// on teardown.
func NewRsyslogConfigWorker(st *apirsyslog.State, mode RsyslogMode, tag names.Tag, namespace string, stateServerAddrs []string) (worker.Worker, error) {
if version.Current.OS == version.Windows {
return worker.NewNoOpWorker(), nil
}
handler, err := newRsyslogConfigHandler(st, mode, tag, namespace, stateServerAddrs)
if err != nil {
return nil, err
}
logger.Debugf("starting rsyslog worker mode %v for %q %q", mode, tag, namespace)
return worker.NewNotifyWorker(handler), nil
}
// newRsyslogConfigWorker returns a worker.Worker that uses
// WatchForRsyslogChanges and updates rsyslog configuration based
// on changes. The worker will remove the configuration file
// on teardown.
func newRsyslogConfigWorker(st *apirsyslog.State, mode RsyslogMode, tag names.Tag, namespace string, stateServerAddrs []string, jujuConfigDir string) (worker.Worker, error) {
if jujuos.HostOS() == jujuos.Windows && mode == RsyslogModeAccumulate {
return worker.NewNoOpWorker(), nil
}
handler, err := newRsyslogConfigHandler(st, mode, tag, namespace, stateServerAddrs, jujuConfigDir)
if err != nil {
return nil, err
}
logger.Debugf("starting rsyslog worker mode %v for %q %q", mode, tag, namespace)
return worker.NewNotifyWorker(handler), nil
}
func (s *AgentSuite) SetUpTest(c *gc.C) {
s.JujuConnSuite.SetUpTest(c)
// Set API host ports so FindTools/Tools API calls succeed.
hostPorts := [][]network.HostPort{
network.NewHostPorts(1234, "0.1.2.3"),
}
err := s.State.SetAPIHostPorts(hostPorts)
c.Assert(err, jc.ErrorIsNil)
s.PatchValue(&proxyupdater.New, func(*apienvironment.Facade, bool) worker.Worker {
return newDummyWorker()
})
s.PatchValue(&newMetadataUpdater, func(cl *imagemetadata.Client) worker.Worker {
return worker.NewNoOpWorker()
})
}
func (s *MachineSuite) checkMetadataWorkerNotRun(c *gc.C, job state.MachineJob, suffix string) {
// Patch out the worker func before starting the agent.
started := newSignal()
newWorker := func(cl *imagemetadata.Client) worker.Worker {
started.trigger()
return worker.NewNoOpWorker()
}
s.PatchValue(&newMetadataUpdater, newWorker)
// Start the machine agent.
m, _, _ := s.primeAgent(c, job)
a := s.newAgent(c, m)
go func() { c.Check(a.Run(nil), jc.ErrorIsNil) }()
defer func() { c.Check(a.Stop(), jc.ErrorIsNil) }()
started.assertNotTriggered(c, startWorkerWait, "metadata update worker started")
}
func (s *MachineSuite) TestMachineAgentRunsDiskManagerWorker(c *gc.C) {
// Patch out the worker func before starting the agent.
started := newSignal()
newWorker := func(diskmanager.ListBlockDevicesFunc, diskmanager.BlockDeviceSetter) worker.Worker {
started.trigger()
return worker.NewNoOpWorker()
}
s.PatchValue(&diskmanager.NewWorker, newWorker)
// Start the machine agent.
m, _, _ := s.primeAgent(c, state.JobHostUnits)
a := s.newAgent(c, m)
go func() { c.Check(a.Run(nil), jc.ErrorIsNil) }()
defer func() { c.Check(a.Stop(), jc.ErrorIsNil) }()
started.assertTriggered(c, "diskmanager worker to start")
}
func (s *MachineSuite) TestMachineAgentRunsCertificateUpdateWorkerForController(c *gc.C) {
started := newSignal()
newUpdater := func(certupdater.AddressWatcher, certupdater.StateServingInfoGetter, certupdater.ControllerConfigGetter,
certupdater.APIHostPortsGetter, certupdater.StateServingInfoSetter,
) worker.Worker {
started.trigger()
return worker.NewNoOpWorker()
}
s.PatchValue(&newCertificateUpdater, newUpdater)
// Start the machine agent.
m, _, _ := s.primeAgent(c, state.JobManageModel)
a := s.newAgent(c, m)
go func() { c.Check(a.Run(nil), jc.ErrorIsNil) }()
defer func() { c.Check(a.Stop(), jc.ErrorIsNil) }()
started.assertTriggered(c, "certificate to be updated")
}
func (s *MachineSuite) TestMachineAgentRunsMachineStorageWorker(c *gc.C) {
m, _, _ := s.primeAgent(c, state.JobHostUnits)
started := newSignal()
newWorker := func(config storageprovisioner.Config) (worker.Worker, error) {
c.Check(config.Scope, gc.Equals, m.Tag())
c.Check(config.Validate(), jc.ErrorIsNil)
started.trigger()
return worker.NewNoOpWorker(), nil
}
s.PatchValue(&storageprovisioner.NewStorageProvisioner, newWorker)
// Start the machine agent.
a := s.newAgent(c, m)
go func() { c.Check(a.Run(nil), jc.ErrorIsNil) }()
defer func() { c.Check(a.Stop(), jc.ErrorIsNil) }()
started.assertTriggered(c, "storage worker to start")
}
// NewWorker returns a worker that keeps track of
// the machine's authorised ssh keys and ensures the
// ~/.ssh/authorized_keys file is up to date.
func NewWorker(st *keyupdater.State, agentConfig agent.Config) (worker.Worker, error) {
machineTag, ok := agentConfig.Tag().(names.MachineTag)
if !ok {
return nil, errors.NotValidf("machine tag %v", agentConfig.Tag())
}
if os.HostOS() == os.Windows {
return worker.NewNoOpWorker(), nil
}
w, err := watcher.NewNotifyWorker(watcher.NotifyConfig{
Handler: &keyupdaterWorker{
st: st,
tag: machineTag,
},
})
if err != nil {
return nil, errors.Trace(err)
}
return w, nil
}
func (s *MachineMockProviderSuite) TestMachineAgentRunsMetadataWorker(c *gc.C) {
// Patch out the worker func before starting the agent.
started := make(chan struct{})
newWorker := func(cl *imagemetadata.Client) worker.Worker {
close(started)
return worker.NewNoOpWorker()
}
s.PatchValue(&newMetadataUpdater, newWorker)
s.PatchValue(&newEnvirons, func(config *config.Config) (environs.Environ, error) {
return &dummyEnviron{}, nil
})
// Start the machine agent.
m, _, _ := s.primeAgent(c, state.JobManageModel)
a := s.newAgent(c, m)
go func() { c.Check(a.Run(nil), jc.ErrorIsNil) }()
defer func() { c.Check(a.Stop(), jc.ErrorIsNil) }()
s.assertChannelActive(c, started, "metadata update worker to start")
}
func (s *MachineSuite) TestCertificateDNSUpdated(c *gc.C) {
// Disable the certificate work so it doesn't update the certificate.
newUpdater := func(certupdater.AddressWatcher, certupdater.StateServingInfoGetter, certupdater.ControllerConfigGetter,
certupdater.APIHostPortsGetter, certupdater.StateServingInfoSetter,
) worker.Worker {
return worker.NewNoOpWorker()
}
s.PatchValue(&newCertificateUpdater, newUpdater)
// Set up the machine agent.
m, _, _ := s.primeAgent(c, state.JobManageModel)
a := s.newAgent(c, m)
// Set up check that certificate has been updated when the agent starts.
updated := make(chan struct{})
expectedDnsNames := set.NewStrings("local", "juju-apiserver", "juju-mongodb")
go func() {
for {
stateInfo, _ := a.CurrentConfig().StateServingInfo()
srvCert, err := cert.ParseCert(stateInfo.Cert)
c.Assert(err, jc.ErrorIsNil)
certDnsNames := set.NewStrings(srvCert.DNSNames...)
if !expectedDnsNames.Difference(certDnsNames).IsEmpty() {
continue
}
pemContent, err := ioutil.ReadFile(filepath.Join(s.DataDir(), "server.pem"))
c.Assert(err, jc.ErrorIsNil)
if string(pemContent) == stateInfo.Cert+"\n"+stateInfo.PrivateKey {
close(updated)
break
}
time.Sleep(10 * time.Millisecond)
}
}()
go func() { c.Check(a.Run(nil), jc.ErrorIsNil) }()
defer func() { c.Check(a.Stop(), jc.ErrorIsNil) }()
s.assertChannelActive(c, updated, "certificate to be updated")
}
func (s *MachineSuite) TestMongoUpgradeWorker(c *gc.C) {
// Patch out the worker func before starting the agent.
started := make(chan struct{})
newWorker := func(*state.State, string, mongoupgrader.StopMongo) (worker.Worker, error) {
close(started)
return worker.NewNoOpWorker(), nil
}
s.PatchValue(&newUpgradeMongoWorker, newWorker)
// Start the machine agent.
m, _, _ := s.primeAgent(c, state.JobManageModel)
a := s.newAgent(c, m)
go func() { c.Check(a.Run(nil), jc.ErrorIsNil) }()
defer func() { c.Check(a.Stop(), jc.ErrorIsNil) }()
// Wait for worker to be started.
s.State.StartSync()
select {
case <-started:
case <-time.After(coretesting.LongWait):
c.Fatalf("timeout while waiting for mongo upgrader worker to start")
}
}
func (s *MachineSuite) testCertificateDNSUpdated(c *gc.C, a *MachineAgent) {
// Disable the certificate worker so that the certificate could
// only have been updated during agent startup.
newUpdater := func(certupdater.AddressWatcher, certupdater.StateServingInfoGetter, certupdater.ControllerConfigGetter,
certupdater.APIHostPortsGetter, certupdater.StateServingInfoSetter,
) worker.Worker {
return worker.NewNoOpWorker()
}
s.PatchValue(&newCertificateUpdater, newUpdater)
// Set up a channel which fires when State is opened.
started := make(chan struct{}, 16)
s.PatchValue(&reportOpenedState, func(*state.State) {
started <- struct{}{}
})
// Start the agent.
go func() { c.Check(a.Run(nil), jc.ErrorIsNil) }()
defer func() { c.Check(a.Stop(), jc.ErrorIsNil) }()
// Wait for State to be opened. Once this occurs we know that the
// agent's initial startup has happened.
s.assertChannelActive(c, started, "agent to start up")
// Check that certificate was updated when the agent started.
stateInfo, _ := a.CurrentConfig().StateServingInfo()
srvCert, _, err := cert.ParseCertAndKey(stateInfo.Cert, stateInfo.PrivateKey)
c.Assert(err, jc.ErrorIsNil)
expectedDnsNames := set.NewStrings("local", "juju-apiserver", "juju-mongodb")
certDnsNames := set.NewStrings(srvCert.DNSNames...)
c.Check(expectedDnsNames.Difference(certDnsNames).IsEmpty(), jc.IsTrue)
// Check the mongo certificate file too.
pemContent, err := ioutil.ReadFile(filepath.Join(s.DataDir(), "server.pem"))
c.Assert(err, jc.ErrorIsNil)
c.Check(string(pemContent), gc.Equals, stateInfo.Cert+"\n"+stateInfo.PrivateKey)
}
