Pull out rest of record into specific files

octodns/record/ds.py

@@ -0,0 +1,136 @@
+#
+#
+#
+
+from ..equality import EqualityTupleMixin
+from .base import Record, ValuesMixin
+from .rr import RrParseError
+
+
+class DsValue(EqualityTupleMixin, dict):
+    # https://www.rfc-editor.org/rfc/rfc4034.html#section-2.1
+
+    @classmethod
+    def parse_rdata_text(cls, value):
+        try:
+            flags, protocol, algorithm, public_key = value.split(' ')
+        except ValueError:
+            raise RrParseError()
+        try:
+            flags = int(flags)
+        except ValueError:
+            pass
+        try:
+            protocol = int(protocol)
+        except ValueError:
+            pass
+        try:
+            algorithm = int(algorithm)
+        except ValueError:
+            pass
+        return {
+            'flags': flags,
+            'protocol': protocol,
+            'algorithm': algorithm,
+            'public_key': public_key,
+        }
+
+    @classmethod
+    def validate(cls, data, _type):
+        if not isinstance(data, (list, tuple)):
+            data = (data,)
+        reasons = []
+        for value in data:
+            try:
+                int(value['flags'])
+            except KeyError:
+                reasons.append('missing flags')
+            except ValueError:
+                reasons.append(f'invalid flags "{value["flags"]}"')
+            try:
+                int(value['protocol'])
+            except KeyError:
+                reasons.append('missing protocol')
+            except ValueError:
+                reasons.append(f'invalid protocol "{value["protocol"]}"')
+            try:
+                int(value['algorithm'])
+            except KeyError:
+                reasons.append('missing algorithm')
+            except ValueError:
+                reasons.append(f'invalid algorithm "{value["algorithm"]}"')
+            if 'public_key' not in value:
+                reasons.append('missing public_key')
+        return reasons
+
+    @classmethod
+    def process(cls, values):
+        return [cls(v) for v in values]
+
+    def __init__(self, value):
+        super().__init__(
+            {
+                'flags': int(value['flags']),
+                'protocol': int(value['protocol']),
+                'algorithm': int(value['algorithm']),
+                'public_key': value['public_key'],
+            }
+        )
+
+    @property
+    def flags(self):
+        return self['flags']
+
+    @flags.setter
+    def flags(self, value):
+        self['flags'] = value
+
+    @property
+    def protocol(self):
+        return self['protocol']
+
+    @protocol.setter
+    def protocol(self, value):
+        self['protocol'] = value
+
+    @property
+    def algorithm(self):
+        return self['algorithm']
+
+    @algorithm.setter
+    def algorithm(self, value):
+        self['algorithm'] = value
+
+    @property
+    def public_key(self):
+        return self['public_key']
+
+    @public_key.setter
+    def public_key(self, value):
+        self['public_key'] = value
+
+    @property
+    def data(self):
+        return self
+
+    @property
+    def rdata_text(self):
+        return (
+            f'{self.flags} {self.protocol} {self.algorithm} {self.public_key}'
+        )
+
+    def _equality_tuple(self):
+        return (self.flags, self.protocol, self.algorithm, self.public_key)
+
+    def __repr__(self):
+        return (
+            f'{self.flags} {self.protocol} {self.algorithm} {self.public_key}'
+        )
+
+
+class DsRecord(ValuesMixin, Record):
+    _type = 'DS'
+    _value_type = DsValue
+
+
+Record.register_type(DsRecord)