コード例 #1
0
ファイル: upgrader.go プロジェクト: hivetech/judo.legacy
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)
}
コード例 #2
0
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, ""})
		}
	}
}
コード例 #3
0
ファイル: upgrader.go プロジェクト: CSRedRat/juju-core
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
}
コード例 #4
0
ファイル: upgrade.go プロジェクト: rif/golang-stuff
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")
}