adding ability to delete elb listeners

moto/elb/models.py

@@ -12,10 +12,11 @@ class FakeHealthCheck(object):
 
 
 class FakeListener(object):
-    def __init__(self, load_balancer_port, instance_port, protocol):
+    def __init__(self, load_balancer_port, instance_port, protocol, ssl_certificate_id):
         self.load_balancer_port = load_balancer_port
         self.instance_port = instance_port
         self.protocol = protocol.upper()
+        self.ssl_certificate_id = ssl_certificate_id
 
 
 class FakeLoadBalancer(object):
@@ -25,11 +26,13 @@ class FakeLoadBalancer(object):
         self.instance_ids = []
         self.zones = zones
         self.listeners = []
-        for protocol, lb_port, instance_port in ports:
+
+        for protocol, lb_port, instance_port, ssl_certificate_id in ports:
             listener = FakeListener(
                 protocol=protocol,
                 load_balancer_port=lb_port,
                 instance_port=instance_port,
+                ssl_certificate_id=ssl_certificate_id
             )
             self.listeners.append(listener)
 
@@ -63,6 +66,18 @@ class ELBBackend(BaseBackend):
         self.load_balancers[name] = new_load_balancer
         return new_load_balancer
 
+    def create_load_balancer_listeners(self, name, ports):
+        balancer = self.load_balancers.get(name, None)
+        if balancer:
+            for protocol, lb_port, instance_port, ssl_certificate_id in ports:
+                for listener in balancer.listeners:
+                    if lb_port == listener.load_balancer_port:
+                        break
+                else:
+                    balancer.listeners.append(FakeListener(lb_port, instance_port, protocol, ssl_certificate_id))
+
+        return balancer
+
     def describe_load_balancers(self, names):
         balancers = self.load_balancers.values()
         if names:
@@ -70,6 +85,20 @@ class ELBBackend(BaseBackend):
         else:
             return balancers
 
+    def delete_load_balancer_listeners(self, name, ports):
+        balancer = self.load_balancers.get(name, None)
+        listeners = []
+        if balancer:
+            for lb_port in ports:
+                for listener in balancer.listeners:
+                    if lb_port == listener.load_balancer_port:
+                        continue
+                    else:
+                        listeners.append(listener)
+
+        balancer.listeners = listeners
+        return balancer
+
     def delete_load_balancer(self, load_balancer_name):
         self.load_balancers.pop(load_balancer_name, None)
 
@@ -85,6 +114,15 @@ class ELBBackend(BaseBackend):
         load_balancer.health_check = check
         return check
 
+    def set_load_balancer_listener_sslcertificate(self, name, lb_port, ssl_certificate_id):
+        balancer = self.load_balancers.get(name, None)
+        if balancer:
+            for idx, listener in enumerate(balancer.listeners):
+                if lb_port == listener.load_balancer_port:
+                    balancer.listeners[idx].ssl_certificate_id = ssl_certificate_id
+
+        return balancer
+
     def register_instances(self, load_balancer_name, instance_ids):
         load_balancer = self.get_load_balancer(load_balancer_name)
         load_balancer.instance_ids.extend(instance_ids)

moto/elb/responses.py

@@ -21,8 +21,10 @@ class ELBResponse(BaseResponse):
                 break
             lb_port = self.querystring['Listeners.member.{0}.LoadBalancerPort'.format(port_index)][0]
             instance_port = self.querystring['Listeners.member.{0}.InstancePort'.format(port_index)][0]
-            ports.append([protocol, lb_port, instance_port])
+            ssl_certificate_id = self.querystring.get('Listeners.member.{0}.SSLCertificateId'.format(port_index)[0], None)
+            ports.append([protocol, lb_port, instance_port, ssl_certificate_id])
             port_index += 1
+
         elb_backend.create_load_balancer(
             name=load_balancer_name,
             zones=availability_zones,
@@ -31,12 +33,45 @@ class ELBResponse(BaseResponse):
         template = Template(CREATE_LOAD_BALANCER_TEMPLATE)
         return template.render()
 
+    def create_load_balancer_listeners(self):
+        load_balancer_name = self.querystring.get('LoadBalancerName')[0]
+        ports = []
+        port_index = 1
+        while True:
+            try:
+                protocol = self.querystring['Listeners.member.{0}.Protocol'.format(port_index)][0]
+            except KeyError:
+                break
+            lb_port = self.querystring['Listeners.member.{0}.LoadBalancerPort'.format(port_index)][0]
+            instance_port = self.querystring['Listeners.member.{0}.InstancePort'.format(port_index)][0]
+            ssl_certificate_id = self.querystring.get('Listeners.member.{0}.SSLCertificateId'.format(port_index)[0], None)
+            ports.append([protocol, lb_port, instance_port, ssl_certificate_id])
+            port_index += 1
+
+        elb_backend.create_load_balancer_listeners(name=load_balancer_name, ports=ports)
+
+        template = Template(CREATE_LOAD_BALANCER_LISTENERS_TEMPLATE)
+        return template.render()
+
     def describe_load_balancers(self):
         names = [value[0] for key, value in self.querystring.items() if "LoadBalancerNames.member" in key]
         load_balancers = elb_backend.describe_load_balancers(names)
         template = Template(DESCRIBE_LOAD_BALANCERS_TEMPLATE)
         return template.render(load_balancers=load_balancers)
 
+    def delete_load_balancer_listeners(self):
+        load_balancer_name = self.querystring.get('LoadBalancerName')[0]
+        ports = []
+        port_index = 1
+        while True:
+            try:
+                ports.append(self.querystring['Listeners.member.{0}.LoadBalancerPort'.format(port_index)][0])
+            except KeyError:
+                break
+        elb_backend.delete_load_balancer_listeners(load_balancer_name, ports)
+        template = Template(DELETE_LOAD_BALANCER_LISTENERS)
+        return template.render()
+
     def delete_load_balancer(self):
         load_balancer_name = self.querystring.get('LoadBalancerName')[0]
         elb_backend.delete_load_balancer(load_balancer_name)
@@ -62,6 +97,16 @@ class ELBResponse(BaseResponse):
         load_balancer = elb_backend.register_instances(load_balancer_name, instance_ids)
         return template.render(load_balancer=load_balancer)
 
+    def set_load_balancer_listener_sslcertificate(self):
+        load_balancer_name = self.querystring.get('LoadBalancerName')[0]
+        ssl_certificate_id = self.querystring['SSLCertificateId'][0]
+        lb_port = self.querystring['LoadBalancerPort'][0]
+
+        elb_backend.set_load_balancer_listener_sslcertificate(load_balancer_name, lb_port, ssl_certificate_id)
+
+        template = Template(SET_LOAD_BALANCER_SSL_CERTIFICATE)
+        return template.render()
+
     def deregister_instances_from_load_balancer(self):
         load_balancer_name = self.querystring.get('LoadBalancerName')[0]
         instance_ids = [value[0] for key, value in self.querystring.items() if "Instances.member" in key]
@@ -73,6 +118,13 @@ CREATE_LOAD_BALANCER_TEMPLATE = """<CreateLoadBalancerResult xmlns="http://elast
     <DNSName>tests.us-east-1.elb.amazonaws.com</DNSName>
 </CreateLoadBalancerResult>"""
 
+CREATE_LOAD_BALANCER_LISTENERS_TEMPLATE = """<CreateLoadBalancerListenersResponse xmlns="http://elasticloadbalancing.amazon aws.com/doc/2012-06-01/">
+  <CreateLoadBalancerListenersResult/>
+  <ResponseMetadata>
+    <RequestId>1549581b-12b7-11e3-895e-1334aEXAMPLE</RequestId>
+  </ResponseMetadata>
+</CreateLoadBalancerListenersResponse>"""
+
 DELETE_LOAD_BALANCER_TEMPLATE = """<DeleteLoadBalancerResult xmlns="http://elasticloadbalancing.amazonaws.com/doc/2012-06-01/">
 </DeleteLoadBalancerResult>"""
 
@@ -106,6 +158,7 @@ DESCRIBE_LOAD_BALANCERS_TEMPLATE = """<DescribeLoadBalancersResponse xmlns="http
                   <LoadBalancerPort>{{ listener.load_balancer_port }}</LoadBalancerPort>
                   <InstanceProtocol>{{ listener.protocol }}</InstanceProtocol>
                   <InstancePort>{{ listener.instance_port }}</InstancePort>
+                  <SSLCertificateId>{{ listener.ssl_certificate_id }}</SSLCertificateId>
                 </Listener>
               </member>
             {% endfor %}
@@ -177,3 +230,18 @@ DEREGISTER_INSTANCES_TEMPLATE = """<DeregisterInstancesWithLoadBalancerResult xm
     {% endfor %}
   </Instances>
 </DeregisterInstancesWithLoadBalancerResult>"""
+
+SET_LOAD_BALANCER_SSL_CERTIFICATE = """<SetLoadBalancerListenerSSLCertificateResponse xmlns="http://elasticloadbalan cing.amazonaws.com/doc/2012-06-01/">
+ <SetLoadBalancerListenerSSLCertificateResult/>
+<ResponseMetadata>
+    <RequestId>83c88b9d-12b7-11e3-8b82-87b12EXAMPLE</RequestId>
+</ResponseMetadata>
+</SetLoadBalancerListenerSSLCertificateResponse>"""
+
+
+DELETE_LOAD_BALANCER_LISTENERS = """<DeleteLoadBalancerListenersResponse xmlns="http://elasticloadbalan cing.amazonaws.com/doc/2012-06-01/">
+ <DeleteLoadBalancerListenersResult/>
+<ResponseMetadata>
+    <RequestId>83c88b9d-12b7-11e3-8b82-87b12EXAMPLE</RequestId>
+</ResponseMetadata>
+</DeleteLoadBalancerListenersResponse>"""