~rogpeppe/juju-core/470-1.16-wallyworld-provisioner-safe-mode

« back to all changes in this revision

Viewing changes to worker/provisioner/provisioner.go

  • Committer: Roger Peppe
  • Date: 2013-11-27 18:33:23 UTC
  • Revision ID: roger.peppe@canonical.com-20131127183323-uzhskuad5wi4ux99
worker/provisioner: cherry pick changes from safe-mode changes in trunk

Show diffs side-by-side

added added

removed removed

Lines of Context:
15
15
        "launchpad.net/juju-core/environs/config"
16
16
        "launchpad.net/juju-core/instance"
17
17
        apiprovisioner "launchpad.net/juju-core/state/api/provisioner"
18
 
        apiwatcher "launchpad.net/juju-core/state/api/watcher"
19
18
        "launchpad.net/juju-core/state/watcher"
20
19
        coretools "launchpad.net/juju-core/tools"
21
20
        "launchpad.net/juju-core/worker"
39
38
        machine     *apiprovisioner.Machine
40
39
        environ     environs.Environ
41
40
        agentConfig agent.Config
 
41
        broker      environs.InstanceBroker
42
42
        tomb        tomb.Tomb
43
43
 
44
44
        configObserver
45
45
}
46
46
 
 
47
// configObserver is implemented so that tests can see
 
48
// when the environment configuration changes.
47
49
type configObserver struct {
48
50
        sync.Mutex
49
51
        observer chan<- *config.Config
76
78
}
77
79
 
78
80
func (p *Provisioner) loop() error {
79
 
        // Only wait for the environment if we are an environmental provisioner.
80
81
        var environConfigChanges <-chan struct{}
81
 
        var environWatcher apiwatcher.NotifyWatcher
82
 
        if p.pt == ENVIRON {
83
 
                environWatcher, err := p.st.WatchForEnvironConfigChanges()
84
 
                if err != nil {
85
 
                        return err
86
 
                }
87
 
                environConfigChanges = environWatcher.Changes()
88
 
                defer watcher.Stop(environWatcher, &p.tomb)
89
 
 
90
 
                p.environ, err = worker.WaitForEnviron(environWatcher, p.st, p.tomb.Dying())
91
 
                if err != nil {
92
 
                        return err
93
 
                }
94
 
        }
95
 
 
96
 
        auth, err := NewAPIAuthenticator(p.st)
97
 
        if err != nil {
98
 
                return err
99
 
        }
100
 
 
101
 
        // Start a new worker for the environment or lxc provisioner,
102
 
        // it depends on the provisioner type passed in NewProvisioner.
103
 
 
104
 
        // Start responding to changes in machines, and to any further updates
105
 
        // to the environment config.
106
 
        instanceBroker, err := p.getBroker()
107
 
        if err != nil {
108
 
                return err
109
 
        }
110
 
        machineWatcher, err := p.getWatcher()
111
 
        if err != nil {
112
 
                return err
113
 
        }
114
 
        task := NewProvisionerTask(
115
 
                p.agentConfig.Tag(),
116
 
                p.st,
117
 
                machineWatcher,
118
 
                instanceBroker,
119
 
                auth)
 
82
        environWatcher, err := p.st.WatchForEnvironConfigChanges()
 
83
        if err != nil {
 
84
                return err
 
85
        }
 
86
        environConfigChanges = environWatcher.Changes()
 
87
        defer watcher.Stop(environWatcher, &p.tomb)
 
88
 
 
89
        p.environ, err = worker.WaitForEnviron(environWatcher, p.st, p.tomb.Dying())
 
90
        if err != nil {
 
91
                return err
 
92
        }
 
93
        p.broker = p.environ
 
94
        safeMode := p.environ.Config().ProvisionerSafeMode()
 
95
        task, err := p.getStartTask(safeMode)
 
96
        if err != nil {
 
97
                return err
 
98
        }
120
99
        defer watcher.Stop(task, &p.tomb)
121
100
 
122
101
        for {
131
110
                        if !ok {
132
111
                                return watcher.MustErr(environWatcher)
133
112
                        }
134
 
                        config, err := p.st.EnvironConfig()
 
113
                        environConfig, err := p.st.EnvironConfig()
135
114
                        if err != nil {
136
115
                                logger.Errorf("cannot load environment configuration: %v", err)
137
116
                                return err
138
117
                        }
139
 
                        if err := p.setConfig(config); err != nil {
 
118
                        if err := p.setConfig(environConfig); err != nil {
140
119
                                logger.Errorf("loaded invalid environment configuration: %v", err)
141
120
                        }
 
121
                        task.SetSafeMode(environConfig.ProvisionerSafeMode())
142
122
                }
143
123
        }
144
124
}
157
137
func (p *Provisioner) getWatcher() (Watcher, error) {
158
138
        switch p.pt {
159
139
        case ENVIRON:
 
140
                logger.Infof("getting environ watcher")
160
141
                return p.st.WatchEnvironMachines()
161
142
        case LXC:
 
143
                logger.Infof("getting lxc watcher")
162
144
                machine, err := p.getMachine()
163
145
                if err != nil {
164
146
                        return nil, err
219
201
        p.tomb.Kill(nil)
220
202
        return p.tomb.Wait()
221
203
}
 
204
 
 
205
// getStartTask creates a new worker for the provisioner,
 
206
func (p *Provisioner) getStartTask(safeMode bool) (ProvisionerTask, error) {
 
207
        auth, err := NewAPIAuthenticator(p.st)
 
208
        if err != nil {
 
209
                return nil, err
 
210
        }
 
211
        // Start responding to changes in machines, and to any further updates
 
212
        // to the environment config.
 
213
        machineWatcher, err := p.getWatcher()
 
214
        if err != nil {
 
215
                return nil, err
 
216
        }
 
217
        task := NewProvisionerTask(
 
218
                p.agentConfig.Tag(),
 
219
                safeMode,
 
220
                p.st,
 
221
                machineWatcher,
 
222
                p.broker,
 
223
                auth)
 
224
        return task, nil
 
225
}