func (u *UpgraderAPI) oneAgentTools(tag string, agentVersion version.Number, env environs.Environ) (*tools.Tools, error) {
if !u.authorizer.AuthOwner(tag) {
return nil, common.ErrPerm
}
entity0, err := u.findEntity(tag)
if err != nil {
return nil, err
}
entity, ok := entity0.(state.AgentTooler)
if !ok {
return nil, common.NotSupportedError(tag, "agent tools")
}
existingTools, err := entity.AgentTools()
if err != nil {
return nil, err
}
requested := version.Binary{
Number: agentVersion,
Series: existingTools.Version.Series,
Arch: existingTools.Version.Arch,
}
// TODO(jam): Avoid searching the provider for every machine
// that wants to upgrade. The information could just be cached
// in state, or even in the API servers
return environs.FindExactTools(env, requested)
}
func (s *ToolsSuite) TestFindExactTools(c *C) {
for i, test := range findExactToolsTests {
c.Logf("\ntest %d: %s", i, test.info)
s.Reset(c, nil)
private := s.uploadPrivate(c, test.private...)
public := s.uploadPublic(c, test.public...)
actual, err := environs.FindExactTools(s.env, test.seek)
if test.err == nil {
c.Check(err, IsNil)
c.Check(actual.Binary, Equals, test.seek)
source := private
if len(source) == 0 {
// We only use the public bucket if the private one has *no* tools.
source = public
}
c.Check(actual.URL, DeepEquals, source[actual.Binary])
} else {
c.Check(err, DeepEquals, &errors.NotFoundError{test.err, ""})
}
}
}
func (u *UpgraderAPI) oneAgentTools(entity params.Entity, agentVersion version.Number, env environs.Environ) (params.AgentTools, error) {
if !u.authorizer.AuthOwner(entity.Tag) {
return nilTools, common.ErrPerm
}
machine, err := u.st.Machine(state.MachineIdFromTag(entity.Tag))
if err != nil {
return nilTools, err
}
// TODO: Support Unit as well as Machine
existingTools, err := machine.AgentTools()
if err != nil {
return nilTools, err
}
requested := version.Binary{
Number: agentVersion,
Series: existingTools.Series,
Arch: existingTools.Arch,
}
// Note: (jam) We shouldn't have to search the provider
// for every machine that wants to upgrade. The
// information could just be cached in state, or
// even in the API servers
tools, err := environs.FindExactTools(env, requested)
if err != nil {
return nilTools, err
}
return params.AgentTools{
Tag: entity.Tag,
Arch: tools.Arch,
Series: tools.Series,
URL: tools.URL,
Major: tools.Major,
Minor: tools.Minor,
Patch: tools.Patch,
Build: tools.Build,
}, nil
}
func (u *Upgrader) run() error {
// Let the state know the version that is currently running.
currentTools, err := tools.ReadTools(u.dataDir, version.Current)
if err != nil {
// Don't abort everything because we can't find the tools directory.
// The problem should sort itself out as we will immediately
// download some more tools and upgrade.
log.Warningf("upgrader cannot read current tools: %v", err)
currentTools = &tools.Tools{
Binary: version.Current,
}
}
err = u.agentState.SetAgentTools(currentTools)
if err != nil {
return err
}
// TODO(fwereade): this whole package should be ignorant of environs,
// so it shouldn't be watching environ config (and it shouldn't be
// looking in storage): we should be able to find out what to download
// from state, exactly as we do for charms.
w := u.st.WatchEnvironConfig()
defer watcher.Stop(w, &u.tomb)
// Rather than using worker.WaitForEnviron, invalid environments are
// managed explicitly so that all configuration changes are observed
// by the loop below.
var environ environs.Environ
// TODO(rog) retry downloads when they fail.
var (
download *downloader.Download
downloadTools *tools.Tools
downloadDone <-chan downloader.Status
)
// If we're killed early on (probably as a result of some other
// task dying) we allow ourselves some time to try to connect to
// the state and download a new version. We return to normal
// undelayed behaviour when:
// 1) We find there's no upgrade to do.
// 2) A download fails.
tomb := delayedTomb(&u.tomb, upgraderKillDelay)
noDelay := func() {
if tomb != &u.tomb {
tomb.Kill(nil)
tomb = &u.tomb
}
}
for {
// We wait for the tools to change while we're downloading
// so that if something goes wrong (for instance a bad URL
// hangs up) another change to the proposed tools can
// potentially fix things.
select {
case cfg, ok := <-w.Changes():
if !ok {
return watcher.MustErr(w)
}
var err error
if environ == nil {
environ, err = environs.New(cfg)
if err != nil {
log.Errorf("upgrader loaded invalid initial environment configuration: %v", err)
break
}
} else {
err = environ.SetConfig(cfg)
if err != nil {
log.Warningf("upgrader loaded invalid environment configuration: %v", err)
// continue on, because the version number is still significant.
}
}
proposed, ok := cfg.AgentVersion()
if !ok {
// This shouldn't be possible; but if it happens it's no reason
// to kill this task. Just wait for the config to change again.
continue
}
if download != nil {
// There's a download in progress, stop it if we need to.
if downloadTools.Number == proposed {
// We are already downloading the requested tools.
break
}
// Tools changed. We need to stop and restart.
download.Stop()
download, downloadTools, downloadDone = nil, nil, nil
}
// TODO: major version upgrades.
if proposed.Major != version.Current.Major {
log.Errorf("major version upgrades are not supported yet")
noDelay()
break
}
if proposed == version.Current.Number {
noDelay()
break
}
required := version.Binary{
Number: proposed,
Series: version.Current.Series,
Arch: version.Current.Arch,
}
if tools, err := tools.ReadTools(u.dataDir, required); err == nil {
// The exact tools have already been downloaded, so use them.
return u.upgradeReady(currentTools, tools)
}
tools, err := environs.FindExactTools(environ, required)
if err != nil {
log.Errorf("upgrader error finding tools for %v: %v", required, err)
if !errors.IsNotFoundError(err) {
return err
}
noDelay()
// TODO(rog): poll until tools become available.
break
}
log.Infof("upgrader downloading %q", tools.URL)
download = downloader.New(tools.URL, "")
downloadTools = tools
downloadDone = download.Done()
case status := <-downloadDone:
newTools := downloadTools
download, downloadTools, downloadDone = nil, nil, nil
if status.Err != nil {
log.Errorf("upgrader download of %v failed: %v", newTools.Binary, status.Err)
noDelay()
break
}
err := tools.UnpackTools(u.dataDir, newTools, status.File)
status.File.Close()
if err := os.Remove(status.File.Name()); err != nil {
log.Warningf("upgrader cannot remove temporary download file: %v", err)
}
if err != nil {
log.Errorf("upgrader cannot unpack %v tools: %v", newTools.Binary, err)
noDelay()
break
}
return u.upgradeReady(currentTools, newTools)
case <-tomb.Dying():
if download != nil {
return fmt.Errorf("upgrader aborted download of %q", downloadTools.URL)
}
return nil
}
}
panic("not reached")
}
