github.com/cloudbase/juju-core@v0.0.0-20140504232958-a7271ac7912f/cmd/jujud/machine_windows.go (about)

     1  package main
     2  
     3  import (
     4      "os"
     5      "fmt"
     6      "path/filepath"
     7  
     8      // "launchpad.net/juju-core/agent"
     9      "launchpad.net/juju-core/worker"
    10      // "launchpad.net/juju-core/worker/authenticationworker"
    11      "launchpad.net/juju-core/worker/charmrevisionworker"
    12      "launchpad.net/juju-core/worker/deployer"
    13      "launchpad.net/juju-core/worker/firewaller"
    14      workerlogger "launchpad.net/juju-core/worker/logger"
    15      // "launchpad.net/juju-core/worker/machineenvironmentworker"
    16      "launchpad.net/juju-core/worker/machiner"
    17      // "launchpad.net/juju-core/worker/rsyslog"
    18      "launchpad.net/juju-core/worker/upgrader"
    19      "launchpad.net/juju-core/state/api/params"
    20      // "launchpad.net/juju-core/provider"
    21      "launchpad.net/juju-core/worker/provisioner"
    22      "launchpad.net/juju-core/utils"
    23  )
    24  
    25  func (a *MachineAgent) initAgent() error {
    26      if err := os.Remove(jujuRun); err != nil && !os.IsNotExist(err) {
    27          return err
    28      }
    29      jujud := filepath.Join(a.Conf.dataDir, "tools", a.Tag(), "jujud.exe")
    30      return utils.Symlink(jujud, jujuRun)
    31  }
    32  
    33  // APIWorker returns a Worker that connects to the API and starts any
    34  // workers that need an API connection.
    35  //
    36  // If a state worker is necessary, APIWorker calls ensureStateWorker.
    37  func (a *MachineAgent) APIWorker(ensureStateWorker func()) (worker.Worker, error) {
    38      agentConfig := a.Conf.config
    39      st, entity, err := openAPIState(agentConfig, a)
    40      if err != nil {
    41          return nil, err
    42      }
    43      reportOpenedAPI(st)
    44      for _, job := range entity.Jobs() {
    45          if job.NeedsState() {
    46              ensureStateWorker()
    47              break
    48          }
    49      }
    50      /*
    51      rsyslogMode := rsyslog.RsyslogModeForwarding
    52      for _, job := range entity.Jobs() {
    53          if job == params.JobManageEnviron {
    54              rsyslogMode = rsyslog.RsyslogModeAccumulate
    55              break
    56          }
    57      } */
    58  
    59      runner := newRunner(connectionIsFatal(st), moreImportant)
    60  
    61      // Run the upgrader and the upgrade-steps worker without waiting for the upgrade steps to complete.
    62      runner.StartWorker("upgrader", func() (worker.Worker, error) {
    63          return upgrader.NewUpgrader(st.Upgrader(), agentConfig), nil
    64      })
    65      runner.StartWorker("upgrade-steps", func() (worker.Worker, error) {
    66          return a.upgradeWorker(st, entity.Jobs()), nil
    67      })
    68  
    69      // All other workers must wait for the upgrade steps to complete before starting.
    70      a.startWorkerAfterUpgrade(runner, "machiner", func() (worker.Worker, error) {
    71          return machiner.NewMachiner(st.Machiner(), agentConfig), nil
    72      })
    73      a.startWorkerAfterUpgrade(runner, "logger", func() (worker.Worker, error) {
    74          return workerlogger.NewLogger(st.Logger(), agentConfig), nil
    75      })
    76      // TODO: gsamfira: Port machineenvironmentworker to windows. Proxy settings can be written
    77      // in the registry
    78      /* 
    79      a.startWorkerAfterUpgrade(runner, "machineenvironmentworker", func() (worker.Worker, error) {
    80          return machineenvironmentworker.NewMachineEnvironmentWorker(st.Environment(), agentConfig), nil
    81      }) */
    82      // gsamfira: No syslog support on windows (yet)
    83      /*
    84      a.startWorkerAfterUpgrade(runner, "rsyslog", func() (worker.Worker, error) {
    85          return newRsyslogConfigWorker(st.Rsyslog(), agentConfig, rsyslogMode)
    86      }) */
    87  
    88      // If not a local provider bootstrap machine, start the worker to manage SSH keys.
    89  
    90      // TODO: gsamfira: This will need to be ported at a later time to setup x509 keys for
    91      // WinRm
    92      /*
    93      providerType := agentConfig.Value(agent.ProviderType)
    94      if providerType != provider.Local || a.MachineId != bootstrapMachineId {
    95          a.startWorkerAfterUpgrade(runner, "authenticationworker", func() (worker.Worker, error) {
    96              return authenticationworker.NewWorker(st.KeyUpdater(), agentConfig), nil
    97          })
    98      } */
    99  
   100      // Perform the operations needed to set up hosting for containers.
   101      if err := a.setupContainerSupport(runner, st, entity); err != nil {
   102          return nil, fmt.Errorf("setting up container support: %v", err)
   103      }
   104      for _, job := range entity.Jobs() {
   105          switch job {
   106          case params.JobHostUnits:
   107              a.startWorkerAfterUpgrade(runner, "deployer", func() (worker.Worker, error) {
   108                  apiDeployer := st.Deployer()
   109                  context := newDeployContext(apiDeployer, agentConfig)
   110                  return deployer.NewDeployer(apiDeployer, context), nil
   111              })
   112          case params.JobManageEnviron:
   113              a.startWorkerAfterUpgrade(runner, "environ-provisioner", func() (worker.Worker, error) {
   114                  return provisioner.NewEnvironProvisioner(st.Provisioner(), agentConfig), nil
   115              })
   116              // TODO(axw) 2013-09-24 bug #1229506
   117              // Make another job to enable the firewaller. Not all environments
   118              // are capable of managing ports centrally.
   119              a.startWorkerAfterUpgrade(runner, "firewaller", func() (worker.Worker, error) {
   120                  return firewaller.NewFirewaller(st.Firewaller())
   121              })
   122              a.startWorkerAfterUpgrade(runner, "charm-revision-updater", func() (worker.Worker, error) {
   123                  return charmrevisionworker.NewRevisionUpdateWorker(st.CharmRevisionUpdater()), nil
   124              })
   125          case params.JobManageStateDeprecated:
   126              // Legacy environments may set this, but we ignore it.
   127          default:
   128              // TODO(dimitern): Once all workers moved over to using
   129              // the API, report "unknown job type" here.
   130          }
   131      }
   132      return newCloseWorker(runner, st), nil // Note: a worker.Runner is itself a worker.Worker.
   133  }