~juju-qa/ubuntu/xenial/juju/xenial-2.0-beta3

        "github.com/juju/juju/api/agenttools"

        statestorage "github.com/juju/juju/state/storage"

        "github.com/juju/juju/version"

        "github.com/juju/juju/worker/machiner"

        "github.com/juju/juju/worker/toolsversionchecker"

const bootstrapMachineId = "0"

 

        retryDelay   = 3 * time.Second

        newMachiner              = machiner.NewMachiner

        agentConfig := a.currentConfig.CurrentConfig()

                Filename:   agent.LogFilename(agentConfig),

        loopDeviceManager looputil.LoopDeviceManager,

                        loopDeviceManager,

        configChangedVal voyeur.Value

        logger.Infof("machine agent %v start (%s [%s])", a.Tag(), version.Current, runtime.Compiler)

        a.runner.StartWorker("statestarter", a.newStateStarterWorker)

        a.configChangedVal.Set(struct{}{})

        if err != nil {

                return errors.Trace(err)

        }

        return nil

// newStateStarterWorker wraps stateStarter in a simple worker for use in

// a.runner.StartWorker.

func (a *MachineAgent) newStateStarterWorker() (worker.Worker, error) {

        return worker.NewSimpleWorker(a.stateStarter), nil

}

 

// stateStarter watches for changes to the agent configuration, and

// starts or stops the state worker as appropriate. We watch the agent

// configuration because the agent configuration has all the details

// that we need to start a controller, whether they have been cached

// or read from the state.

//

// It will stop working as soon as stopch is closed.

func (a *MachineAgent) stateStarter(stopch <-chan struct{}) error {

        confWatch := a.configChangedVal.Watch()

        defer confWatch.Close()

        watchCh := make(chan struct{})

        go func() {

                for confWatch.Next() {

                        watchCh <- struct{}{}

                }

        }()

        for {

                select {

                case <-watchCh:

                        agentConfig := a.CurrentConfig()

 

                        // N.B. StartWorker and StopWorker are idempotent.

                        _, ok := agentConfig.StateServingInfo()

                        if ok {

                                a.runner.StartWorker("state", func() (worker.Worker, error) {

                                        return a.StateWorker()

                                })

                        } else {

                                a.runner.StopWorker("state")

                        }

                case <-stopch:

                        return nil

                }

        }

}

 

                runner.StartWorker("toolsversionchecker", func() (worker.Worker, error) {

                        // 4 times a day seems a decent enough amount of checks.

                        checkerParams := toolsversionchecker.VersionCheckerParams{

                                CheckInterval: time.Hour * 6,

                        }

                        return toolsversionchecker.New(agenttools.NewFacade(apiConn), &checkerParams), nil

                })

func (a *MachineAgent) openStateForUpgrade() (*state.State, func(), error) {

                return nil, nil, errors.Trace(err)

                return nil, nil, errors.New("no state info available")

                return nil, nil, errors.Trace(err)

        }

 

        // Ensure storage is available during upgrades.

        stor := statestorage.NewStorage(st.ModelUUID(), st.MongoSession())

        registerSimplestreamsDataSource(stor, false)

 

        closer := func() {

                unregisterSimplestreamsDataSource()

                st.Close()

        }

        return st, closer, nil

// StateWorker returns a worker running all the workers that require

// a *state.State connection.

func (a *MachineAgent) StateWorker() (worker.Worker, error) {

        agentConfig := a.CurrentConfig()

 

        st, m, err := openState(agentConfig, stateWorkerDialOpts)

                        // Each time aipserver worker is restarted, we need a fresh copy of state due

                                logger.Debugf("opening state for apistate worker")

        return cmdutil.NewCloseWorker(logger, runner, stateWorkerCloser{st}), nil

}

 

type stateWorkerCloser struct {

        stateCloser io.Closer

}

 

func (s stateWorkerCloser) Close() error {

        // This state-dependent data source will be useless once state is closed -

        // un-register it before closing state.

        unregisterSimplestreamsDataSource()

        return s.stateCloser.Close()

        for name, factory := range registeredModelWorkers {

                newWorker := factory(st)

                singularRunner.StartWorker(name, newWorker)

        }

 

                        return apiserver.UpgradeInProgressError

                return errors.Errorf("login for %q blocked because %s", authTag, apiserver.UpgradeInProgressError.Error())