Added initial project files

app/specs/__init__.py

@@ -0,0 +1,2 @@
+from .specs import Spec
+from .parser import parse_specs_file

app/specs/parser.py

@@ -0,0 +1,114 @@
+import yaml
+from pathlib import Path
+from specs import Spec
+from typing import List, Dict
+
+
+class InvalidKeyError(Exception):
+    def __init__(self, key):
+        message = "Invalid key: {}".format(key)
+
+        super().__init__(key)
+
+
+class MissingKeyError(Exception):
+    def __init__(self, key):
+        message = "Missing key: {}".format(key)
+
+        super().__init__(key)
+
+
+def parse_specs_file(path: Path) -> List[Spec]:
+    """
+    Parse a YAML file defining backup specs.
+
+    Args:
+        path: path to the specs file
+
+    Returns:
+        A list of specs
+    """
+
+    # Skeleton of a spec config
+    # If a value is None, this means it doesn't have a default value and must be
+    # defined
+    spec_skel = {
+        "source": None,
+        "destination": None,
+        "limit": None,
+        "volume": False,
+        "notify": {
+            "title": "Backup Notification",
+            "events": ["failure"]
+        }
+    }
+
+    # Read YAML file
+    with open(path, "r") as yaml_file:
+        data = yaml.load(yaml_file, Loader=yaml.Loader)
+
+    # Check specs section exists
+    if "specs" not in data:
+        raise MissingKeyError("specs")
+
+    # Allow for default notify settings
+    if "notify" in data:
+        spec_skel["notify"] = data["notify"]
+
+    specs = []
+    # Check format for each spec
+    for key in data["specs"]:
+        specs.append(Spec.from_dict(key, combine_with_skeleton(
+            data["specs"][key], spec_skel)
+        ))
+
+    return specs
+
+
+def combine_with_skeleton(data: Dict, skel: Dict) -> Dict:
+    """
+    Compare a dict with a given skeleton dict, and fill in default values where
+    needed.
+    """
+
+    # First, check for illegal keys
+    for key in data:
+        if key not in skel:
+            raise InvalidKeyError(key)
+
+    # Then, check the default values
+    for key, value in skel.items():
+        if key not in data:
+            # Raise error if there's not default value
+            if value is None:
+                raise MissingKeyError(key)
+
+            # Replace with default value
+            data[key] = value
+
+        # Error if value is not same type as default value
+        elif type(data[key]) != type(value) and value is not None:
+            raise TypeError("Invalid value type")
+
+        # Recurse into dicts
+        elif type(value) == dict:
+            data[key] = combine_with_skeleton(data[key], value)
+
+    return data
+
+
+# Test cases
+if __name__ == "__main__":
+    d1 = {
+        "a": 5
+    }
+    s1 = {
+        "a": 7,
+        "b": 2
+    }
+    r1 = {
+        "a": 5,
+        "b": 2
+    }
+
+    assert combine_with_skeleton(d1, s1) == r1

app/specs/specs.py

@@ -0,0 +1,149 @@
+from pathlib import Path
+from datetime import datetime
+import requests
+import os
+
+
+class Spec:
+    # Base class has no skeleton
+    __SKELETON = {}
+
+    def __init__(self, name, destination, limit, title, events=None):
+        self.name        = name
+        self.destination = Path(destination)
+        self.limit       = limit
+        self.title       = title
+        self.events      = [] if events is None else events
+
+    def to_dict(self):
+        return {
+            "name": self.name,
+            "destination": str(self.destination),
+            "limit": self.limit,
+            "notify": {
+                "title": self.title,
+                "events": self.events
+            }
+        }
+
+    def backup(self):
+        raise NotImplementedError()
+
+    def remove_redundant(self):
+        tarballs = sorted(self.destination.glob('*.tar.gz'),
+                          key=os.path.getmtime, reverse=True)
+
+        if len(tarballs) >= self.limit:
+            for path in tarballs[self.limit - 1:]:
+                path.unlink()
+
+    def notify(self, status_code):
+        if status_code:
+            if "failure" not in self.events:
+                return
+
+            message = "backup for {} failed.".format(self.name)
+
+        else:
+            if "success" not in self.events:
+                return
+
+            message = "backup for {} succeeded.".format(self.name)
+
+        # Read API key from env vars
+        try:
+            key = os.environ["IFTTT_API_KEY"]
+
+        # Don't send notification if there's not API key defined
+        except KeyError:
+            return
+
+        url = "https://maker.ifttt.com/trigger/{}/with/key/{}".format(
+            "phone_notifications",
+            key
+        )
+
+        data = {
+            "value1": self.title,
+            "value2": message
+        }
+
+        requests.post(url, data=data)
+
+    def get_filename(self):
+        return '{}_{}.tar.gz'.format(
+            self.name,
+            datetime.now().strftime('%Y-%m-%d_%H-%M-%S')
+        )
+
+    @staticmethod
+    def from_dict(name, data) -> "Specification":
+        if data.get("volume", False):
+            return VolumeSpec.from_dict(name, data)
+
+        return DirSpec.from_dict(name, data)
+
+    @staticmethod
+    def from_file(path: str):
+        with open(path, 'r') as yaml_file:
+            data = yaml.load(yaml_file, Loader=yaml.Loader)
+
+        return [Spec.from_dict(name, info)
+                for name, info in data["specs"].items()]
+
+
+class DirSpec(Spec):
+    def __init__(self, name, source, destination, limit, title, events=None):
+        super().__init__(name, destination, limit, title, events)
+
+        self.source = Path(source)
+
+    def backup(self):
+        self.remove_redundant()
+
+        status_code = os.system(
+            "tar -C '{}' -czf '{}' -- .".format(
+                self.source,
+                self.destination / self.get_filename()
+            )
+        )
+
+        self.notify(status_code)
+
+    @staticmethod
+    def from_dict(name, data):
+        return DirSpec(
+            name,
+            data["source"],
+            data["destination"],
+            data["limit"],
+            data["notify"]["title"],
+            data["notify"]["events"]
+        )
+
+class VolumeSpec(Spec):
+    def __init__(self, name, volume, destination, limit, title, events=None):
+        super().__init__(name, destination, limit, title, events)
+
+        self.volume = volume
+
+    def backup(self):
+        status_code = os.system(
+            "docker run --rm -v '{}:/from' -v '{}:/to' alpine:latest "
+            "tar -C /from -czf '/to/{}' -- .".format(
+                self.volume,
+                self.destination,
+                self.get_filename()
+            )
+        )
+
+    @staticmethod
+    def from_dict(name, data):
+        return VolumeSpec(
+            name,
+            data["source"],
+            data["destination"],
+            data["limit"],
+            data["notify"]["title"],
+            data["notify"]["events"]
+        )