// bundleTools bundles all the current juju tools in gzipped tar
// format to the given writer.
// If forceVersion is not nil, a FORCE-VERSION file is included in
// the tools bundle so it will lie about its current version number.
func bundleTools(build bool, w io.Writer, forceVersion *version.Number) (tvers version.Binary, sha256Hash string, err error) {
dir, err := ioutil.TempDir("", "juju-tools")
if err != nil {
return version.Binary{}, "", err
}
defer os.RemoveAll(dir)
if err := packageLocalTools(dir, build); err != nil {
return version.Binary{}, "", err
}
// Extract the version number that the jujud binary was built with.
// This is used to check compatibility with the version of the client
// being used to bootstrap.
tvers, err = getVersionFromJujud(dir)
if err != nil {
return version.Binary{}, "", errors.Trace(err)
}
if forceVersion != nil {
logger.Debugf("forcing version to %s", forceVersion)
if err := ioutil.WriteFile(filepath.Join(dir, "FORCE-VERSION"), []byte(forceVersion.String()), 0666); err != nil {
return version.Binary{}, "", err
}
}
sha256hash, err := archiveAndSHA256(w, dir)
if err != nil {
return version.Binary{}, "", err
}
return tvers, sha256hash, err
}
// bundleTools bundles all the current juju tools in gzipped tar
// format to the given writer.
// If forceVersion is not nil, a FORCE-VERSION file is included in
// the tools bundle so it will lie about its current version number.
func bundleTools(w io.Writer, forceVersion *version.Number) (tvers version.Binary, sha256Hash string, err error) {
dir, err := ioutil.TempDir("", "juju-tools")
if err != nil {
return version.Binary{}, "", err
}
defer os.RemoveAll(dir)
if err := copyExistingJujud(dir); err != nil {
logger.Debugf("copy existing failed: %v", err)
if err := buildJujud(dir); err != nil {
return version.Binary{}, "", err
}
}
if forceVersion != nil {
logger.Debugf("forcing version to %s", forceVersion)
if err := ioutil.WriteFile(filepath.Join(dir, "FORCE-VERSION"), []byte(forceVersion.String()), 0666); err != nil {
return version.Binary{}, "", err
}
}
tvers, err = getVersionFromJujud(dir)
if err != nil {
return version.Binary{}, "", errors.Trace(err)
}
sha256hash, err := archiveAndSHA256(w, dir)
if err != nil {
return version.Binary{}, "", err
}
return tvers, sha256hash, err
}
// NewDbLogger returns a DbLogger instance which is used to write logs
// to the database.
func NewDbLogger(st ModelSessioner, entity names.Tag, ver version.Number) *DbLogger {
_, logsColl := initLogsSession(st)
return &DbLogger{
logsColl: logsColl,
modelUUID: st.ModelUUID(),
entity: entity.String(),
version: ver.String(),
}
}
// UpdateLatestToolsVersion looks up for the latest available version of
// juju tools and updates environementDoc with it.
func (m *Model) UpdateLatestToolsVersion(ver version.Number) error {
v := ver.String()
// TODO(perrito666): I need to assert here that there isn't a newer
// version in place.
ops := []txn.Op{{
C: modelsC,
Id: m.doc.UUID,
Update: bson.D{{"$set", bson.D{{"available-tools", v}}}},
}}
err := m.st.runTransaction(ops)
if err != nil {
return errors.Trace(err)
}
return m.Refresh()
}
// setBootstrapToolsVersion updates the agent-version configuration attribute.
func setBootstrapToolsVersion(environ environs.Environ, toolsVersion version.Number) error {
cfg := environ.Config()
if agentVersion, _ := cfg.AgentVersion(); agentVersion != toolsVersion {
cfg, err := cfg.Apply(map[string]interface{}{
"agent-version": toolsVersion.String(),
})
if err == nil {
err = environ.SetConfig(cfg)
}
if err != nil {
return errors.Errorf("failed to update model configuration: %v", err)
}
}
return nil
}
// GUISetVersion sets the Juju GUI version that the controller must serve.
func (st *State) GUISetVersion(vers version.Number) error {
// Check that the provided version is actually present in the GUI storage.
storage, err := st.GUIStorage()
if err != nil {
return errors.Annotate(err, "cannot open GUI storage")
}
defer storage.Close()
if _, err = storage.Metadata(vers.String()); err != nil {
return errors.Annotatef(err, "cannot find %q GUI version in the storage", vers)
}
// Set the current version.
settings, closer := st.getCollection(guisettingsC)
defer closer()
if _, err = settings.Writeable().Upsert(nil, bson.D{{"current-version", vers}}); err != nil {
return errors.Annotate(err, "cannot set current GUI version")
}
return nil
}
// UploadGUIArchive uploads a GUI archive to the controller over HTTPS, and
// reports about whether the upload updated the current GUI served by Juju.
func (c *Client) UploadGUIArchive(r io.ReadSeeker, hash string, size int64, vers version.Number) (current bool, err error) {
// Prepare the request.
v := url.Values{}
v.Set("version", vers.String())
v.Set("hash", hash)
req, err := http.NewRequest("POST", guiArchivePath+"?"+v.Encode(), nil)
if err != nil {
return false, errors.Annotate(err, "cannot create upload request")
}
req.Header.Set("Content-Type", "application/x-tar-bzip2")
req.ContentLength = size
// Retrieve a client and send the request.
httpClient, err := c.facade.RawAPICaller().HTTPClient()
if err != nil {
return false, errors.Annotate(err, "cannot retrieve HTTP client")
}
var resp params.GUIArchiveVersion
if err = httpClient.Do(req, r, &resp); err != nil {
return false, errors.Annotate(err, "cannot upload the GUI archive")
}
return resp.Current, nil
}
// setBootstrapTools returns the newest tools from the given tools list,
// and updates the agent-version configuration attribute.
func setBootstrapTools(environ environs.Environ, possibleTools coretools.List) (coretools.List, error) {
if len(possibleTools) == 0 {
return nil, fmt.Errorf("no bootstrap tools available")
}
var newVersion version.Number
newVersion, toolsList := possibleTools.Newest()
logger.Infof("newest version: %s", newVersion)
cfg := environ.Config()
if agentVersion, _ := cfg.AgentVersion(); agentVersion != newVersion {
cfg, err := cfg.Apply(map[string]interface{}{
"agent-version": newVersion.String(),
})
if err == nil {
err = environ.SetConfig(cfg)
}
if err != nil {
return nil, fmt.Errorf("failed to update model configuration: %v", err)
}
}
bootstrapVersion := newVersion
// We should only ever bootstrap the exact same version as the client,
// or we risk bootstrap incompatibility. We still set agent-version to
// the newest version, so the agent will immediately upgrade itself.
if !isCompatibleVersion(newVersion, jujuversion.Current) {
compatibleVersion, compatibleTools := findCompatibleTools(possibleTools, jujuversion.Current)
if len(compatibleTools) == 0 {
logger.Warningf(
"failed to find %s tools, will attempt to use %s",
jujuversion.Current, newVersion,
)
} else {
bootstrapVersion, toolsList = compatibleVersion, compatibleTools
}
}
logger.Infof("picked bootstrap tools version: %s", bootstrapVersion)
return toolsList, nil
}
// BundleTools bundles all the current juju tools in gzipped tar
// format to the given writer.
// If forceVersion is not nil, a FORCE-VERSION file is included in
// the tools bundle so it will lie about its current version number.
func bundleTools(w io.Writer, forceVersion *version.Number) (tvers version.Binary, sha256Hash string, err error) {
dir, err := ioutil.TempDir("", "juju-tools")
if err != nil {
return version.Binary{}, "", err
}
defer os.RemoveAll(dir)
if err := copyExistingJujud(dir); err != nil {
logger.Debugf("copy existing failed: %v", err)
if err := buildJujud(dir); err != nil {
return version.Binary{}, "", err
}
}
if forceVersion != nil {
logger.Debugf("forcing version to %s", forceVersion)
if err := ioutil.WriteFile(filepath.Join(dir, "FORCE-VERSION"), []byte(forceVersion.String()), 0666); err != nil {
return version.Binary{}, "", err
}
}
cmd := exec.Command(filepath.Join(dir, names.Jujud), "version")
out, err := cmd.CombinedOutput()
if err != nil {
return version.Binary{}, "", fmt.Errorf("cannot get version from %q: %v; %s", cmd.Args[0], err, out)
}
tvs := strings.TrimSpace(string(out))
tvers, err = version.ParseBinary(tvs)
if err != nil {
return version.Binary{}, "", fmt.Errorf("invalid version %q printed by jujud", tvs)
}
sha256hash, err := archiveAndSHA256(w, dir)
if err != nil {
return version.Binary{}, "", err
}
return tvers, sha256hash, err
}
// SetBootstrapEndpointAddress writes the API endpoint address of the
// bootstrap server, plus the agent version, into the connection information.
// This should only be run once directly after Bootstrap. It assumes that
// there is just one instance in the environment - the bootstrap instance.
func SetBootstrapEndpointAddress(
store jujuclient.ControllerStore,
controllerName string, agentVersion version.Number,
apiPort int, environ environs.Environ,
) error {
instances, err := allInstances(environ)
if err != nil {
return errors.Trace(err)
}
length := len(instances)
if length == 0 {
return errors.Errorf("found no instances, expected at least one")
}
if length > 1 {
return errors.Errorf("expected one instance, got %d", length)
}
bootstrapInstance := instances[0]
// Don't use c.ConnectionEndpoint as it attempts to contact the state
// server if no addresses are found in connection info.
netAddrs, err := bootstrapInstance.Addresses()
if err != nil {
return errors.Annotate(err, "failed to get bootstrap instance addresses")
}
apiHostPorts := network.AddressesWithPort(netAddrs, apiPort)
// At bootstrap we have 2 models, the controller model and the default.
two := 2
params := juju.UpdateControllerParams{
AgentVersion: agentVersion.String(),
AddrConnectedTo: apiHostPorts,
MachineCount: &length,
ControllerMachineCount: &length,
ModelCount: &two,
}
return juju.UpdateControllerDetailsFromLogin(store, controllerName, params)
}
