state: deprecate JobManageState

cmd/jujud/machine.go

 // Copyright 2012, 2013 Canonical Ltd.
 // Licensed under the AGPLv3, see LICENCE file for details.
 
 package main
 
 import (
         "fmt"
         "os"
         "path/filepath"
         "time"
@@ skipping 196 matching lines @@
                 case params.JobManageEnviron:
                         runner.StartWorker("environ-provisioner", func() (worker.Worker, error) {
                                 return provisioner.NewEnvironProvisioner(st.Provisioner(), agentConfig), nil
                         })
                         // TODO(axw) 2013-09-24 bug #1229506
                         // Make another job to enable the firewaller. Not all environments
                         // are capable of managing ports centrally.
                         runner.StartWorker("firewaller", func() (worker.Worker, error) {
                                 return firewaller.NewFirewaller(st.Firewaller())
                         })
-                case params.JobManageState:
                         runner.StartWorker("charm-revision-updater", func() (worker.Worker, error) {
                                 return charmrevisionworker.NewRevisionUpdateWorker(st.CharmRevisionUpdater()), nil
                         })
+                case params.JobManageState:
+                        // Legacy environments may set this, but we ignore it.
                 default:
                         // TODO(dimitern): Once all workers moved over to using
                         // the API, report "unknown job type" here.
                 }
         }
         return newCloseWorker(runner, st), nil // Note: a worker.Runner is itself a worker.Worker.
 }
 
 // setupContainerSupport determines what containers can be run on this machine and
 // initialises suitable infrastructure to support such containers.
@@ skipping 68 matching lines @@
                 })
         }
         for _, job := range m.Jobs() {
                 switch job {
                 case state.JobHostUnits:
                         // Implemented in APIWorker.
                 case state.JobManageEnviron:
                         runner.StartWorker("instancepoller", func() (worker.Worker, error) {
                                 return instancepoller.NewWorker(st), nil
                         })
-                case state.JobManageState:
                         runner.StartWorker("apiserver", func() (worker.Worker, error) {
                                 // If the configuration does not have the required information,
                                 // it is currently not a recoverable error, so we kill the whole
                                 // agent, potentially enabling human intervention to fix
                                 // the agent's configuration file. In the future, we may retrieve
                                 // the state server certificate and key from the state, and
                                 // this should then change.
                                 port, cert, key := a.Conf.config.APIServerDetails()
                                 if len(cert) == 0 || len(key) == 0 {
                                         return nil, &fatalError{"configuration does not have state server cert/key"}
                                 }
                                 dataDir := a.Conf.config.DataDir()
                                 return apiserver.NewServer(st, fmt.Sprintf(":%d", port), cert, key, dataDir)
                         })
                         runner.StartWorker("cleaner", func() (worker.Worker, error) {
                                 return cleaner.NewCleaner(st), nil
                         })
                         runner.StartWorker("resumer", func() (worker.Worker, error) {
                                 // The action of resumer is so subtle that it is not tested,
                                 // because we can't figure out how to do so without brutalising
                                 // the transaction log.
                                 return resumer.NewResumer(st), nil
                         })
                         runner.StartWorker("minunitsworker", func() (worker.Worker, error) {
                                 return minunitsworker.NewMinUnitsWorker(st), nil
                         })
+                case state.JobManageState:
+                        // Legacy environments may set this, but we ignore it.
                 default:
                         logger.Warningf("ignoring unknown job %q", job)
                 }
         }
         return newCloseWorker(runner, st), nil
 }
 
 func (a *MachineAgent) Entity(st *state.State) (AgentState, error) {
         m, err := st.Machine(a.MachineId)
         if err != nil {
@@ skipping 90 matching lines @@
         select {
         case apiReporter <- st:
         default:
         }
 }
 func sendOpenedAPIs(dst chan<- *api.State) (undo func()) {
         var original chan<- *api.State
         original, apiReporter = apiReporter, dst
         return func() { apiReporter = original }
 }