cmd/jujud: do not change password

state/relationunit.go

 // Copyright 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/txn"
@@ skipping 62 matching lines @@
                 return err
         }
         if count, err := ru.st.relationScopes.FindId(ruKey).Count(); err != nil {
                 return err
         } else if count != 0 {
                 return nil
         }
 
         // Collect the operations necessary to enter scope, as follows:
         // * Check unit and relation state, and incref the relation.
+        // * TODO(fwereade): check unit status == params.StatusStarted (this
+        //   breaks a bunch of tests in a boring but noisy-to-fix way, and is
+        //   being saved for a followup).
         unitName, relationKey := ru.unit.doc.Name, ru.relation.doc.Key
         ops := []txn.Op{{
                 C:      ru.st.units.Name,
                 Id:     unitName,
                 Assert: isAliveDoc,
         }, {
                 C:      ru.st.relations.Name,
                 Id:     relationKey,
                 Assert: isAliveDoc,
                 Update: D{{"$inc", D{{"unitcount", 1}}}},
@@ skipping 28 matching lines @@
         // * If the unit should have a subordinate, and does not, create it.
         var existingSubName string
         if subOps, subName, err := ru.subordinateOps(); err != nil {
                 return err
         } else {
                 existingSubName = subName
                 ops = append(ops, subOps...)
         }
 
         // Now run the complete transaction, or figure out why we can't.
-        if err := ru.st.runner.Run(ops, "", nil); err != txn.ErrAborted {
+        if err := ru.st.runTransaction(ops); err != txn.ErrAborted {
                 return err
         }
         if count, err := ru.st.relationScopes.FindId(ruKey).Count(); err != nil {
                 return err
         } else if count != 0 {
                 // The scope document exists, so we're actually already in scope.
                 return nil
         }
 
         // The relation or unit might no longer be Alive. (Note that there is no
@@ skipping 135 matching lines @@
                                 Assert: D{{"unitcount", D{{"$gt", 1}}}},
                                 Update: D{{"$inc", D{{"unitcount", -1}}}},
                         })
                 } else {
                         relOps, err := ru.relation.removeOps("", ru.unit)
                         if err != nil {
                                 return err
                         }
                         ops = append(ops, relOps...)
                 }
-                if err = ru.st.runner.Run(ops, "", nil); err != txn.ErrAborted {
+                if err = ru.st.runTransaction(ops); err != txn.ErrAborted {
                         if err != nil {
                                 return fmt.Errorf("cannot leave scope for %s: %v", desc, err)
                         }
                         return err
                 }
                 if err := ru.relation.Refresh(); errors.IsNotFoundError(err) {
                         return nil
                 } else if err != nil {
                         return err
                 }
@@ skipping 59 matching lines @@
 // relationScopeDoc represents a unit which is in a relation scope.
 // The relation, container, role, and unit are all encoded in the key.
 type relationScopeDoc struct {
         Key string `bson:"_id"`
 }
 
 func (d *relationScopeDoc) unitName() string {
         parts := strings.Split(d.Key, "#")
         return parts[len(parts)-1]
 }