func (s *backingSettings) updated(st *State, store *multiwatcher.Store, id interface{}) error {
parentId, url, ok := backingEntityIdForSettingsKey(id.(string))
if !ok {
return nil
}
info0 := store.Get(parentId)
switch info := info0.(type) {
case nil:
// The parent info doesn't exist. Ignore the status until it does.
return nil
case *params.ServiceInfo:
// If we're seeing settings for the service with a different
// charm URL, we ignore them - we will fetch
// them again when the service charm changes.
// By doing this we make sure that the settings in the
// ServiceInfo are always consistent with the charm URL.
if info.CharmURL != url {
break
}
newInfo := *info
cleanSettingsMap(*s)
newInfo.Config = *s
info0 = &newInfo
default:
return nil
}
store.Update(info0)
return nil
}
func (svc *backingMachine) removed(st *State, store *multiwatcher.Store, id interface{}) error {
store.Remove(params.EntityId{
Kind: "machine",
Id: id,
})
return nil
}
func (s *backingStatus) updated(st *State, store *multiwatcher.Store, id interface{}) error {
parentId, ok := backingEntityIdForGlobalKey(id.(string))
if !ok {
return nil
}
info0 := store.Get(parentId)
switch info := info0.(type) {
case nil:
// The parent info doesn't exist. Ignore the status until it does.
return nil
case *params.UnitInfo:
newInfo := *info
newInfo.Status = s.Status
newInfo.StatusInfo = s.StatusInfo
newInfo.StatusData = s.StatusData
info0 = &newInfo
case *params.MachineInfo:
newInfo := *info
newInfo.Status = s.Status
newInfo.StatusInfo = s.StatusInfo
newInfo.StatusData = s.StatusData
info0 = &newInfo
default:
panic(fmt.Errorf("status for unexpected entity with id %q; type %T", id, info))
}
store.Update(info0)
return nil
}
func (a *backingAnnotation) updated(st *State, store *multiwatcher.Store, id interface{}) error {
info := ¶ms.AnnotationInfo{
Tag: a.Tag,
Annotations: a.Annotations,
}
store.Update(info)
return nil
}
func (svc *backingAnnotation) removed(st *State, store *multiwatcher.Store, id interface{}) error {
tag, ok := tagForGlobalKey(id.(string))
if !ok {
panic(fmt.Errorf("unknown global key %q in state", id))
}
store.Remove(params.EntityId{
Kind: "annotation",
Id: tag,
})
return nil
}
func (svc *backingService) updated(st *State, store *multiwatcher.Store, id interface{}) error {
if svc.CharmURL == nil {
return errors.Errorf("charm url is nil")
}
env, err := st.Environment()
if err != nil {
return errors.Trace(err)
}
info := ¶ms.ServiceInfo{
Name: svc.Name,
Exposed: svc.Exposed,
CharmURL: svc.CharmURL.String(),
OwnerTag: svc.fixOwnerTag(env),
Life: params.Life(svc.Life.String()),
MinUnits: svc.MinUnits,
}
oldInfo := store.Get(info.EntityId())
needConfig := false
if oldInfo == nil {
// We're adding the entry for the first time,
// so fetch the associated child documents.
c, err := readConstraints(st, serviceGlobalKey(svc.Name))
if err != nil {
return err
}
info.Constraints = c
needConfig = true
} else {
// The entry already exists, so preserve the current status.
oldInfo := oldInfo.(*params.ServiceInfo)
info.Constraints = oldInfo.Constraints
if info.CharmURL == oldInfo.CharmURL {
// The charm URL remains the same - we can continue to
// use the same config settings.
info.Config = oldInfo.Config
} else {
// The charm URL has changed - we need to fetch the
// settings from the new charm's settings doc.
needConfig = true
}
}
if needConfig {
var err error
info.Config, _, err = readSettingsDoc(st, serviceSettingsKey(svc.Name, svc.CharmURL))
if err != nil {
return err
}
}
store.Update(info)
return nil
}
func (r *backingRelation) updated(st *State, store *multiwatcher.Store, id interface{}) error {
eps := make([]params.Endpoint, len(r.Endpoints))
for i, ep := range r.Endpoints {
eps[i] = params.Endpoint{
ServiceName: ep.ServiceName,
Relation: ep.Relation,
}
}
info := ¶ms.RelationInfo{
Key: r.Key,
Id: r.Id,
Endpoints: eps,
}
store.Update(info)
return nil
}
func (m *backingMachine) updated(st *State, store *multiwatcher.Store, id interface{}) error {
info := ¶ms.MachineInfo{
Id: m.Id,
Life: params.Life(m.Life.String()),
Series: m.Series,
Jobs: paramsJobsFromJobs(m.Jobs),
Addresses: mergedAddresses(m.MachineAddresses, m.Addresses),
SupportedContainers: m.SupportedContainers,
SupportedContainersKnown: m.SupportedContainersKnown,
}
oldInfo := store.Get(info.EntityId())
if oldInfo == nil {
// We're adding the entry for the first time,
// so fetch the associated machine status.
sdoc, err := getStatus(st, machineGlobalKey(m.Id))
if err != nil {
return err
}
info.Status = sdoc.Status
info.StatusInfo = sdoc.StatusInfo
} else {
// The entry already exists, so preserve the current status and
// instance data.
oldInfo := oldInfo.(*params.MachineInfo)
info.Status = oldInfo.Status
info.StatusInfo = oldInfo.StatusInfo
info.InstanceId = oldInfo.InstanceId
info.HardwareCharacteristics = oldInfo.HardwareCharacteristics
}
// If the machine is been provisioned, fetch the instance id as required,
// and set instance id and hardware characteristics.
if m.Nonce != "" && info.InstanceId == "" {
instanceData, err := getInstanceData(st, m.Id)
if err == nil {
info.InstanceId = string(instanceData.InstanceId)
info.HardwareCharacteristics = hardwareCharacteristics(instanceData)
} else if !errors.IsNotFound(err) {
return err
}
}
store.Update(info)
return nil
}
func (s *backingConstraints) updated(st *State, store *multiwatcher.Store, id interface{}) error {
parentId, ok := backingEntityIdForGlobalKey(id.(string))
if !ok {
return nil
}
info0 := store.Get(parentId)
switch info := info0.(type) {
case nil:
// The parent info doesn't exist. Ignore the status until it does.
return nil
case *params.UnitInfo, *params.MachineInfo:
// We don't (yet) publish unit or machine constraints.
return nil
case *params.ServiceInfo:
newInfo := *info
newInfo.Constraints = constraintsDoc(*s).value()
info0 = &newInfo
default:
panic(fmt.Errorf("status for unexpected entity with id %q; type %T", id, info))
}
store.Update(info0)
return nil
}
func (u *backingUnit) updated(st *State, store *multiwatcher.Store, id interface{}) error {
info := ¶ms.UnitInfo{
Name: u.Name,
Service: u.Service,
Series: u.Series,
MachineId: u.MachineId,
Ports: u.Ports,
}
if u.CharmURL != nil {
info.CharmURL = u.CharmURL.String()
}
oldInfo := store.Get(info.EntityId())
if oldInfo == nil {
// We're adding the entry for the first time,
// so fetch the associated unit status.
sdoc, err := getStatus(st, unitGlobalKey(u.Name))
if err != nil {
return err
}
info.Status = sdoc.Status
info.StatusInfo = sdoc.StatusInfo
} else {
// The entry already exists, so preserve the current status.
oldInfo := oldInfo.(*params.UnitInfo)
info.Status = oldInfo.Status
info.StatusInfo = oldInfo.StatusInfo
}
publicAddress, privateAddress, err := getUnitAddresses(st, u.Name)
if err != nil {
return err
}
info.PublicAddress = publicAddress
info.PrivateAddress = privateAddress
store.Update(info)
return nil
}