Add support for DNAME records

docs/records.md

@@ -7,6 +7,7 @@ OctoDNS supports the following record types:
 * `A`
 * `AAAA`
 * `CNAME`
+* `DNAME`
 * `MX`
 * `NAPTR`
 * `NS`

octodns/provider/yaml.py

@@ -104,8 +104,8 @@ class YamlProvider(BaseProvider):
     '''
     SUPPORTS_GEO = True
     SUPPORTS_DYNAMIC = True
-    SUPPORTS = set(('A', 'AAAA', 'ALIAS', 'CAA', 'CNAME', 'MX', 'NAPTR', 'NS',
-                    'PTR', 'SSHFP', 'SPF', 'SRV', 'TXT'))
+    SUPPORTS = set(('A', 'AAAA', 'ALIAS', 'CAA', 'CNAME', 'DNAME', 'MX',
+                    'NAPTR', 'NS', 'PTR', 'SSHFP', 'SPF', 'SRV', 'TXT'))
 
     def __init__(self, id, directory, default_ttl=3600, enforce_order=True,
                  populate_should_replace=False, *args, **kwargs):

octodns/record/__init__.py

@@ -95,6 +95,7 @@ class Record(EqualityTupleMixin):
                 'ALIAS': AliasRecord,
                 'CAA': CaaRecord,
                 'CNAME': CnameRecord,
+                'DNAME': DnameRecord,
                 'MX': MxRecord,
                 'NAPTR': NaptrRecord,
                 'NS': NsRecord,
@@ -759,6 +760,10 @@ class CnameValue(_TargetValue):
     pass
 
 
+class DnameValue(_TargetValue):
+    pass
+
+
 class ARecord(_DynamicMixin, _GeoMixin, Record):
     _type = 'A'
     _value_type = Ipv4List
@@ -842,6 +847,11 @@ class CnameRecord(_DynamicMixin, _ValueMixin, Record):
         return reasons
 
 
+class DnameRecord(_DynamicMixin, _ValueMixin, Record):
+    _type = 'DNAME'
+    _value_type = DnameValue
+
+
 class MxValue(EqualityTupleMixin):
 
     @classmethod

tests/config/dynamic.tests.yaml

@@ -109,6 +109,40 @@ cname:
       - pool: iad
   type: CNAME
   value: target.unit.tests.
+dname:
+  dynamic:
+    pools:
+      ams:
+        values:
+          - value: target-ams.unit.tests.
+      iad:
+        values:
+          - value: target-iad.unit.tests.
+      lax:
+        values:
+          - value: target-lax.unit.tests.
+      sea:
+        values:
+          - value: target-sea-1.unit.tests.
+            weight: 10
+          - value: target-sea-2.unit.tests.
+            weight: 14
+    rules:
+      - geos:
+        - EU-GB
+        pool: lax
+      - geos:
+        - EU
+        pool: ams
+      - geos:
+          - NA-US-CA
+          - NA-US-NC
+          - NA-US-OR
+          - NA-US-WA
+        pool: sea
+      - pool: iad
+  type: DNAME
+  value: target.unit.tests.
 real-ish-a:
   dynamic:
     pools:

tests/config/split/dynamic.tests./dname.yaml

@@ -0,0 +1,42 @@
+---
+dname:
+  dynamic:
+    pools:
+      ams:
+        fallback: null
+        values:
+        - value: target-ams.unit.tests.
+          weight: 1
+      iad:
+        fallback: null
+        values:
+        - value: target-iad.unit.tests.
+          weight: 1
+      lax:
+        fallback: null
+        values:
+        - value: target-lax.unit.tests.
+          weight: 1
+      sea:
+        fallback: null
+        values:
+        - value: target-sea-1.unit.tests.
+          weight: 10
+        - value: target-sea-2.unit.tests.
+          weight: 14
+    rules:
+    - geos:
+      - EU-GB
+      pool: lax
+    - geos:
+      - EU
+      pool: ams
+    - geos:
+      - NA-US-CA
+      - NA-US-NC
+      - NA-US-OR
+      - NA-US-WA
+      pool: sea
+    - pool: iad
+  type: DNAME
+  value: target.unit.tests.

tests/config/split/unit.tests./dname.yaml

@@ -0,0 +1,5 @@
+---
+dname:
+  ttl: 300
+  type: DNAME
+  value: unit.tests.

tests/config/unit.tests.yaml

@@ -56,6 +56,10 @@ cname:
   ttl: 300
   type: CNAME
   value: unit.tests.
+dname:
+  ttl: 300
+  type: DNAME
+  value: unit.tests.
 excluded:
   octodns:
     excluded:

tests/test_octodns_manager.py

@@ -118,12 +118,12 @@ class TestManager(TestCase):
             environ['YAML_TMP_DIR'] = tmpdir.dirname
             tc = Manager(get_config_filename('simple.yaml')) \
                 .sync(dry_run=False)
-            self.assertEquals(21, tc)
+            self.assertEquals(22, tc)
 
             # try with just one of the zones
             tc = Manager(get_config_filename('simple.yaml')) \
                 .sync(dry_run=False, eligible_zones=['unit.tests.'])
-            self.assertEquals(15, tc)
+            self.assertEquals(16, tc)
 
             # the subzone, with 2 targets
             tc = Manager(get_config_filename('simple.yaml')) \
@@ -138,18 +138,18 @@ class TestManager(TestCase):
             # Again with force
             tc = Manager(get_config_filename('simple.yaml')) \
                 .sync(dry_run=False, force=True)
-            self.assertEquals(21, tc)
+            self.assertEquals(22, tc)
 
             # Again with max_workers = 1
             tc = Manager(get_config_filename('simple.yaml'), max_workers=1) \
                 .sync(dry_run=False, force=True)
-            self.assertEquals(21, tc)
+            self.assertEquals(22, tc)
 
             # Include meta
             tc = Manager(get_config_filename('simple.yaml'), max_workers=1,
                          include_meta=True) \
                 .sync(dry_run=False, force=True)
-            self.assertEquals(25, tc)
+            self.assertEquals(26, tc)
 
     def test_eligible_sources(self):
         with TemporaryDirectory() as tmpdir:
@@ -183,13 +183,13 @@ class TestManager(TestCase):
                 fh.write('---\n{}')
 
             changes = manager.compare(['in'], ['dump'], 'unit.tests.')
-            self.assertEquals(15, len(changes))
+            self.assertEquals(16, len(changes))
 
             # Compound sources with varying support
             changes = manager.compare(['in', 'nosshfp'],
                                       ['dump'],
                                       'unit.tests.')
-            self.assertEquals(14, len(changes))
+            self.assertEquals(15, len(changes))
 
             with self.assertRaises(ManagerException) as ctx:
                 manager.compare(['nope'], ['dump'], 'unit.tests.')

tests/test_octodns_provider_constellix.py

@@ -138,7 +138,7 @@ class TestConstellixProvider(TestCase):
         plan = provider.plan(self.expected)
 
         # No root NS, no ignored, no excluded, no unsupported
-        n = len(self.expected.records) - 5
+        n = len(self.expected.records) - 6
         self.assertEquals(n, len(plan.changes))
         self.assertEquals(n, provider.apply(plan))
 

tests/test_octodns_provider_digitalocean.py

@@ -163,7 +163,7 @@ class TestDigitalOceanProvider(TestCase):
         plan = provider.plan(self.expected)
 
         # No root NS, no ignored, no excluded, no unsupported
-        n = len(self.expected.records) - 7
+        n = len(self.expected.records) - 8
         self.assertEquals(n, len(plan.changes))
         self.assertEquals(n, provider.apply(plan))
         self.assertFalse(plan.exists)

tests/test_octodns_provider_dnsimple.py

@@ -137,7 +137,7 @@ class TestDnsimpleProvider(TestCase):
         plan = provider.plan(self.expected)
 
         # No root NS, no ignored, no excluded
-        n = len(self.expected.records) - 3
+        n = len(self.expected.records) - 4
         self.assertEquals(n, len(plan.changes))
         self.assertEquals(n, provider.apply(plan))
         self.assertFalse(plan.exists)

tests/test_octodns_provider_dnsmadeeasy.py

@@ -140,7 +140,7 @@ class TestDnsMadeEasyProvider(TestCase):
         plan = provider.plan(self.expected)
 
         # No root NS, no ignored, no excluded, no unsupported
-        n = len(self.expected.records) - 5
+        n = len(self.expected.records) - 6
         self.assertEquals(n, len(plan.changes))
         self.assertEquals(n, provider.apply(plan))
 

tests/test_octodns_provider_easydns.py

@@ -374,7 +374,7 @@ class TestEasyDNSProvider(TestCase):
         plan = provider.plan(self.expected)
 
         # No root NS, no ignored, no excluded, no unsupported
-        n = len(self.expected.records) - 6
+        n = len(self.expected.records) - 7
         self.assertEquals(n, len(plan.changes))
         self.assertEquals(n, provider.apply(plan))
         self.assertFalse(plan.exists)

tests/test_octodns_provider_powerdns.py

@@ -171,7 +171,7 @@ class TestPowerDnsProvider(TestCase):
         expected = Zone('unit.tests.', [])
         source = YamlProvider('test', join(dirname(__file__), 'config'))
         source.populate(expected)
-        expected_n = len(expected.records) - 2
+        expected_n = len(expected.records) - 3
         self.assertEquals(16, expected_n)
 
         # No diffs == no changes
@@ -277,7 +277,7 @@ class TestPowerDnsProvider(TestCase):
         expected = Zone('unit.tests.', [])
         source = YamlProvider('test', join(dirname(__file__), 'config'))
         source.populate(expected)
-        self.assertEquals(18, len(expected.records))
+        self.assertEquals(19, len(expected.records))
 
         # A small change to a single record
         with requests_mock() as mock:

tests/test_octodns_provider_yaml.py

@@ -35,10 +35,10 @@ class TestYamlProvider(TestCase):
 
         # without it we see everything
         source.populate(zone)
-        self.assertEquals(18, len(zone.records))
+        self.assertEquals(19, len(zone.records))
 
         source.populate(dynamic_zone)
-        self.assertEquals(5, len(dynamic_zone.records))
+        self.assertEquals(6, len(dynamic_zone.records))
 
         # Assumption here is that a clean round-trip means that everything
         # worked as expected, data that went in came back out and could be
@@ -58,21 +58,21 @@ class TestYamlProvider(TestCase):
 
             # We add everything
             plan = target.plan(zone)
-            self.assertEquals(15, len([c for c in plan.changes
+            self.assertEquals(16, len([c for c in plan.changes
                                        if isinstance(c, Create)]))
             self.assertFalse(isfile(yaml_file))
 
             # Now actually do it
-            self.assertEquals(15, target.apply(plan))
+            self.assertEquals(16, target.apply(plan))
             self.assertTrue(isfile(yaml_file))
 
             # Dynamic plan
             plan = target.plan(dynamic_zone)
-            self.assertEquals(5, len([c for c in plan.changes
+            self.assertEquals(6, len([c for c in plan.changes
                                       if isinstance(c, Create)]))
             self.assertFalse(isfile(dynamic_yaml_file))
             # Apply it
-            self.assertEquals(5, target.apply(plan))
+            self.assertEquals(6, target.apply(plan))
             self.assertTrue(isfile(dynamic_yaml_file))
 
             # There should be no changes after the round trip
@@ -87,7 +87,7 @@ class TestYamlProvider(TestCase):
 
             # A 2nd sync should still create everything
             plan = target.plan(zone)
-            self.assertEquals(15, len([c for c in plan.changes
+            self.assertEquals(16, len([c for c in plan.changes
                                        if isinstance(c, Create)]))
 
             with open(yaml_file) as fh:
@@ -109,6 +109,7 @@ class TestYamlProvider(TestCase):
                 # these are stored as singular 'value'
                 self.assertTrue('value' in data.pop('aaaa'))
                 self.assertTrue('value' in data.pop('cname'))
+                self.assertTrue('value' in data.pop('dname'))
                 self.assertTrue('value' in data.pop('included'))
                 self.assertTrue('value' in data.pop('ptr'))
                 self.assertTrue('value' in data.pop('spf'))
@@ -136,6 +137,10 @@ class TestYamlProvider(TestCase):
                 self.assertTrue('value' in dyna)
                 # self.assertTrue('dynamic' in dyna)
 
+                dyna = data.pop('dname')
+                self.assertTrue('value' in dyna)
+                # self.assertTrue('dynamic' in dyna)
+
                 dyna = data.pop('real-ish-a')
                 self.assertTrue('values' in dyna)
                 # self.assertTrue('dynamic' in dyna)
@@ -237,10 +242,10 @@ class TestSplitYamlProvider(TestCase):
 
         # without it we see everything
         source.populate(zone)
-        self.assertEquals(18, len(zone.records))
+        self.assertEquals(19, len(zone.records))
 
         source.populate(dynamic_zone)
-        self.assertEquals(5, len(dynamic_zone.records))
+        self.assertEquals(6, len(dynamic_zone.records))
 
         with TemporaryDirectory() as td:
             # Add some subdirs to make sure that it can create them
@@ -251,20 +256,20 @@ class TestSplitYamlProvider(TestCase):
 
             # We add everything
             plan = target.plan(zone)
-            self.assertEquals(15, len([c for c in plan.changes
+            self.assertEquals(16, len([c for c in plan.changes
                                        if isinstance(c, Create)]))
             self.assertFalse(isdir(zone_dir))
 
             # Now actually do it
-            self.assertEquals(15, target.apply(plan))
+            self.assertEquals(16, target.apply(plan))
 
             # Dynamic plan
             plan = target.plan(dynamic_zone)
-            self.assertEquals(5, len([c for c in plan.changes
+            self.assertEquals(6, len([c for c in plan.changes
                                       if isinstance(c, Create)]))
             self.assertFalse(isdir(dynamic_zone_dir))
             # Apply it
-            self.assertEquals(5, target.apply(plan))
+            self.assertEquals(6, target.apply(plan))
             self.assertTrue(isdir(dynamic_zone_dir))
 
             # There should be no changes after the round trip
@@ -279,7 +284,7 @@ class TestSplitYamlProvider(TestCase):
 
             # A 2nd sync should still create everything
             plan = target.plan(zone)
-            self.assertEquals(15, len([c for c in plan.changes
+            self.assertEquals(16, len([c for c in plan.changes
                                        if isinstance(c, Create)]))
 
             yaml_file = join(zone_dir, '$unit.tests.yaml')
@@ -302,8 +307,8 @@ class TestSplitYamlProvider(TestCase):
                     self.assertTrue('values' in data.pop(record_name))
 
             # These are stored as singular "value." Again, check each file.
-            for record_name in ('aaaa', 'cname', 'included', 'ptr', 'spf',
-                                'www.sub', 'www'):
+            for record_name in ('aaaa', 'cname', 'dname', 'included', 'ptr',
+                                'spf', 'www.sub', 'www'):
                 yaml_file = join(zone_dir, '{}.yaml'.format(record_name))
                 self.assertTrue(isfile(yaml_file))
                 with open(yaml_file) as fh:
@@ -322,7 +327,7 @@ class TestSplitYamlProvider(TestCase):
                     self.assertTrue('dynamic' in dyna)
 
             # Singular again.
-            for record_name in ('cname', 'simple-weighted'):
+            for record_name in ('cname', 'dname', 'simple-weighted'):
                 yaml_file = join(
                     dynamic_zone_dir, '{}.yaml'.format(record_name))
                 self.assertTrue(isfile(yaml_file))
@@ -386,7 +391,7 @@ class TestOverridingYamlProvider(TestCase):
         # Load the base, should see the 5 records
         base.populate(zone)
         got = {r.name: r for r in zone.records}
-        self.assertEquals(5, len(got))
+        self.assertEquals(6, len(got))
         # We get the "dynamic" A from the bae config
         self.assertTrue('dynamic' in got['a'].data)
         # No added
@@ -395,7 +400,7 @@ class TestOverridingYamlProvider(TestCase):
         # Load the overrides, should replace one and add 1
         override.populate(zone)
         got = {r.name: r for r in zone.records}
-        self.assertEquals(6, len(got))
+        self.assertEquals(7, len(got))
         # 'a' was replaced with a generic record
         self.assertEquals({
             'ttl': 3600,

tests/test_octodns_record.py

@@ -9,10 +9,10 @@ from six import text_type
 from unittest import TestCase
 
 from octodns.record import ARecord, AaaaRecord, AliasRecord, CaaRecord, \
-    CaaValue, CnameRecord, Create, Delete, GeoValue, MxRecord, MxValue, \
-    NaptrRecord, NaptrValue, NsRecord, PtrRecord, Record, SshfpRecord, \
-    SshfpValue, SpfRecord, SrvRecord, SrvValue, TxtRecord, Update, \
-    ValidationError, _Dynamic, _DynamicPool, _DynamicRule
+    CaaValue, CnameRecord, DnameRecord, Create, Delete, GeoValue, MxRecord, \
+    MxValue, NaptrRecord, NaptrValue, NsRecord, PtrRecord, Record, \
+    SshfpRecord, SshfpValue, SpfRecord, SrvRecord, SrvValue, TxtRecord, \
+    Update, ValidationError, _Dynamic, _DynamicPool, _DynamicRule
 from octodns.zone import Zone
 
 from helpers import DynamicProvider, GeoProvider, SimpleProvider
@@ -55,6 +55,19 @@ class TestRecord(TestCase):
         })
         self.assertEquals(upper_record.value, lower_record.value)
 
+    def test_dname_lowering_value(self):
+        upper_record = DnameRecord(self.zone, 'DnameUppwerValue', {
+            'ttl': 30,
+            'type': 'DNAME',
+            'value': 'GITHUB.COM',
+        })
+        lower_record = DnameRecord(self.zone, 'DnameLowerValue', {
+            'ttl': 30,
+            'type': 'DNAME',
+            'value': 'github.com',
+        })
+        self.assertEquals(upper_record.value, lower_record.value)
+
     def test_ptr_lowering_value(self):
         upper_record = PtrRecord(self.zone, 'PtrUppwerValue', {
             'ttl': 30,
@@ -362,6 +375,10 @@ class TestRecord(TestCase):
         self.assertSingleValue(CnameRecord, 'target.foo.com.',
                                'other.foo.com.')
 
+    def test_dname(self):
+        self.assertSingleValue(DnameRecord, 'target.foo.com.',
+                               'other.foo.com.')
+
     def test_mx(self):
         a_values = [{
             'preference': 10,
@@ -1825,6 +1842,31 @@ class TestRecordValidation(TestCase):
         self.assertEquals(['CNAME value "foo.bar.com" missing trailing .'],
                           ctx.exception.reasons)
 
+    def test_DNAME(self):
+        # A valid DNAME record.
+        Record.new(self.zone, 'sub', {
+            'type': 'DNAME',
+            'ttl': 600,
+            'value': 'foo.bar.com.',
+        })
+
+        # A DNAME record can be present at the zone APEX.
+        Record.new(self.zone, '', {
+            'type': 'DNAME',
+            'ttl': 600,
+            'value': 'foo.bar.com.',
+        })
+
+        # missing trailing .
+        with self.assertRaises(ValidationError) as ctx:
+            Record.new(self.zone, 'www', {
+                'type': 'DNAME',
+                'ttl': 600,
+                'value': 'foo.bar.com',
+            })
+        self.assertEquals(['DNAME value "foo.bar.com" missing trailing .'],
+                          ctx.exception.reasons)
+
     def test_MX(self):
         # doesn't blow up
         Record.new(self.zone, '', {
@@ -2628,6 +2670,73 @@ class TestDynamicRecords(TestCase):
         self.assertTrue(rules)
         self.assertEquals(cname_data['dynamic']['rules'][0], rules[0].data)
 
+    def test_simple_dname_weighted(self):
+        dname_data = {
+            'dynamic': {
+                'pools': {
+                    'one': {
+                        'values': [{
+                            'value': 'one.dname.target.',
+                        }],
+                    },
+                    'two': {
+                        'values': [{
+                            'value': 'two.dname.target.',
+                        }],
+                    },
+                    'three': {
+                        'values': [{
+                            'weight': 12,
+                            'value': 'three-1.dname.target.',
+                        }, {
+                            'weight': 32,
+                            'value': 'three-2.dname.target.',
+                        }]
+                    },
+                },
+                'rules': [{
+                    'geos': ['AF', 'EU'],
+                    'pool': 'three',
+                }, {
+                    'geos': ['NA-US-CA'],
+                    'pool': 'two',
+                }, {
+                    'pool': 'one',
+                }],
+            },
+            'ttl': 60,
+            'value': 'dname.target.',
+        }
+        dname = DnameRecord(self.zone, 'weighted', dname_data)
+        self.assertEquals('DNAME', dname._type)
+        self.assertEquals(dname_data['ttl'], dname.ttl)
+        self.assertEquals(dname_data['value'], dname.value)
+
+        dynamic = dname.dynamic
+        self.assertTrue(dynamic)
+
+        pools = dynamic.pools
+        self.assertTrue(pools)
+        self.assertEquals({
+            'value': 'one.dname.target.',
+            'weight': 1,
+        }, pools['one'].data['values'][0])
+        self.assertEquals({
+            'value': 'two.dname.target.',
+            'weight': 1,
+        }, pools['two'].data['values'][0])
+        self.assertEquals([{
+            'value': 'three-1.dname.target.',
+            'weight': 12,
+        }, {
+            'value': 'three-2.dname.target.',
+            'weight': 32,
+        }], pools['three'].data['values'])
+
+        rules = dynamic.rules
+        self.assertTrue(rules)
+        self.assertEquals(dname_data['dynamic']['rules'][0], rules[0].data)
+
     def test_dynamic_validation(self):
         # Missing pools
         a_data = {