// retrieveLatestCharmInfo looks up the charm store to return the charm URLs for the
// latest revision of the deployed charms.
func retrieveLatestCharmInfo(st *state.State) ([]latestCharmInfo, error) {
// First get the uuid for the environment to use when querying the charm store.
env, err := st.Model()
if err != nil {
return nil, err
}
services, err := st.AllServices()
if err != nil {
return nil, err
}
client, err := NewCharmStoreClient(st)
if err != nil {
return nil, errors.Trace(err)
}
var charms []charmstore.CharmID
var resultsIndexedServices []*state.Service
for _, service := range services {
curl, _ := service.CharmURL()
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
}
cid := charmstore.CharmID{
URL: curl,
Channel: service.Channel(),
}
charms = append(charms, cid)
resultsIndexedServices = append(resultsIndexedServices, service)
}
results, err := charmstore.LatestCharmInfo(client, charms, env.UUID())
if err != nil {
return nil, err
}
var latest []latestCharmInfo
for i, result := range results {
if result.Error != nil {
logger.Errorf("retrieving charm info for %s: %v", charms[i].URL, result.Error)
continue
}
service := resultsIndexedServices[i]
latest = append(latest, latestCharmInfo{
CharmInfo: result.CharmInfo,
service: service,
})
}
return latest, nil
}
// fetchAllDeployedCharms 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
}
return deployedCharms, nil
}
// fetchAllServicesAndUnits returns a map from service name to service,
// a map from service name to unit name to unit, and a map from base charm URL to latest URL.
func fetchAllServicesAndUnits(
st *state.State, unitMatcher unitMatcher) (
map[string]*state.Service, map[string]map[string]*state.Unit, map[charm.URL]string, error) {
svcMap := make(map[string]*state.Service)
unitMap := make(map[string]map[string]*state.Unit)
latestCharms := make(map[charm.URL]string)
services, err := st.AllServices()
if err != nil {
return nil, nil, nil, err
}
for _, s := range services {
units, err := s.AllUnits()
if err != nil {
return nil, nil, nil, err
}
svcUnitMap := make(map[string]*state.Unit)
for _, u := range units {
if !unitMatcher.matchUnit(u) {
continue
}
svcUnitMap[u.Name()] = u
}
if unitMatcher.matchesAny() || len(svcUnitMap) > 0 {
unitMap[s.Name()] = svcUnitMap
svcMap[s.Name()] = s
// Record the base URL for the service's charm so that
// the latest store revision can be looked up.
charmURL, _ := s.CharmURL()
if charmURL.Schema == "cs" {
latestCharms[*charmURL.WithRevision(-1)] = ""
}
}
}
for baseURL, _ := range latestCharms {
ch, err := st.LatestPlaceholderCharm(&baseURL)
if errors.IsNotFound(err) {
continue
}
if err != nil {
return nil, nil, nil, err
}
latestCharms[baseURL] = ch.String()
}
return svcMap, unitMap, latestCharms, nil
}