← Back to branch summary

~ubuntu-branches/ubuntu/trusty/juju-core/trusty-proposed

« back to all changes in this revision

Viewing changes to src/launchpad.net/juju-core/cmd/jujud/machine.go

  • Committer: Package Import Robot
  • Author(s): James Page
  • Date: 2014-01-29 11:40:20 UTC
  • mfrom: (23.1.1 trusty-proposed)
  • Revision ID: package-import@ubuntu.com-20140129114020-ejieitm8smtt5vln
Tags: 1.17.1-0ubuntu2
d/tests/local-provider: Don't fail tests if ~/.juju is present as its
created by the juju version command. 

Show diffs side-by-side

added added

removed removed

Lines of Context:
src/launchpad.net/juju-core/cmd/jujud/machine.go
30
30
        "launchpad.net/juju-core/worker"
31
31
        "launchpad.net/juju-core/worker/addressupdater"
32
32
        "launchpad.net/juju-core/worker/authenticationworker"
 
33
        "launchpad.net/juju-core/worker/charmrevisionworker"
33
34
        "launchpad.net/juju-core/worker/cleaner"
34
35
        "launchpad.net/juju-core/worker/deployer"
35
36
        "launchpad.net/juju-core/worker/firewaller"
39
40
        "launchpad.net/juju-core/worker/minunitsworker"
40
41
        "launchpad.net/juju-core/worker/provisioner"
41
42
        "launchpad.net/juju-core/worker/resumer"
 
43
        "launchpad.net/juju-core/worker/terminationworker"
42
44
        "launchpad.net/juju-core/worker/upgrader"
43
45
)
44
46
 
52
54
 
53
55
var retryDelay = 3 * time.Second
54
56
 
 
57
var jujuRun = "/usr/local/bin/juju-run"
 
58
 
55
59
// MachineAgent is a cmd.Command responsible for running a machine agent.
56
60
type MachineAgent struct {
57
61
        cmd.CommandBase
110
114
                return err
111
115
        }
112
116
        charm.CacheDir = filepath.Join(a.Conf.dataDir, "charmcache")
 
117
        if err := a.initAgent(); err != nil {
 
118
                return err
 
119
        }
113
120
 
114
121
        // ensureStateWorker ensures that there is a worker that
115
122
        // connects to the state that runs within itself all the workers
136
143
        a.runner.StartWorker("api", func() (worker.Worker, error) {
137
144
                return a.APIWorker(ensureStateWorker)
138
145
        })
 
146
        a.runner.StartWorker("termination", func() (worker.Worker, error) {
 
147
                return terminationworker.NewWorker(), nil
 
148
        })
139
149
        err := a.runner.Wait()
140
150
        if err == worker.ErrTerminateAgent {
141
151
                err = a.uninstallAgent()
172
182
        runner.StartWorker("logger", func() (worker.Worker, error) {
173
183
                return workerlogger.NewLogger(st.Logger(), agentConfig), nil
174
184
        })
175
 
        runner.StartWorker("authenticationworker", func() (worker.Worker, error) {
176
 
                return authenticationworker.NewWorker(st.KeyUpdater(), agentConfig), nil
177
 
        })
 
185
 
 
186
        // If not a local provider bootstrap machine, start the worker to manage SSH keys.
 
187
        providerType := agentConfig.Value(agent.ProviderType)
 
188
        if providerType != provider.Local || a.MachineId != bootstrapMachineId {
 
189
                runner.StartWorker("authenticationworker", func() (worker.Worker, error) {
 
190
                        return authenticationworker.NewWorker(st.KeyUpdater(), agentConfig), nil
 
191
                })
 
192
        }
178
193
 
179
194
        // Perform the operations needed to set up hosting for containers.
180
195
        if err := a.setupContainerSupport(runner, st, entity); err != nil {
192
207
                        runner.StartWorker("environ-provisioner", func() (worker.Worker, error) {
193
208
                                return provisioner.NewEnvironProvisioner(st.Provisioner(), agentConfig), nil
194
209
                        })
195
 
                        // TODO(dimitern): Add firewaller here, when using the API.
 
210
                        // TODO(axw) 2013-09-24 bug #1229506
 
211
                        // Make another job to enable the firewaller. Not all environments
 
212
                        // are capable of managing ports centrally.
 
213
                        runner.StartWorker("firewaller", func() (worker.Worker, error) {
 
214
                                return firewaller.NewFirewaller(st.Firewaller())
 
215
                        })
196
216
                case params.JobManageState:
197
 
                        // Not yet implemented with the API.
 
217
                        runner.StartWorker("charm-revision-updater", func() (worker.Worker, error) {
 
218
                                return charmrevisionworker.NewRevisionUpdateWorker(st.CharmRevisionUpdater()), nil
 
219
                        })
198
220
                default:
199
221
                        // TODO(dimitern): Once all workers moved over to using
200
222
                        // the API, report "unknown job type" here.
253
275
}
254
276
 
255
277
// StateJobs returns a worker running all the workers that require
256
 
// a *state.State cofnnection.
 
278
// a *state.State connection.
257
279
func (a *MachineAgent) StateWorker() (worker.Worker, error) {
258
280
        agentConfig := a.Conf.config
259
281
        st, entity, err := openState(agentConfig, a)
280
302
                case state.JobHostUnits:
281
303
                        // Implemented in APIWorker.
282
304
                case state.JobManageEnviron:
283
 
                        // TODO(axw) 2013-09-24 bug #1229506
284
 
                        // Make another job to enable the firewaller. Not all environments
285
 
                        // are capable of managing ports centrally.
286
 
                        runner.StartWorker("firewaller", func() (worker.Worker, error) {
287
 
                                return firewaller.NewFirewaller(st), nil
288
 
                        })
289
305
                        runner.StartWorker("addressupdater", func() (worker.Worker, error) {
290
306
                                return addressupdater.NewWorker(st), nil
291
307
                        })
301
317
                                if len(cert) == 0 || len(key) == 0 {
302
318
                                        return nil, &fatalError{"configuration does not have state server cert/key"}
303
319
                                }
304
 
                                return apiserver.NewServer(st, fmt.Sprintf(":%d", port), cert, key)
 
320
                                dataDir := a.Conf.config.DataDir()
 
321
                                return apiserver.NewServer(st, fmt.Sprintf(":%d", port), cert, key, dataDir)
305
322
                        })
306
323
                        runner.StartWorker("cleaner", func() (worker.Worker, error) {
307
324
                                return cleaner.NewCleaner(st), nil
341
358
        return names.MachineTag(a.MachineId)
342
359
}
343
360
 
 
361
func (a *MachineAgent) initAgent() error {
 
362
        if err := os.Remove(jujuRun); err != nil && !os.IsNotExist(err) {
 
363
                return err
 
364
        }
 
365
        jujud := filepath.Join(a.Conf.dataDir, "tools", a.Tag(), "jujud")
 
366
        return os.Symlink(jujud, jujuRun)
 
367
}
 
368
 
344
369
func (a *MachineAgent) uninstallAgent() error {
345
370
        var errors []error
346
371
        agentServiceName := a.Conf.config.Value(agent.AgentServiceName)
353
378
                        errors = append(errors, fmt.Errorf("cannot remove service %q: %v", agentServiceName, err))
354
379
                }
355
380
        }
 
381
        // Remove the juju-run symlink.
 
382
        if err := os.Remove(jujuRun); err != nil && !os.IsNotExist(err) {
 
383
                errors = append(errors, err)
 
384
        }
356
385
        // The machine agent may terminate without knowing its jobs,
357
386
        // for example if the machine's entry in state was removed.
358
387
        // Thus, we do not rely on jobs here, and instead just check