New charm revision updater api

state/apiserver/charmrevisionupdater/updater.go

+// Copyright 2013 Canonical Ltd.
+// Licensed under the AGPLv3, see LICENCE file for details.
+
+package charmrevisionupdater
+
+import (
+        "launchpad.net/loggo"
+
+        "launchpad.net/juju-core/charm"
+        "launchpad.net/juju-core/log"
+        "launchpad.net/juju-core/state"
+        "launchpad.net/juju-core/state/api/params"
+        "launchpad.net/juju-core/state/apiserver/common"
+)
+
+var logger = loggo.GetLogger("juju.state.apiserver.charmrevisionupdater")
+
+// CharmRevisionUpdater defines the methods on the charmrevisionupdater API end point.
+type CharmRevisionUpdater interface {
+        UpdateLatestRevisions() (params.ErrorResult, error)
+}
+
+// CharmRevisionUpdaterAPI implements the CharmRevisionUpdater interface and is the concrete
+// implementation of the api end point.
+type CharmRevisionUpdaterAPI struct {
+        state      *state.State
+        resources  *common.Resources
+        authorizer common.Authorizer
+}
+
+var _ CharmRevisionUpdater = (*CharmRevisionUpdaterAPI)(nil)
+
+// NewCharmRevisionUpdaterAPI creates a new server-side charmrevisionupdater API end point.
+func NewCharmRevisionUpdaterAPI(
+        st *state.State,
+        resources *common.Resources,
+        authorizer common.Authorizer,
+) (*CharmRevisionUpdaterAPI, error) {
+        if !authorizer.AuthMachineAgent() && !authorizer.AuthStateManager() {
+                return nil, common.ErrPerm
+        }
+        return &CharmRevisionUpdaterAPI{
+                state: st, resources: resources, authorizer: authorizer}, nil
+}
+
+// UpdateLatestRevisions retrieves the latest revision information from the charm store for all deployed charms
+// and records this information in state.
+func (api *CharmRevisionUpdaterAPI) UpdateLatestRevisions() (params.ErrorResult, error) {
+        deployedCharms, err := fetchAllDeployedCharms(api.state)
+        if err != nil {
+                return params.ErrorResult{common.ServerError(err)}, nil
+        }
+        // Look up the revision information for all the deployed charms.
+        curls, err := retrieveLatestCharmInfo(deployedCharms)
+        if err != nil {
+                return params.ErrorResult{common.ServerError(err)}, nil
+        }
+        // Add the charms and latest revision info to state as charm placeholders.
+        for _, curl := range curls {
+                if err = api.state.AddStoreCharmPlaceholder(curl); err != nil {
+                        return params.ErrorResult{common.ServerError(err)}, nil
+                }
+        }
+        return params.ErrorResult{}, nil
+}
+
+// fetchAllServicesAndUnits returns a map from service name to service
+// and a map from service name to unit name to unit.
+func fetchAllDeployedCharms(st *state.State) (map[string]*charm.URL, error) {
+        deployedCharms := make(map[string]*charm.URL)
+        services, err := st.AllServices()
+        if err != nil {
+                return nil, err
+        }
+        for _, s := range services {
+                url, _ := s.CharmURL()
+                // Record the basic charm information so it can be bulk processed later to
+                // get the available revision numbers from the repo.
+                baseCharm := url.WithRevision(-1)
+                deployedCharms[baseCharm.String()] = baseCharm

[jameinel, 2014/01/16 09:56:16]

This breaks if you have the same charm deployed to two differently named
services, right?

juju deploy mysql mysqlA
juju deploy mysql mysqlB

It may be that WithRevision(-1) will be the same even if mysqlA and mysqlB are
at different revs.

I'd just like to confirm that. Maybe test worthy?

[wallyworld, 2014/01/16 10:11:47]

Yes, that's the intent. See below.
The way this works is that deployedCharms is used to hold the latest revisions
from the charm store, as queried from the db. These latest revisions are then
compared against each service. So mysqlA and B may well have cs:mysql-3 and
cs:mysql-4. deployedCharms might have cs:mysql5 (since that's what the store
has). So the status will compare cs:mysql-3 and cs:mysql-4 to cs:mysql-5 and
present accordingly.

+        }
+        return deployedCharms, nil
+}
+
+// retrieveLatestCharmInfo looks up the charm store to return the charm URLs for the
+// latest revision of the deployed charms.
+func retrieveLatestCharmInfo(deployedCharms map[string]*charm.URL) ([]*charm.URL, error) {
+        var curls []*charm.URL
+        for _, curl := range deployedCharms {
+                if curl.Schema == "local" {
+                        // Version checking for charms from local repositories is not
+                        // currently supported, since we don't yet support passing in
+                        // a path to the local repo. This may change if the need arises.
+                        continue
+                }
+                curls = append(curls, curl)
+        }
+
+        // Do a bulk call to get the revision info for all charms.
+        revInfo, err := charm.Store.Latest(curls...)
+        if err != nil {
+                return nil, log.LoggedErrorf(logger, "finding charm revision info: %v", err)
+        }
+        var latestCurls []*charm.URL
+        for i, info := range revInfo {
+                curl := curls[i]
+                if info.Err == nil {
+                        latestCurls = append(latestCurls, curl.WithRevision(info.Revision))
+                } else {
+                        logger.Errorf("retrieving charm info for %s: %v", curl, info.Err)
+                }
+        }
+        return latestCurls, nil
+}