cmd/jujud: do not change password

worker/firewaller/firewaller.go

 // Copyright 2012, 2013 Canonical Ltd.
 // Licensed under the AGPLv3, see LICENCE file for details.
 
 package firewaller
 
 import (
         "fmt"
         "launchpad.net/juju-core/environs"
         "launchpad.net/juju-core/environs/config"
         "launchpad.net/juju-core/errors"
+        "launchpad.net/juju-core/instance"
         "launchpad.net/juju-core/log"
         "launchpad.net/juju-core/state"
-        "launchpad.net/juju-core/state/api/params"
         "launchpad.net/juju-core/state/watcher"
         "launchpad.net/juju-core/worker"
         "launchpad.net/tomb"
 )
 
 // Firewaller watches the state for ports opened or closed
 // and reflects those changes onto the backing environment.
 type Firewaller struct {
         tomb            tomb.Tomb
         st              *state.State
         environ         environs.Environ
         environWatcher  *state.EnvironConfigWatcher
         machinesWatcher *state.LifecycleWatcher
         machineds       map[string]*machineData
         unitsChange     chan *unitsChange
         unitds          map[string]*unitData
         portsChange     chan *portsChange
         serviceds       map[string]*serviceData
         exposedChange   chan *exposedChange
         globalMode      bool
-        globalPortRef   map[params.Port]int
+        globalPortRef   map[instance.Port]int
 }
 
 // NewFirewaller returns a new Firewaller.
 func NewFirewaller(st *state.State) *Firewaller {
         fw := &Firewaller{
                 st:              st,
                 environWatcher:  st.WatchEnvironConfig(),
                 machinesWatcher: st.WatchEnvironMachines(),
                 machineds:       make(map[string]*machineData),
                 unitsChange:     make(chan *unitsChange),
@@ skipping 14 matching lines @@
 
         var err error
         var reconciled bool
 
         fw.environ, err = worker.WaitForEnviron(fw.environWatcher, fw.tomb.Dying())
         if err != nil {
                 return err
         }
         if fw.environ.Config().FirewallMode() == config.FwGlobal {
                 fw.globalMode = true
-                fw.globalPortRef = make(map[params.Port]int)
+                fw.globalPortRef = make(map[instance.Port]int)
         }
         for {
                 select {
                 case <-fw.tomb.Dying():
                         return tomb.ErrDying
                 case change, ok := <-fw.environWatcher.Changes():
                         if !ok {
                                 return watcher.MustErr(fw.environWatcher)
                         }
                         if err := fw.environ.SetConfig(change); err != nil {
@@ skipping 48 matching lines @@
         }
 }
 
 // startMachine creates a new data value for tracking details of the
 // machine and starts watching the machine for units added or removed.
 func (fw *Firewaller) startMachine(id string) error {
         machined := &machineData{
                 fw:     fw,
                 id:     id,
                 unitds: make(map[string]*unitData),
-                ports:  make([]params.Port, 0),
+                ports:  make([]instance.Port, 0),
         }
         m, err := machined.machine()
         if errors.IsNotFoundError(err) {
                 return nil
         } else if err != nil {
                 return fmt.Errorf("worker/firewaller: cannot watch machine units: %v", err)
         }
         unitw := m.WatchUnits()
         select {
         case <-fw.tomb.Dying():
@@ skipping 38 matching lines @@
         if fw.serviceds[serviceName] == nil {
                 err := fw.startService(service)
                 if err != nil {
                         delete(fw.unitds, unitName)
                         return err
                 }
         }
         unitd.serviced = fw.serviceds[serviceName]
         unitd.serviced.unitds[unitName] = unitd
 
-        ports := make([]params.Port, len(unitd.ports))
+        ports := make([]instance.Port, len(unitd.ports))
         copy(ports, unitd.ports)
 
         go unitd.watchLoop(ports)
         return nil
 }
 
 // startService creates a new data value for tracking details of the
 // service and starts watching the service for exposure changes.
 func (fw *Firewaller) startService(service *state.Service) error {
         serviced := &serviceData{
                 fw:      fw,
                 service: service,
                 exposed: service.IsExposed(),
                 unitds:  make(map[string]*unitData),
         }
         fw.serviceds[service.Name()] = serviced
         go serviced.watchLoop(serviced.exposed)
         return nil
 }
 
 // reconcileGlobal compares the initially started watcher for machines,
 // units and services with the opened and closed ports globally and
 // opens and closes the appropriate ports for the whole environment.
 func (fw *Firewaller) reconcileGlobal() error {
         initialPorts, err := fw.environ.Ports()
         if err != nil {
                 return err
         }
-        collector := make(map[params.Port]bool)
+        collector := make(map[instance.Port]bool)
         for _, unitd := range fw.unitds {
                 if unitd.serviced.exposed {
                         for _, port := range unitd.ports {
                                 collector[port] = true
                         }
                 }
         }
-        wantedPorts := []params.Port{}
+        wantedPorts := []instance.Port{}
         for port := range collector {
                 wantedPorts = append(wantedPorts, port)
         }
         // Check which ports to open or to close.
         toOpen := diff(wantedPorts, initialPorts)
         toClose := diff(initialPorts, wantedPorts)
         if len(toOpen) > 0 {
                 log.Infof("worker/firewaller: opening global ports %v", toOpen)
                 if err := fw.environ.OpenPorts(toOpen); err != nil {
                         return err
@@ skipping 21 matching lines @@
                                 return err
                         }
                         continue
                 } else if err != nil {
                         return err
                 }
                 instanceId, ok := m.InstanceId()
                 if !ok {
                         return errors.NotFoundf("instance id for %v", m)
                 }
-                instances, err := fw.environ.Instances([]state.InstanceId{instanceId})
+                instances, err := fw.environ.Instances([]instance.Id{instanceId})
                 if err == environs.ErrNoInstances {
                         return nil
                 } else if err != nil {
                         return err
                 }
                 initialPorts, err := instances[0].Ports(machined.id)
                 if err != nil {
                         return err
                 }
                 // Check which ports to open or to close.
@@ skipping 70 matching lines @@
                 if err := fw.flushMachine(machined); err != nil {
                         return err
                 }
         }
         return nil
 }
 
 // flushMachine opens and closes ports for the passed machine.
 func (fw *Firewaller) flushMachine(machined *machineData) error {
         // Gather ports to open and close.
-        ports := map[params.Port]bool{}
+        ports := map[instance.Port]bool{}
         for _, unitd := range machined.unitds {
                 if unitd.serviced.exposed {
                         for _, port := range unitd.ports {
                                 ports[port] = true
                         }
                 }
         }
-        want := []params.Port{}
+        want := []instance.Port{}
         for port := range ports {
                 want = append(want, port)
         }
         toOpen := diff(want, machined.ports)
         toClose := diff(machined.ports, want)
         machined.ports = want
         if fw.globalMode {
                 return fw.flushGlobalPorts(toOpen, toClose)
         }
         return fw.flushInstancePorts(machined, toOpen, toClose)
 }
 
 // flushGlobalPorts opens and closes global ports in the environment.
 // It keeps a reference count for ports so that only 0-to-1 and 1-to-0 events
 // modify the environment.
-func (fw *Firewaller) flushGlobalPorts(rawOpen, rawClose []params.Port) error {
+func (fw *Firewaller) flushGlobalPorts(rawOpen, rawClose []instance.Port) error {
         // Filter which ports are really to open or close.
-        var toOpen, toClose []params.Port
+        var toOpen, toClose []instance.Port
         for _, port := range rawOpen {
                 if fw.globalPortRef[port] == 0 {
                         toOpen = append(toOpen, port)
                 }
                 fw.globalPortRef[port]++
         }
         for _, port := range rawClose {
                 fw.globalPortRef[port]--
                 if fw.globalPortRef[port] == 0 {
                         toClose = append(toClose, port)
@@ skipping 14 matching lines @@
                         // TODO(mue) Add local retry logic.
                         return err
                 }
                 state.SortPorts(toClose)
                 log.Infof("worker/firewaller: closed ports %v in environment", toClose)
         }
         return nil
 }
 
 // flushGlobalPorts opens and closes ports global on the machine.
-func (fw *Firewaller) flushInstancePorts(machined *machineData, toOpen, toClose []params.Port) error {
+func (fw *Firewaller) flushInstancePorts(machined *machineData, toOpen, toClose []instance.Port) error {
         // If there's nothing to do, do nothing.
         // This is important because when a machine is first created,
         // it will have no instance id but also no open ports -
         // InstanceId will fail but we don't care.
         if len(toOpen) == 0 && len(toClose) == 0 {
                 return nil
         }
         m, err := machined.machine()
         if errors.IsNotFoundError(err) {
                 return nil
         }
         if err != nil {
                 return err
         }
         instanceId, ok := m.InstanceId()
         if !ok {
                 return errors.NotFoundf("instance id for %v", m)
         }
-        instances, err := fw.environ.Instances([]state.InstanceId{instanceId})
+        instances, err := fw.environ.Instances([]instance.Id{instanceId})
         if err != nil {
                 return err
         }
         // Open and close the ports.
         if len(toOpen) > 0 {
                 if err := instances[0].OpenPorts(machined.id, toOpen); err != nil {
                         // TODO(mue) Add local retry logic.
                         return err
                 }
                 state.SortPorts(toOpen)
@@ skipping 117 matching lines @@
         machined *machineData
         units    []string
 }
 
 // machineData holds machine details and watches units added or removed.
 type machineData struct {
         tomb   tomb.Tomb
         fw     *Firewaller
         id     string
         unitds map[string]*unitData
-        ports  []params.Port
+        ports  []instance.Port
 }
 
 func (md *machineData) machine() (*state.Machine, error) {
         return md.fw.st.Machine(md.id)
 }
 
 // watchLoop watches the machine for units added or removed.
 func (md *machineData) watchLoop(unitw *state.MachineUnitsWatcher) {
         defer md.tomb.Done()
         defer watcher.Stop(unitw, &md.tomb)
@@ skipping 20 matching lines @@
 
 // stopWatch stops the machine watching.
 func (md *machineData) Stop() error {
         md.tomb.Kill(nil)
         return md.tomb.Wait()
 }
 
 // portsChange contains the changed ports for one specific unit.
 type portsChange struct {
         unitd *unitData
-        ports []params.Port
+        ports []instance.Port
 }
 
 // unitData holds unit details and watches port changes.
 type unitData struct {
         tomb     tomb.Tomb
         fw       *Firewaller
         unit     *state.Unit
         serviced *serviceData
         machined *machineData
-        ports    []params.Port
+        ports    []instance.Port
 }
 
 // watchLoop watches the unit for port changes.
-func (ud *unitData) watchLoop(latestPorts []params.Port) {
+func (ud *unitData) watchLoop(latestPorts []instance.Port) {
         defer ud.tomb.Done()
         w := ud.unit.Watch()
         defer watcher.Stop(w, &ud.tomb)
         for {
                 select {
                 case <-ud.tomb.Dying():
                         return
                 case _, ok := <-w.Changes():
                         if !ok {
                                 ud.fw.tomb.Kill(watcher.MustErr(w))
@@ skipping 14 matching lines @@
                         case ud.fw.portsChange <- &portsChange{ud, change}:
                         case <-ud.tomb.Dying():
                                 return
                         }
                 }
         }
 }
 
 // samePorts returns whether old and new contain the same set of ports.
 // Both old and new must be sorted.
-func samePorts(old, new []params.Port) bool {
+func samePorts(old, new []instance.Port) bool {
         if len(old) != len(new) {
                 return false
         }
         for i, p := range old {
                 if new[i] != p {
                         return false
                 }
         }
         return true
 }
@@ skipping 53 matching lines @@
         }
 }
 
 // Stop stops the service watching.
 func (sd *serviceData) Stop() error {
         sd.tomb.Kill(nil)
         return sd.tomb.Wait()
 }
 
 // diff returns all the ports that exist in A but not B.
-func diff(A, B []params.Port) (missing []params.Port) {
+func diff(A, B []instance.Port) (missing []instance.Port) {
 next:
         for _, a := range A {
                 for _, b := range B {
                         if a == b {
                                 continue next
                         }
                 }
                 missing = append(missing, a)
         }
         return
 }