First commit

Author: wibimaster

.gitignore

@@ -0,0 +1,10 @@
+# Byte-compiled / optimized / DLL files
+__pycache__/
+*.py[cod]
+*$py.class
+*.egg-info/
+dist/
+logfile.log
+.idea
+build/
+dist/

LICENSE

@@ -0,0 +1,37 @@
+# DevStroke ZDD
+
+Zero Downtime Deployment system with Docker
+
+## Installation
+
+### Pythonic way
+
+```sh
+pip install https://github.com/devstroke-io/zdd/archive/master.zip
+```
+
+### Download binary
+
+@TODO
+
+## Usage
+
+```sh
+Usage: zdd [OPTIONS] PROJECT [TAG]
+
+  Deploy PROJECT with TAG (default 'latest')
+
+Options:
+  -V, --version  Show the version and exit.
+  -q, --quiet    no output
+  -v, --verbose  verbosity level
+  -h, --help     Show this message and exit.
+```
+
+## Build binary
+
+```sh
+pyinstaller --onefile zdd.py
+```
+
+Produce binary `dist/zdd`

README.md

@@ -0,0 +1,61 @@
+from os.path import dirname, join
+
+from setuptools import find_packages, setup
+
+KEYWORDS = []
+CLASSIFIERS = [
+    'Intended Audience :: Developers',
+    'Programming Language :: Python :: 3.7',
+    'Programming Language :: Python :: Implementation :: CPython',
+    'Programming Language :: Python',
+    'Topic :: Software Development',
+    'Topic :: Utilities',
+]
+INSTALL_REQUIRES = [
+    'click==7.*',
+    'colorama==0.4.*',
+    'docker==3.*',
+    'pyinstaller==3.*',
+]
+
+PROJECT_DIR = dirname(__file__)
+README_FILE = join(PROJECT_DIR, 'README.md')
+ABOUT_FILE = join(PROJECT_DIR, 'src', 'zdd', '__about__.py')
+
+
+def get_readme():
+    with open(README_FILE) as fileobj:
+        return fileobj.read()
+
+
+def get_about():
+    about = {}
+    with open(ABOUT_FILE) as fileobj:
+        exec(fileobj.read(), about)
+    return about
+
+
+ABOUT = get_about()
+
+setup(
+    name=ABOUT['__title__'],
+    version=ABOUT['__version__'],
+    description=ABOUT['__summary__'],
+    long_description=get_readme(),
+    author=ABOUT['__author__'],
+    author_email=ABOUT['__email__'],
+    url=ABOUT['__uri__'],
+    keywords=KEYWORDS,
+    license=ABOUT['__license__'],
+    classifiers=CLASSIFIERS,
+    package_dir={'': 'src'},
+    packages=find_packages('src'),
+    entry_points={
+        'console_scripts': [
+            'zdd=zdd.__main__:main',
+        ],
+    },
+    install_requires=INSTALL_REQUIRES,
+    python_requires='>=3.7',
+    zip_safe=False
+)

setup.py

@@ -0,0 +1,13 @@
+"""Project metadata."""
+
+__version__ = '1.0.0'
+
+__title__ = 'zdd'
+__summary__ = "TODO"
+__uri__ = 'https://gitlabs.mybestpro/MyBestProLabs/JTChatBot/TODO'
+
+__author__ = "Damien JARRY"
+__email__ = '[email protected]'
+
+__copyright__ = "2018, DevStroke.io"
+__license__ = "AGPL-3.0-only"

src/zdd/__about__.py

@@ -0,0 +1,66 @@
+import signal
+import sys
+
+import click
+from colorama import Fore, Style
+
+from .__about__ import __version__
+from .services.deploy import Deploy
+from .services.logger import Logger
+
+logo = """
+███████╗██████╗ ██████╗                                                    
+╚══███╔╝██╔══██╗██╔══██╗                                                   
+  ███╔╝ ██║  ██║██║  ██║                                                   
+ ███╔╝  ██║  ██║██║  ██║                                                   
+███████╗██████╔╝██████╔╝                                                   
+╚══════╝╚═════╝ ╚═════╝                                                    
+██████╗ ███████╗██╗   ██╗███████╗████████╗██████╗  ██████╗ ██╗  ██╗███████╗
+██╔══██╗██╔════╝██║   ██║██╔════╝╚══██╔══╝██╔══██╗██╔═══██╗██║ ██╔╝██╔════╝
+██║  ██║█████╗  ██║   ██║███████╗   ██║   ██████╔╝██║   ██║█████╔╝ █████╗  
+██║  ██║██╔══╝  ╚██╗ ██╔╝╚════██║   ██║   ██╔══██╗██║   ██║██╔═██╗ ██╔══╝  
+██████╔╝███████╗ ╚████╔╝ ███████║   ██║   ██║  ██║╚██████╔╝██║  ██╗███████╗
+╚═════╝ ╚══════╝  ╚═══╝  ╚══════╝   ╚═╝   ╚═╝  ╚═╝ ╚═════╝ ╚═╝  ╚═╝╚══════╝
+"""
+
+
+def signal_handler(sig: int, frame: object) -> None:
+    """Handler for signals captured
+    :param sig: Signal identifier
+    :type sig: int
+    :param frame: Current stack frame
+    :type frame: object
+    :return: None
+    :rtype: None
+    """
+    if sig == signal.SIGINT:
+        sig_type = "SIGINT"
+    elif sig == signal.SIGTERM:
+        sig_type = "SIGTERM"
+    else:
+        sig_type = f"UNKNOWN ({sig})"
+    Logger.get('main').critical(f"Process interrupted ({sig_type})")
+    sys.exit(200)
+
+
+@click.command(context_settings={'help_option_names': ['-h', '--help']})
+@click.version_option(__version__, '-V', '--version')
+@click.argument('project', type=click.STRING, required=True)
+@click.argument('tag', type=click.STRING, required=False, default="latest")
+@click.option('-q', '--quiet', is_flag=True, help="no output")
+@click.option('-v', '--verbose', count=True, help="verbosity level")
+def main(project, tag, quiet, verbose) -> None:
+    """
+    Deploy PROJECT with TAG (default 'latest')
+    """
+    print(Fore.MAGENTA + Style.BRIGHT + logo + Style.RESET_ALL)
+    for sig_name in [signal.SIGINT, signal.SIGTERM]:
+        signal.signal(sig_name, signal_handler)
+    Logger.prepare('main', 1000 if quiet else 50 - verbose * 10)
+    deploy = Deploy(project, tag)
+    deploy.pull()
+    deploy.reload()
+
+
+if __name__ == '__main__':
+    main()

src/zdd/__init__.py

@@ -0,0 +1,53 @@
+import sys
+
+
+class Cursor:
+    @staticmethod
+    def move(line, column):
+        sys.stdout.write(f'\033[{line};{column}H')
+        sys.stdout.flush()
+
+    @staticmethod
+    def move_start():
+        sys.stdout.write(f'\r')
+        sys.stdout.flush()
+
+    @staticmethod
+    def erase_to_the_end():
+        sys.stdout.write(f'\033[K')
+        sys.stdout.flush()
+
+    @staticmethod
+    def move_up(count):
+        sys.stdout.write(f'\033[{count}A')
+        sys.stdout.flush()
+
+    @staticmethod
+    def move_down(count):
+        sys.stdout.write(f'\033[{count}B')
+        sys.stdout.flush()
+
+    @staticmethod
+    def move_forward(count):
+        sys.stdout.write(f'\033[{count}C')
+        sys.stdout.flush()
+
+    @staticmethod
+    def move_backward(count):
+        sys.stdout.write(f'\033[{count}D')
+        sys.stdout.flush()
+
+    @staticmethod
+    def clear_screen():
+        sys.stdout.write(f'\033[2J')
+        sys.stdout.flush()
+
+    @staticmethod
+    def save_position():
+        sys.stdout.write(f'\033[s')
+        sys.stdout.flush()
+
+    @staticmethod
+    def restore_position():
+        sys.stdout.write(f'\033[u')
+        sys.stdout.flush()

src/zdd/__main__.py

@@ -0,0 +1,134 @@
+import json
+import sys
+from pathlib import Path
+from time import sleep
+
+import docker
+from docker import DockerClient
+from docker.errors import NotFound, APIError
+
+from .configuration import Configuration
+from ...services.cursor import Cursor
+from ...services.logger import Logger
+
+
+class Deploy:
+    _client: DockerClient = None
+    _config: Configuration = None
+    _logger: Logger = Logger.get('main.zdd')
+    _project: str = None
+    _tag: str = None
+
+    def __init__(self, project: str, tag: str) -> None:
+        self._project = project
+        self._tag = tag
+        config = self.__fetch_config()
+        self._config = Configuration(**config)
+        self._client = docker.from_env()
+
+    def reload(self) -> None:
+        self._logger.info(f"Reload {self._config.docker_image}:{self._tag}")
+        image: dict = self._client.images.get(name=f'{self._config.docker_image}:{self._tag}')
+        if not image:
+            self._logger.critical(f"Cannot find image {self._config.docker_image}:{self._tag} locally")
+            sys.exit(120)
+        self.__reload_instance(1)
+        self.__reload_instance(2)
+
+    def pull(self) -> None:
+        """Pull project's Docker image
+        :return: None
+        :rtype: None
+        """
+        self._logger.info(f"Pull {self._config.docker_image}:{self._tag}")
+        lines = {}
+        api_client = docker.APIClient()
+        try:
+            for line in api_client.pull(self._config.docker_image, tag=self._tag, stream=True):
+                line = json.loads(line)
+                if 'id' in line:
+                    if line['id'] not in lines:
+                        lines[line['id']] = {
+                            'status': None,
+                            'progress': None
+                        }
+                        sys.stdout.write('\n')
+                    if 'progress' in line:
+                        lines[line['id']]['progress'] = line['progress']
+                    if 'status' in line:
+                        lines[line['id']]['status'] = line['status']
+                    index = list(lines).index(line['id'])
+                    move = len(list(lines)) - index
+                    Cursor.move_up(move)
+                    Cursor.move_start()
+                    Cursor.erase_to_the_end()
+                    sys.stdout.write(f"{line['id']}: {lines[line['id']]['status']}")
+                    if lines[line['id']]['status'] == 'Downloading' and lines[line['id']]['progress'] is not None:
+                        sys.stdout.write(f" {lines[line['id']]['progress']}")
+                    Cursor.move_down(move)
+                    Cursor.move_start()
+                elif 'status' in line:
+                    print(f"{line['status']}")
+        except NotFound:
+            self._logger.critical(f"'{self._config.docker_image}:{self._tag}' not found on Docker HUB")
+            sys.exit(110)
+
+    def __reload_instance(self, instance: int) -> None:
+        image = f'{self._config.docker_image}:{self._tag}'
+        container_name = f'{self._project}_{instance}'
+        params = self._config.get_params(instance)
+        # stop instance
+        try:
+            container = self._client.containers.get(container_name)
+        except NotFound:
+            container = None
+        if container:
+            self._logger.info(f"Stop {container_name} instance...")
+            container.stop()
+            self._logger.info(f"{container_name} instance stopped")
+        # run instance
+        self._logger.info(f"Start {container_name} instance...")
+        try:
+            self._client.containers.run(
+                image,
+                name=container_name,
+                **params
+            )
+            self._logger.info(f"{container_name} instance running")
+        except APIError as e:
+            self._logger.critical(f"Fail to run {container_name} with {str(e)}")
+            sys.exit(130)
+        # @TODO(damien): Check if instance is really up (request :port ?)
+        sleep(1)
+
+    def __fetch_config(self) -> dict:
+        """Get and decode JSON configuration file content
+        :return: Project configuration from JSON
+        :rtype: dict
+        """
+        try:
+            file = str(Path.home()) + '/.config/zdd.json'
+            self._logger.info(f"Fetch configuration file ({file})")
+            with open(file) as content:
+                config = json.load(content)
+        except FileNotFoundError:
+            self._logger.critical(f"Cannot find configuration file ({file})")
+            sys.exit(100)
+        except json.JSONDecodeError:
+            self._logger.critical(f"Cannot decode configuration file ({file})")
+            sys.exit(101)
+        if 'projects' not in config:
+            self._logger.critical(f"'projects' key missing in configuration file ({file})")
+            sys.exit(102)
+        if self._project not in config['projects']:
+            self._logger.critical(f"Project '{self._project}' not in configuration file ({file})")
+            sys.exit(103)
+        if not config['projects'][self._project]['active']:
+            self._logger.critical(f"Project '{self._project}' is deactivated in configuration file ({file})")
+            sys.exit(104)
+        if 'docker_image' not in config['projects'][self._project]:
+            self._logger.critical(
+                f"Missing 'docker_image' key for project '{self._project}' in configuration file ({file})")
+            sys.exit(105)
+        self._logger.debug(config['projects'][self._project])
+        return config['projects'][self._project]