// addCharmViaAPI calls the appropriate client API calls to add the
// given charm URL to state. Also displays the charm URL of the added
// charm on stdout.
func addCharmViaAPI(client *api.Client, ctx *cmd.Context, curl *charm.URL, repo charm.Repository) (*charm.URL, error) {
if curl.Revision < 0 {
latest, err := charm.Latest(repo, curl)
if err != nil {
return nil, err
}
curl = curl.WithRevision(latest)
}
switch curl.Schema {
case "local":
ch, err := repo.Get(curl)
if err != nil {
return nil, err
}
stateCurl, err := client.AddLocalCharm(curl, ch)
if err != nil {
return nil, err
}
curl = stateCurl
case "cs":
err := client.AddCharm(curl)
if err != nil {
return nil, err
}
default:
return nil, fmt.Errorf("unsupported charm URL schema: %q", curl.Schema)
}
ctx.Infof("Added charm %q to the environment.", curl)
return curl, nil
}
func getCharmInfo(client *api.Client, charmName string, localRepoPath string, defaultSeries string) (*api.CharmInfo, error) {
curl, err := resolveCharmURL(client, charmName, defaultSeries)
if err != nil {
return nil, err
}
repo, err := charm.InferRepository(curl.Reference, localRepoPath)
if err != nil {
return nil, err
}
// repo = config.SpecializeCharmRepo(repo, defaultSeries)
curl, err = addCharmViaAPI(client, curl, repo)
if err != nil {
return nil, err
}
charmInfo, err := client.CharmInfo(curl.String())
if err != nil {
log.Info("Error getting charm info for: %v", curl.String(), err)
return nil, err
}
return charmInfo, nil
}
// resolveCharmURL returns a resolved charm URL, given a charm location string.
// If the series is not resolved, the environment default-series is used, or if
// not set, the series is resolved with the state server.
func resolveCharmURL(client *api.Client, url string, defaultSeries string) (*charm.URL, error) {
ref, series, err := charm.ParseReference(url)
if err != nil {
return nil, err
}
// If series is not set, use configured default series
if series == "" {
series = defaultSeries
}
// Otherwise, look up the best supported series for this charm
if series == "" {
return client.ResolveCharm(ref)
}
return &charm.URL{Reference: ref, Series: series}, nil
}
func recordMachineInState(
client *api.Client, machineParams params.AddMachineParams) (machineId string, err error) {
// Note: we explicitly use AddMachines1dot18 rather than AddMachines to preserve
// backwards compatibility; we do not require any of the new features of AddMachines
// here.
results, err := client.AddMachines1dot18([]params.AddMachineParams{machineParams})
if err != nil {
return "", err
}
// Currently, only one machine is added, but in future there may be several added in one call.
machineInfo := results[0]
if machineInfo.Error != nil {
return "", machineInfo.Error
}
return machineInfo.Machine, nil
}
// initVersions collects state relevant to an upgrade decision. The returned
// agent and client versions, and the list of currently available tools, will
// always be accurate; the chosen version, and the flag indicating development
// mode, may remain blank until uploadTools or validate is called.
func (c *UpgradeJujuCommand) initVersions(client *api.Client, cfg *config.Config) (*upgradeContext, error) {
agent, ok := cfg.AgentVersion()
if !ok {
// Can't happen. In theory.
return nil, fmt.Errorf("incomplete environment configuration")
}
if c.Version == agent {
return nil, errUpToDate
}
clientVersion := version.Current.Number
findResult, err := client.FindTools(clientVersion.Major, -1, "", "")
var availableTools coretools.List
if params.IsCodeNotImplemented(err) {
availableTools, err = findTools1dot17(cfg)
} else {
availableTools = findResult.List
}
if err != nil {
return nil, err
}
err = findResult.Error
if findResult.Error != nil {
if !params.IsCodeNotFound(err) {
return nil, err
}
if !c.UploadTools {
// No tools found and we shouldn't upload any, so if we are not asking for a
// major upgrade, pretend there is no more recent version available.
if c.Version == version.Zero && agent.Major == clientVersion.Major {
return nil, errUpToDate
}
return nil, err
}
}
return &upgradeContext{
agent: agent,
client: clientVersion,
chosen: c.Version,
tools: availableTools,
apiClient: client,
config: cfg,
}, nil
}
// resolveCharmURL returns a resolved charm URL, given a charm location string.
// If the series is not resolved, the environment default-series is used, or if
// not set, the series is resolved with the state server.
func resolveCharmURL(url string, client *api.Client, conf *config.Config) (*charm.URL, error) {
ref, series, err := charm.ParseReference(url)
if err != nil {
return nil, err
}
// If series is not set, use configured default series
if series == "" {
if defaultSeries, ok := conf.DefaultSeries(); ok {
series = defaultSeries
}
}
// Otherwise, look up the best supported series for this charm
if series == "" {
if ref.Schema == "local" {
possibleUrl := &charm.URL{Reference: ref, Series: "precise"}
logger.Errorf(`The series is not specified in the environment (default-series) or with the charm. Did you mean:
%s`, possibleUrl.String())
return nil, fmt.Errorf("cannot resolve series for charm: %q", ref)
}
return client.ResolveCharm(ref)
}
return &charm.URL{Reference: ref, Series: series}, nil
}
func assertEnvironmentName(c *gc.C, client *api.Client, expectName string) {
envInfo, err := client.EnvironmentInfo()
c.Assert(err, gc.IsNil)
c.Assert(envInfo.Name, gc.Equals, expectName)
}