Merge pull request #285 from zalando-stups/fix-senza-status-for-alias-records

Fix senza status for alias records

Author: hjacobs

senza/cli.py

@@ -17,7 +17,6 @@
 
 import boto3
 import click
-import dns.resolver
 import requests
 import senza
 import yaml
@@ -43,7 +42,7 @@
 from .stups.piu import Piu
 from .templates import get_template_description, get_templates
 from .templates._helper import get_mint_bucket_name
-from .traffic import change_version_traffic, get_records, print_version_traffic
+from .traffic import change_version_traffic, get_records, print_version_traffic, resolve_to_ip_addresses
 from .utils import (camel_case_to_underscore, ensure_keys, named_value,
                     pystache_render)
 
@@ -937,7 +936,9 @@ def status(stack_ref, region, output, w, watch):
         for stack in sorted(get_stacks(stack_refs, region)):
             instance_health = get_instance_health(elb, stack.StackName)
 
-            main_dns_resolves = False
+            main_dns_resolves = None
+            version_addresses = set()
+            main_addresses = set()
             http_status = None
             for res in cf.Stack(stack.StackId).resource_summaries.all():
                 if res.resource_type == 'AWS::Route53::RecordSet':
@@ -946,22 +947,20 @@ def status(stack_ref, region, output, w, watch):
                         # physical resource ID will be empty during stack creation
                         continue
                     if 'version' in res.logical_id.lower():
+                        # VersionDomain -> check HTTPS reachability
+                        # (won't work for internal ELBs, but we don't care here)
                         try:
-                            requests.get('https://{}/'.format(name), timeout=2)
+                            requests.get('https://{}/'.format(name), timeout=1)
                             http_status = 'OK'
                         except:
                             http_status = 'ERROR'
+                        version_addresses = resolve_to_ip_addresses(name)
                     else:
-                        try:
-                            answers = dns.resolver.query(name, 'CNAME')
-                        except:
-                            answers = []
-                        for answer in answers:
-                            target = answer.target.to_text()
-                            if isinstance(target, bytes):
-                                target = target.decode()
-                            if target.startswith('{}-'.format(stack.StackName)):
-                                main_dns_resolves = True
+                        # MainDomain -> check whether DNS resolves to this stack version
+                        main_addresses = resolve_to_ip_addresses(name)
+
+            if version_addresses and main_addresses:
+                main_dns_resolves = bool(version_addresses & main_addresses)
 
             instances = list(ec2.instances.filter(Filters=[{'Name': 'tag:aws:cloudformation:stack-id',
                                                             'Values': [stack.StackId]}]))
@@ -1025,7 +1024,7 @@ def domains(stack_ref, region, output, w, watch):
                     if record:
                         row.update({'weight': str(record.get('Weight', '')),
                                     'type': record.get('Type'),
-                                    'value': ','.join([r['Value'] for r in record.get('ResourceRecords')])})
+                                    'value': ','.join([r['Value'] for r in record.get('ResourceRecords', [])])})
                     rows.append(row)
 
         with OutputFormat(output):

senza/traffic.py

@@ -1,4 +1,5 @@
 import collections
+import dns.resolver
 from json import JSONEncoder
 
 import boto3
@@ -395,3 +396,15 @@ def inform_sns(arns: list, message: str, region):
     sns = boto3.client('sns', region_name=region)
     for sns_topic in sns_topics:
         sns.publish(TopicArn=sns_topic, Subject="SenzaTrafficRedirect", Message=jsonizer.encode((message)))
+
+
+def resolve_to_ip_addresses(dns_name: str) -> set:
+    """
+    Try to resolve the given DNS name to IPv4 addresses and return empty set on ANY error.
+    """
+    try:
+        answers = dns.resolver.query(dns_name, 'A')
+    except:
+        return set()
+    else:
+        return {answer.address for answer in answers}

tests/test_cli.py

@@ -1568,3 +1568,58 @@ def test_failure_event():
 
     assert failure_event({'ResourceStatusReason': 'foo',
                           'ResourceStatus': 'FAIL'})
+
+
+def test_status_main_dns(monkeypatch):
+    def my_resource(rtype, *args):
+        if rtype == 'ec2':
+            ec2 = MagicMock()
+            instance = MagicMock()
+            instance.id = 'inst-123'
+            instance.public_ip_address = '8.8.8.8'
+            instance.private_ip_address = '10.0.0.1'
+            instance.state = {'Name': 'Test-instance'}
+            instance.tags = [{'Key': 'aws:cloudformation:stack-name', 'Value': 'test-1'},
+                             {'Key': 'aws:cloudformation:logical-id', 'Value': 'local-id-123'},
+                             {'Key': 'StackName', 'Value': 'test'},
+                             {'Key': 'StackVersion', 'Value': '1'}]
+            instance.launch_time = datetime.datetime.utcnow()
+            ec2.instances.filter.return_value = [instance]
+            return ec2
+        elif rtype == 'cloudformation':
+            cf = MagicMock()
+            version_domain = MagicMock()
+            version_domain.logical_id = 'VersionDomain'
+            version_domain.resource_type = 'AWS::Route53::RecordSet'
+            version_domain.physical_resource_id = 'test-1.example.org'
+            main_domain = MagicMock()
+            main_domain.logical_id = 'MainDomain'
+            main_domain.resource_type = 'AWS::Route53::RecordSet'
+            main_domain.physical_resource_id = 'test.example.org'
+            cf.Stack.return_value.resource_summaries.all.return_value = [version_domain, main_domain]
+            return cf
+        return MagicMock()
+
+    def my_client(rtype, *args):
+        if rtype == 'cloudformation':
+            cf = MagicMock()
+            cf.list_stacks.return_value = {'StackSummaries': [{'StackName': 'test-1',
+                                                               'CreationTime': '2016-06-14'}]}
+            return cf
+        return MagicMock()
+
+    def resolve_to_ip_addresses(dns_name):
+        return {'test-1.example.org': {'1.2.3.4', '5.6.7.8'}, 'test.example.org': {'5.6.7.8'}}.get(dns_name)
+
+    monkeypatch.setattr('boto3.resource', my_resource)
+    monkeypatch.setattr('boto3.client', my_client)
+    monkeypatch.setattr('senza.cli.resolve_to_ip_addresses', resolve_to_ip_addresses)
+
+    runner = CliRunner()
+
+    with runner.isolated_filesystem():
+        result = runner.invoke(cli, ['status', 'test', '--region=aa-fakeregion-1', '1', '--output=json'],
+                               catch_exceptions=False)
+
+    data = json.loads(result.output.strip())
+    assert data[0]['main_dns'] == True

tests/test_traffic.py

@@ -1,6 +1,6 @@
 from unittest.mock import MagicMock
 from senza.aws import SenzaStackSummary
-from senza.traffic import get_stack_versions, StackVersion, get_weights
+from senza.traffic import get_stack_versions, StackVersion, get_weights, resolve_to_ip_addresses
 from senza.manaus.route53 import RecordType
 
 
@@ -71,3 +71,15 @@ def test_get_weights(monkeypatch):
                                                                'app-3': 0},
                                                               0,
                                                               0)
+
+
+def test_resolve_to_ip_addresses(monkeypatch):
+    query = MagicMock()
+    monkeypatch.setattr('dns.resolver.query', query)
+
+    query.side_effect = Exception()
+    assert resolve_to_ip_addresses('example.org') == set()
+
+    query.side_effect = None
+    query.return_value = [MagicMock(address='1.2.3.4')]
+    assert resolve_to_ip_addresses('example.org') == {'1.2.3.4'}