cmd/jujud: do not change password

state/service.go

 // Copyright 2012, 2013 Canonical Ltd.
 // Licensed under the AGPLv3, see LICENCE file for details.
 
 package state
 
 import (
         stderrors "errors"
         "fmt"
         "labix.org/v2/mgo"
         "labix.org/v2/mgo/bson"
@@ skipping 41 matching lines @@
                 st:        st,
         }
         return svc
 }
 
 // Name returns the service name.
 func (s *Service) Name() string {
         return s.doc.Name
 }
 
-// TAg returns a name identifying the service that is safe to use
+// Tag returns a name identifying the service that is safe to use
 // as a file name.  The returned name will be different from other
-// TAg values returned by any other entities from the same state.
+// Tag values returned by any other entities from the same state.
 func (s *Service) Tag() string {
         return "service-" + s.Name()
 }
 
 // serviceGlobalKey returns the global database key for the service
 // with the given name.
 func serviceGlobalKey(svcName string) string {
         return "s#" + svcName
 }
 
@@ skipping 25 matching lines @@
 func (s *Service) Destroy() (err error) {
         defer utils.ErrorContextf(&err, "cannot destroy service %q", s)
         defer func() {
                 if err == nil {
                         // This is a white lie; the document might actually be removed.
                         s.doc.Life = Dying
                 }
         }()
         svc := &Service{st: s.st, doc: s.doc}
         for i := 0; i < 5; i++ {
-                ops, err := svc.destroyOps()
-                switch {
-                case err == errRefresh:
-                case err == errAlreadyDying:
+                switch ops, err := svc.destroyOps(); err {
+                case errRefresh:
+                case errAlreadyDying:
                         return nil
-                case err != nil:
-                        return err
-                default:
-                        if err := svc.st.runner.Run(ops, "", nil); err != txn.ErrAborted {
+                case nil:
+                        if err := svc.st.runTransaction(ops); err != txn.ErrAborted {
                                 return err
                         }
+                default:
+                        return err
                 }
                 if err := svc.Refresh(); errors.IsNotFoundError(err) {
                         return nil
                 } else if err != nil {
                         return err
                 }
         }
         return ErrExcessiveContention
 }
 
@@ skipping 47 matching lines @@
         // will be caught by virtue of being a remove.
         notLastRefs := D{
                 {"life", Alive},
                 {"relationcount", s.doc.RelationCount},
         }
         // With respect to unit count, a changing value doesn't matter, so long
         // as the count's equality with zero does not change, because all we care
         // about is that *some* unit is, or is not, keeping the service from
         // being removed: the difference between 1 unit and 1000 is irrelevant.
         if s.doc.UnitCount > 0 {
+                ops = append(ops, s.st.newCleanupOp("units", s.doc.Name+"/"))
                 notLastRefs = append(notLastRefs, D{{"unitcount", D{{"$gt", 0}}}}...)
         } else {
                 notLastRefs = append(notLastRefs, D{{"unitcount", 0}}...)
         }
         update := D{{"$set", D{{"life", Dying}}}}
         if removeCount != 0 {
                 decref := D{{"$inc", D{{"relationcount", -removeCount}}}}
                 update = append(update, decref...)
         }
         return append(ops, txn.Op{
@@ skipping 44 matching lines @@
         return s.setExposed(false)
 }
 
 func (s *Service) setExposed(exposed bool) (err error) {
         ops := []txn.Op{{
                 C:      s.st.services.Name,
                 Id:     s.doc.Name,
                 Assert: isAliveDoc,
                 Update: D{{"$set", D{{"exposed", exposed}}}},
         }}
-        if err := s.st.runner.Run(ops, "", nil); err != nil {
+        if err := s.st.runTransaction(ops); err != nil {
                 return fmt.Errorf("cannot set exposed flag for service %q to %v: %v", s, exposed, onAbort(err, errNotAlive))
         }
         s.doc.Exposed = exposed
         return nil
 }
 
 // Charm returns the service's charm and whether units should upgrade to that
 // charm even if they are in an error state.
 func (s *Service) Charm() (ch *Charm, force bool, err error) {
         ch, err = s.st.Charm(s.doc.CharmURL)
@@ skipping 214 matching lines @@
                                 Update: D{{"$set", D{{"forcecharm", force}}}},
                         }}
                 } else {
                         // Change the charm URL.
                         ops, err = s.changeCharmOps(ch, force)
                         if err != nil {
                                 return err
                         }
                 }
 
-                if err := s.st.runner.Run(ops, "", nil); err == nil {
+                if err := s.st.runTransaction(ops); err == nil {
                         s.doc.CharmURL = ch.URL()
                         s.doc.ForceCharm = force
                         return nil
                 } else if err != txn.ErrAborted {
                         return err
                 }
 
                 // If the service is not alive, fail out immediately; otherwise,
                 // data changed underneath us, so retry.
                 if alive, err := isAlive(s.st.services, s.doc.Name); err != nil {
@@ skipping 100 matching lines @@
         return name, ops, nil
 }
 
 // AddUnit adds a new principal unit to the service.
 func (s *Service) AddUnit() (unit *Unit, err error) {
         defer utils.ErrorContextf(&err, "cannot add unit to service %q", s)
         name, ops, err := s.addUnitOps("")
         if err != nil {
                 return nil, err
         }
-        if err := s.st.runner.Run(ops, "", nil); err == txn.ErrAborted {
+        if err := s.st.runTransaction(ops); err == txn.ErrAborted {
                 if alive, err := isAlive(s.st.services, s.doc.Name); err != nil {
                         return nil, err
                 } else if !alive {
                         return nil, fmt.Errorf("service is not alive")
                 }
                 return nil, fmt.Errorf("inconsistent state")
         } else if err != nil {
                 return nil, err
         }
         return s.Unit(name)
@@ skipping 13 matching lines @@
                         Update: D{{"$pull", D{{"subordinates", u.doc.Name}}}},
                 })
         } else if u.doc.MachineId != "" {
                 ops = append(ops, txn.Op{
                         C:      s.st.machines.Name,
                         Id:     u.doc.MachineId,
                         Assert: txn.DocExists,
                         Update: D{{"$pull", D{{"principals", u.doc.Name}}}},
                 })
         }
+        observedFieldsMatch := D{
+                {"charmurl", u.doc.CharmURL},
+                {"machineid", u.doc.MachineId},
+        }
         ops = append(ops, txn.Op{
                 C:      s.st.units.Name,
                 Id:     u.doc.Name,
-                Assert: asserts,
+                Assert: append(observedFieldsMatch, asserts...),
                 Remove: true,
         },
                 removeConstraintsOp(s.st, u.globalKey()),
                 removeStatusOp(s.st, u.globalKey()),
                 annotationRemoveOp(s.st, u.globalKey()),
         )
         if u.doc.CharmURL != nil {
                 decOps, err := settingsDecRefOps(s.st, s.doc.Name, u.doc.CharmURL)
-                if err != nil {
+                if errors.IsNotFoundError(err) {
+                        return nil, errRefresh
+                } else if err != nil {
                         return nil, err
                 }
                 ops = append(ops, decOps...)
         }
         if s.doc.Life == Dying && s.doc.RelationCount == 0 && s.doc.UnitCount == 1 {
                 hasLastRef := D{{"life", Dying}, {"relationcount", 0}, {"unitcount", 1}}
                 return append(ops, s.removeOps(hasLastRef)...), nil
         }
         svcOp := txn.Op{
                 C:      s.st.services.Name,
@@ skipping 114 matching lines @@
                 return errNotAlive
         }
         ops := []txn.Op{
                 {
                         C:      s.st.services.Name,
                         Id:     s.doc.Name,
                         Assert: isAliveDoc,
                 },
                 setConstraintsOp(s.st, s.globalKey(), cons),
         }
-        return onAbort(s.st.runner.Run(ops, "", nil), errNotAlive)
+        return onAbort(s.st.runTransaction(ops), errNotAlive)
 }
 
 // settingsIncRefOp returns an operation that increments the ref count
 // of the service settings identified by serviceName and curl. If
 // canCreate is false, a missing document will be treated as an error;
 // otherwise, it will be created with a ref count of 1.
 func settingsIncRefOp(st *State, serviceName string, curl *charm.URL, canCreate bool) (txn.Op, error) {
         key := serviceSettingsKey(serviceName, curl)
         if count, err := st.settingsrefs.FindId(key).Count(); err != nil {
                 return txn.Op{}, err
@@ skipping 16 matching lines @@
         }, nil
 }
 
 // settingsDecRefOps returns a list of operations that decrement the
 // ref count of the service settings identified by serviceName and
 // curl. If the ref count is set to zero, the appropriate setting and
 // ref count documents will both be deleted.
 func settingsDecRefOps(st *State, serviceName string, curl *charm.URL) ([]txn.Op, error) {
         key := serviceSettingsKey(serviceName, curl)
         var doc settingsRefsDoc
-        if err := st.settingsrefs.FindId(key).One(&doc); err != nil {
+        if err := st.settingsrefs.FindId(key).One(&doc); err == mgo.ErrNotFound {
+                return nil, errors.NotFoundf("service %q settings for charm %q", serviceName, curl)
+        } else if err != nil {
                 return nil, err
         }
         if doc.RefCount == 1 {
                 return []txn.Op{{
                         C:      st.settingsrefs.Name,
                         Id:     key,
                         Assert: D{{"refcount", 1}},
                         Remove: true,
                 }, {
                         C:      st.settings.Name,
@@ skipping 20 matching lines @@
 //
 // Note: We're not using the settingsDoc for this because changing
 // just the ref count is not considered a change worth reporting
 // to watchers and firing config-changed hooks.
 //
 // There is and implicit _id field here, which mongo creates, which is
 // always the same as the settingsDoc's id.
 type settingsRefsDoc struct {
         RefCount int
 }