Merge pull request #4 from py-package/feature/commands

Feature/commands

Author: yubarajshrestha

.github/workflows/pythonapp.yml

@@ -1,6 +1,8 @@
 name: Test Application
 
-on: [push, pull_request]
+on:
+  pull_request:
+    branches: [master]
 
 jobs:
   build:

.gitignore

@@ -13,4 +13,5 @@ coverage.xml
 dist
 .env
 *.db
-src/masonite_backup.egg-info
+src/masonite_backup.egg-info
+storage

makefile

@@ -17,7 +17,7 @@ ci: ## [CI] Run package tests and lint
 lint: ## Run code linting
 	python -m flake8 .
 format: ## Format code with Black
-	black .
+	black src
 coverage: ## Run package tests and upload coverage reports
 	python -m pytest --cov-report term --cov-report xml --cov=src/masonite/backup tests
 publish: ## Publish package to pypi

src/backup/Backup.py

@@ -0,0 +1,96 @@
+# flake8: noqa F501
+import pathlib
+import shutil
+import tempfile
+from unittest.mock import patch
+from masonite.configuration import config
+from shutil import make_archive
+from datetime import datetime
+from masonite.utils.location import base_path
+import subprocess
+import gzip
+
+
+class Backup:
+    def __init__(self, application) -> None:
+        self.app = application
+        self.backup_config = config("backup")
+
+    def accept(self, path):
+        for pattern in self.backup_config.get("source").get("excludes"):
+            if pattern in path:
+                return False
+        return True
+
+    def database(self):
+        """
+        Backup the database.
+        """
+
+        db_config = config("database.databases")
+        default = db_config.get("default")
+        connection = db_config.get(default)
+        driver = connection.get("driver")
+
+        db_file_path = base_path(
+            "{}.gz".format("database-" + str(datetime.timestamp(datetime.now())))
+        )
+
+        if driver == "sqlite":
+            pass
+        elif driver == "mysql":
+            command_str = f"mysqldump -u {connection.get('user')} -p{connection.get('password')} {connection.get('database')}"
+
+        elif driver == "postgres":
+            command_str = f"pg_dump -U{connection.get('user')} -h{connection.get('host')} -p{connection.get('port')} -d{connection.get('database')}"
+
+        elif driver == "mssql":
+            command_str = f"sqlcmd -S{connection.get('host')} -U{connection.get('user')} -P{connection.get('port')} -d{connection.get('database')}"
+
+        elif driver == "sqlserver":
+            command_str = f"sqlcmd -S{connection.get('host')} -U{connection.get('user')} -P{connection.get('port')} -d{connection.get('database')}"
+
+        elif driver == "oracle":
+            command_str = f"sqlplus -S{connection.get('user')}/{connection.get('password')}@{connection.get('host')}:{connection.get('port')}/{connection.get('database')}"
+
+        if command_str:
+            with gzip.open(db_file_path, "wb") as f:
+                popen = subprocess.Popen(
+                    [command_str],
+                    stdout=subprocess.PIPE,
+                    shell=True,
+                    universal_newlines=True,
+                )
+                for stdout_line in iter(popen.stdout.readline, ""):
+                    f.write(stdout_line.encode("utf-8"))
+                popen.stdout.close()
+                popen.wait()
+        return db_file_path
+
+    def files(self):
+        """
+        Backup the files.
+        """
+        filename = (
+            self.backup_config.get("filename", "backup")
+            + "-"
+            + str(datetime.timestamp(datetime.now()))
+        )
+
+        output_dir = base_path("storage/backup")
+
+        if not pathlib.Path(output_dir).exists():
+            pathlib.Path(output_dir).mkdir(parents=True, exist_ok=True)
+
+        path_to_archive = pathlib.Path(output_dir).joinpath(filename)
+
+        with tempfile.TemporaryDirectory() as tmp:
+            shutil.copytree(
+                self.backup_config.get("source").get("root"),
+                pathlib.Path(tmp).joinpath("backup"),
+                ignore=shutil.ignore_patterns(*self.backup_config.get("source").get("excludes")),
+            )
+
+            with patch("os.path.isfile", side_effect=self.accept):
+                make_archive(path_to_archive, "zip", tmp)
+        return path_to_archive

src/backup/commands/BackupRunCommand.py

@@ -0,0 +1,42 @@
+import os
+from masonite.commands import Command
+
+
+class BackupRunCommand(Command):
+    """
+    Start the backup process.
+
+    backup:run
+        {--filename : Backup filename}
+        {--only-db : Backup database only}
+        {--only-files : Backup files only}
+    """
+
+    def __init__(self, application):
+        super().__init__()
+        self.app = application
+
+    def handle(self):
+        if not self.validate_options():
+            return
+
+        if self.option("only-db"):
+            self.app.make("backup").database()
+        elif self.option("only-files"):
+            self.app.make("backup").files()
+        else:
+            self.info("Backuping database...")
+            database_file_path = self.app.make("backup").database()
+            self.info("Backuping files...")
+            self.app.make("backup").files()
+
+            # delete the database file
+            os.remove(database_file_path)
+
+        self.info("============ Backup complete ============")
+
+    def validate_options(self):
+        if self.option("only-db") and self.option("only-files"):
+            self.error("You can only pass either files or database backup option.")
+            return False
+        return True

src/backup/commands/__init__.py

@@ -0,0 +1,2 @@
+# flake8: noqa F401
+from .BackupRunCommand import BackupRunCommand

src/backup/config/backup.py

@@ -1,12 +1,26 @@
+# flake8: noqa F501
 """Backup Settings"""
 
+from masonite.utils.location import base_path
+
 """
 |--------------------------------------------------------------------------
-| A Heading of The Setting Being Set
+| Masonite Backup
 |--------------------------------------------------------------------------
 |
-| A quick description
+| This is the configuration file for the Masonite Backup package.
 |
 """
 
-SETTING = "some value"
+FILENAME = "backup"  # The filename of the backup file. (without the extension)
+DIRECTORY = "backup"  # storage/backup
+SOURCE = {
+    "root": base_path(),
+    "excludes": [
+        ".git",
+        "storage",
+        "venv",
+        "node_modules",
+        "__pycache__",
+    ],
+}

src/backup/providers/BackupProvider.py

@@ -1,21 +1,21 @@
 """A BackupProvider Service Provider."""
 
 from masonite.packages import PackageProvider
+from ..Backup import Backup
+from ..commands import BackupRunCommand
 
 
 class BackupProvider(PackageProvider):
-
     def configure(self):
         """Register objects into the Service Container."""
-        (
-            self.root("backup")
-            .name("backup")
-            .config("config/backup.py", publish=True)
-        )
+        (self.root("backup").name("backup").config("config/backup.py", publish=True))
 
     def register(self):
         super().register()
 
+        self.application.bind("backup", Backup(application=self.application))
+        self.application.make("commands").add(BackupRunCommand(application=self.application))
+
     def boot(self):
         """Boots services required by the container."""
         pass

src/backup/providers/__init__.py

@@ -1,2 +1,2 @@
 # flake8: noqa: E501
-from .BackupProvider import BackupProvider
+from .BackupProvider import BackupProvider

tests/integrations/config/providers.py

@@ -50,4 +50,4 @@
     ORMProvider
 ]
 
-PROVIDERS += [ BackupProvider ]
+PROVIDERS += [BackupProvider]