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 }