providers/ec2: support VPC

juju/providers/ec2/tests/common.py

 
 from twisted.internet.defer import fail, succeed, inlineCallbacks, returnValue
 
 from txaws.s3.client import S3Client
 from txaws.s3.exception import S3Error
 from txaws.ec2.client import EC2Client
 from txaws.ec2.exception import EC2Error
 from txaws.ec2.model import Instance, Reservation, SecurityGroup
 
 from juju.lib import serializer
@@ skipping 31 matching lines @@
         """Return the ec2 machine provider.
 
         This should only be invoked after mocker is in replay mode so the
         AWS service class will be appropriately replaced by the mock.
         """
         return MachineProvider(self.env_name, self.get_config())
 
     def get_instance(self,
                      instance_id, state="running", machine_id=42, **kwargs):
         groups = kwargs.pop("groups",
-                            ["juju-%s" % self.env_name,
-                             "juju-%s-%s" % (self.env_name, machine_id)])
+                            [("sg-a1a1a1", "juju-%s" % self.env_name),
+                             ("sg-b2b2b2", "juju-%s-%s" % (self.env_name, machine_id))])
         reservation = Reservation("x", "y", groups=groups)
         return Instance(instance_id, state, reservation=reservation, **kwargs)
 
     def assert_machine(self, machine, instance_id, dns_name):
         self.assertTrue(isinstance(machine, EC2ProviderMachine))
         self.assertEquals(machine.instance_id, instance_id)
         self.assertEquals(machine.dns_name, dns_name)
 
     def get_ec2_error(self, entity_id,
                       format="The instance ID %r does not exist",
@@ skipping 37 matching lines @@
         get_public_key(MATCH(match_config))
         self.mocker.result("zebra")
 
         get_ami_args = get_ami_args or (
             "splendid", "amd64", "us-east-1", False, False)
         get_ami = self.mocker.replace(
             "juju.providers.ec2.utils.get_current_ami")
         get_ami(*get_ami_args)
         self.mocker.result(succeed(ami_name))
 
-    def _mock_create_group(self):
+    def _mock_create_group(self, vpc_id=None):
         group_name = "juju-%s" % self.env_name
         self.ec2.create_security_group(
-            group_name, "juju group for %s" % self.env_name)
-        self.mocker.result(succeed(True))
+            group_name, "juju group for %s" % self.env_name,
+            vpc_id=vpc_id)
+        self.mocker.result(succeed("sg-a1a1a1a1"))
 
         self.ec2.authorize_security_group(
-            group_name, ip_protocol="tcp", from_port="22",
+            group_id="sg-a1a1a1a1", ip_protocol="tcp", from_port="22",
             to_port="22", cidr_ip="0.0.0.0/0")
         self.mocker.result(succeed([self.env_name]))
 
         self.ec2.describe_security_groups(group_name)
         self.mocker.result(succeed(
-            [SecurityGroup(group_name, "", owner_id="123")]))
+            [SecurityGroup("sg-a1a1a1a1", group_name, "", owner_id="123")]))
 
         self.ec2.authorize_security_group(
-            group_name, source_group_name=group_name,
+            group_id="sg-a1a1a1a1", source_group_name=group_name,
             source_group_owner_id="123")
         self.mocker.result(succeed(True))
 
-    def _mock_create_machine_group(self, machine_id):
+    def _mock_create_machine_group(self, machine_id, vpc_id=None):
         machine_group_name = "juju-%s-%s" % (self.env_name, machine_id)
         self.ec2.create_security_group(
             machine_group_name, "juju group for %s machine %s" % (
-                self.env_name, machine_id))
-        self.mocker.result(succeed(True))
+                self.env_name, machine_id), vpc_id=vpc_id)
+        self.mocker.result(succeed("sg-b2b2b2b2"))
 
     def _mock_get_zookeeper_hosts(self, hosts=None):
         """
         Try to encapsulate a variety of behaviors here..
 
         if hosts is None, a default host is used.
         if hosts is False, no s3 state is returned
         if hosts are passed as a list of instances, they
            are returned.
         """
 
         if hosts is None:
             hosts = [self.get_instance(
-                "i-es-zoo", private_dns_name="es.example.internal")]
+                "i-es-zoo", private_dns_name="es.example.internal", private_ip_address="1.1.1.1")]
 
         self.s3.get_object(self.env_name, "provider-state")
         if hosts is False:
             error = S3Error("<error/>", 404)
             error.errors = [{"Code": "NoSuchKey"}]
             self.mocker.result(fail(error))
             return
 
         state = serializer.dump({
             "zookeeper-instances":
@@ skipping 39 matching lines @@
 
 class Observed(object):
     """Minimal wrapper just to ensure :method:`add` returns a `Deferred`."""
 
     def __init__(self):
         self.items = set()
 
     def add(self, item):
         self.items.add(item)
         return succeed(True)