// fetchAndCacheTools fetches tools with the specified version by searching for a URL
// in simplestreams and GETting it, caching the result in toolstorage before returning
// to the caller.
func (h *toolsDownloadHandler) fetchAndCacheTools(v version.Binary, stor toolstorage.Storage, st *state.State) (io.ReadCloser, error) {
envcfg, err := st.EnvironConfig()
if err != nil {
return nil, err
}
env, err := environs.New(envcfg)
if err != nil {
return nil, err
}
tools, err := envtools.FindExactTools(env, v.Number, v.Series, v.Arch)
if err != nil {
return nil, err
}
// No need to verify the server's identity because we verify the SHA-256 hash.
logger.Infof("fetching %v tools from %v", v, tools.URL)
resp, err := utils.GetNonValidatingHTTPClient().Get(tools.URL)
if err != nil {
return nil, err
}
defer resp.Body.Close()
if resp.StatusCode != http.StatusOK {
msg := fmt.Sprintf("bad HTTP response: %v", resp.Status)
if body, err := ioutil.ReadAll(resp.Body); err == nil {
msg += fmt.Sprintf(" (%s)", bytes.TrimSpace(body))
}
return nil, errors.New(msg)
}
data, sha256, err := readAndHash(resp.Body)
if err != nil {
return nil, err
}
if int64(len(data)) != tools.Size {
return nil, errors.Errorf("size mismatch for %s", tools.URL)
}
if sha256 != tools.SHA256 {
return nil, errors.Errorf("hash mismatch for %s", tools.URL)
}
// Cache tarball in toolstorage before returning.
metadata := toolstorage.Metadata{
Version: v,
Size: tools.Size,
SHA256: tools.SHA256,
}
if err := stor.AddTools(bytes.NewReader(data), metadata); err != nil {
return nil, errors.Annotate(err, "error caching tools")
}
return ioutil.NopCloser(bytes.NewReader(data)), nil
}
func (t *ToolsGetter) oneAgentTools(canRead AuthFunc, tag string, agentVersion version.Number, env environs.Environ) (*coretools.Tools, error) {
if !canRead(tag) {
return nil, ErrPerm
}
entity, err := t.st.FindEntity(tag)
if err != nil {
return nil, err
}
tooler, ok := entity.(state.AgentTooler)
if !ok {
return nil, NotSupportedError(tag, "agent tools")
}
existingTools, err := tooler.AgentTools()
if err != nil {
return nil, err
}
// 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 envtools.FindExactTools(env, agentVersion, existingTools.Version.Series, existingTools.Version.Arch)
}
func (u *UnitUpgraderAPI) getMachineTools(tag string) params.ToolsResult {
var result params.ToolsResult
machine, err := u.getAssignedMachine(tag)
if err != nil {
result.Error = common.ServerError(err)
return result
}
machineTools, err := machine.AgentTools()
if err != nil {
result.Error = common.ServerError(err)
return result
}
// For older 1.16 upgrader workers, we need to supply a tools URL since the worker will attempt to
// download the tools even though they already have been fetched by the machine agent. Newer upgrader
// workers do not have this problem. So to be compatible across all versions, we return the full
// tools metadata.
// TODO (wallyworld) - remove in 1.20, just return machineTools
cfg, err := u.st.EnvironConfig()
if err != nil {
result.Error = common.ServerError(err)
return result
}
// SSLHostnameVerification defaults to true, so we need to
// invert that, for backwards-compatibility (older versions
// will have DisableSSLHostnameVerification: false by default).
result.DisableSSLHostnameVerification = !cfg.SSLHostnameVerification()
env, err := environs.New(cfg)
if err != nil {
result.Error = common.ServerError(err)
return result
}
agentTools, err := envtools.FindExactTools(
env, machineTools.Version.Number, machineTools.Version.Series, machineTools.Version.Arch)
if err != nil {
result.Error = common.ServerError(err)
return result
}
result.Tools = agentTools
return result
}
func (s *SimpleStreamsToolsSuite) TestFindExactTools(c *gc.C) {
for i, test := range findExactToolsTests {
c.Logf("\ntest %d: %s", i, test.info)
s.reset(c, nil)
custom := s.uploadCustom(c, test.custom...)
public := s.uploadPublic(c, test.public...)
actual, err := envtools.FindExactTools(s.env, test.seek.Number, test.seek.Series, test.seek.Arch)
if test.err == nil {
if !c.Check(err, jc.ErrorIsNil) {
continue
}
c.Check(actual.Version, gc.Equals, test.seek)
if _, ok := custom[actual.Version]; ok {
c.Check(actual.URL, gc.DeepEquals, custom[actual.Version])
} else {
c.Check(actual.URL, gc.DeepEquals, public[actual.Version])
}
} else {
c.Check(err, jc.Satisfies, errors.IsNotFound)
}
}
}
// MachineConfig returns information from the environment config that
// is needed for machine cloud-init (for non-state servers only). It
// is exposed for testing purposes.
// TODO(rog) fix environs/manual tests so they do not need to call this, or move this elsewhere.
func MachineConfig(st *state.State, machineId, nonce, dataDir string) (*cloudinit.MachineConfig, error) {
environConfig, err := st.EnvironConfig()
if err != nil {
return nil, err
}
// Get the machine so we can get its series and arch.
// If the Arch is not set in hardware-characteristics,
// an error is returned.
machine, err := st.Machine(machineId)
if err != nil {
return nil, err
}
hc, err := machine.HardwareCharacteristics()
if err != nil {
return nil, err
}
if hc.Arch == nil {
return nil, fmt.Errorf("arch is not set for %q", machine.Tag())
}
// Find the appropriate tools information.
env, err := environs.New(environConfig)
if err != nil {
return nil, err
}
agentVersion, ok := env.Config().AgentVersion()
if !ok {
return nil, errors.New("no agent version set in environment configuration")
}
tools, err := envtools.FindExactTools(env, agentVersion, machine.Series(), *hc.Arch)
if err != nil {
return nil, err
}
// Find the API endpoints.
apiInfo, err := environs.APIInfo(env)
if err != nil {
return nil, err
}
auth := authentication.NewAuthenticator(st.MongoConnectionInfo(), apiInfo)
mongoInfo, apiInfo, err := auth.SetupAuthentication(machine)
if err != nil {
return nil, err
}
// Find requested networks.
networks, err := machine.RequestedNetworks()
if err != nil {
return nil, err
}
mcfg, err := environs.NewMachineConfig(machineId, nonce, env.Config().ImageStream(), machine.Series(), networks, mongoInfo, apiInfo)
if err != nil {
return nil, err
}
if dataDir != "" {
mcfg.DataDir = dataDir
}
mcfg.Tools = tools
err = environs.FinishMachineConfig(mcfg, environConfig)
if err != nil {
return nil, err
}
return mcfg, nil
}