environs/cloudinit: use --initial-password

environs/ec2/ec2.go

 package ec2
 
 import (
         "fmt"
         "io/ioutil"
         "launchpad.net/goamz/aws"
         "launchpad.net/goamz/ec2"
         "launchpad.net/goamz/s3"
         "launchpad.net/juju-core/environs"
         "launchpad.net/juju-core/environs/cloudinit"
@@ skipping 538 matching lines @@
                         err = nil
                 }
                 if err != nil && firstErr == nil {
                         firstErr = err
                 }
         }
         return firstErr
 }
 
 func (e *environ) machineGroupName(machineId int) string {
-        return fmt.Sprintf("%s-%d", e.groupName(), machineId)
+        if e.Config().FirewallMode() == config.FwDefault {
+                return fmt.Sprintf("%s-%d", e.groupName(), machineId)
+        }
+        return fmt.Sprintf("%s-global", e.groupName())
 }
 
 func (e *environ) groupName() string {
         return "juju-" + e.name
 }
 
 func (inst *instance) OpenPorts(machineId int, ports []state.Port) error {
         if len(ports) == 0 {
                 return nil
         }
         // Give permissions for anyone to access the given ports.
-        // TODO(mue) Choose group depending on inst.e.Config().FirewallMode().
         ipPerms := portsToIPPerms(ports)
         g := ec2.SecurityGroup{Name: inst.e.machineGroupName(machineId)}
         _, err := inst.e.ec2().AuthorizeSecurityGroup(g, ipPerms)
         if err != nil && ec2ErrCode(err) == "InvalidPermission.Duplicate" {
                 if len(ports) == 1 {
                         return nil
                 }
                 // If there's more than one port and we get a duplicate error,
                 // then we go through authorizing each port individually,
                 // otherwise the ports that were *not* duplicates will have
@@ skipping 13 matching lines @@
         return nil
 }
 
 func (inst *instance) ClosePorts(machineId int, ports []state.Port) error {
         if len(ports) == 0 {
                 return nil
         }
         // Revoke permissions for anyone to access the given ports.
         // Note that ec2 allows the revocation of permissions that aren't
         // granted, so this is naturally idempotent.
-        // TODO(mue) Choose group depending on inst.e.Config().FirewallMode().
         g := ec2.SecurityGroup{Name: inst.e.machineGroupName(machineId)}
         _, err := inst.e.ec2().RevokeSecurityGroup(g, portsToIPPerms(ports))
         if err != nil {
                 return fmt.Errorf("cannot close ports: %v", err)
         }
         log.Printf("environs/ec2: closed ports in security group %s: %v", g.Name, ports)
         return nil
 }
 
 func portsToIPPerms(ports []state.Port) []ec2.IPPerm {
         ipPerms := make([]ec2.IPPerm, len(ports))
         for i, p := range ports {
                 ipPerms[i] = ec2.IPPerm{
                         Protocol:  p.Protocol,
                         FromPort:  p.Number,
                         ToPort:    p.Number,
                         SourceIPs: []string{"0.0.0.0/0"},
                 }
         }
         return ipPerms
 }
 
 func (inst *instance) Ports(machineId int) (ports []state.Port, err error) {
-        // TODO(mue) Choose group depending on inst.e.Config().FirewallMode().
         g := ec2.SecurityGroup{Name: inst.e.machineGroupName(machineId)}
         resp, err := inst.e.ec2().SecurityGroups([]ec2.SecurityGroup{g}, nil)
         if err != nil {
                 return nil, err
         }
         if len(resp.Groups) != 1 {
                 return nil, fmt.Errorf("expected one security group, got %d", len(resp.Groups))
         }
         for _, p := range resp.Groups[0].IPPerms {
                 if len(p.SourceIPs) != 1 {
@@ skipping 43 matching lines @@
                         {
                                 Protocol:     "icmp",
                                 FromPort:     -1,
                                 ToPort:       -1,
                                 SourceGroups: sourceGroups,
                         },
                 })
         if err != nil {
                 return nil, err
         }
-        // TODO(mue) Ensure machine group only if e.Config().FirewallMode()
-        // is config.FwDefault.
         jujuMachineGroup, err := e.ensureGroup(e.machineGroupName(machineId), nil)
         if err != nil {
                 return nil, err
         }
         return []ec2.SecurityGroup{jujuGroup, jujuMachineGroup}, nil
 }
 
 // zeroGroup holds the zero security group.
 var zeroGroup ec2.SecurityGroup
 
@@ skipping 143 matching lines @@
                 }
                 var data []byte
                 data, err = ioutil.ReadAll(resp.Body)
                 if err != nil {
                         continue
                 }
                 return strings.TrimSpace(string(data)), nil
         }
         return
 }