def get(c): """This task synchronizes the server to the local machine""" inv_logging.task(get.__name__) settings = inv_base.read_settings("production") for rsync_task in settings["rsync_get"]: if "include" in settings["rsync_get"][rsync_task]: include = settings["rsync_get"][rsync_task]["include"] else: include = None if "exclude" in settings["rsync_get"][rsync_task]: exclude = settings["rsync_get"][rsync_task]["exclude"] else: exclude = None logging.info( f"The settings {rsync_task} from the settings.json file are used for the production." ) rsync_get(c, settings["REMOTE_USER"], settings["REMOTE_HOST"], settings["rsync_get"][rsync_task]["local_dir"], settings["rsync_get"][rsync_task]["remote_dir"], include, exclude) inv_logging.success(get.__name__)
def setproductionenvironment(c): """The task writes the environment variables on the server for django and docker. The created files are uploaded to the server and the required folders for cigsanalysistool are created.""" inv_logging.task(setproductionenvironment.__name__) settings = inv_base.read_settings("production") dict_env = setenvironment(c, "production") remote_env = { "django": os.path.join(settings["docker"]["INSTALLFOLDER"], "django/djangoVue/.env"), "docker": os.path.join(settings["docker"]["INSTALLFOLDER"], ".env") } inv_rsync.scp_push(c, settings["REMOTE_USER"], settings["REMOTE_HOST"], dict_env["docker"], remote_env["docker"]) inv_rsync.scp_push(c, settings["REMOTE_USER"], settings["REMOTE_HOST"], dict_env["django"], remote_env["django"]) os.system(f"rm {dict_env['docker']}") logging.info( f"The environment '{dict_env['docker']}' variable was deleted.") os.system(f"rm {dict_env['django']}") logging.info( f"The environment '{dict_env['django']}' variable was deleted.") for folder in settings['initFolders']: folder = os.path.join(settings["docker"]["INSTALLFOLDER"], folder) inv_rsync.ssh(c, settings["REMOTE_USER"], settings["REMOTE_HOST"], f"mkdir -p {folder}") inv_logging.success(setproductionenvironment.__name__)
def run(c, cmd): """Start a service from the Docker Compose file, for example: docker django""" inv_logging.task(run.__name__) user, group = inv_base.uid_gid(c) inv_logging.cmd(cmd) inv_base.docker_compose(c, f"run -u {user}:{group} {cmd}", pty=True) inv_logging.success(run.__name__)
def npm(c, cmd): """This task is used to respond to the packet manager npm, for example: npm install date-fns""" inv_logging.task(npm.__name__) user, group = inv_base.uid_gid(c) inv_logging.cmd(cmd) inv_base.docker_compose(c, f"run -u {user}:{group} node npm {cmd}", pty=True) inv_logging.success(npm.__name__)
def setenvironment(c, cmd): """The task writes the local environment variables for django and docker, for example: development""" inv_logging.task(setenvironment.__name__) inv_logging.cmd(cmd) settings = inv_base.read_settings(cmd) development_dir = os.getcwd() if cmd == "production": filename = ".env.production" else: filename = ".env" dict_env = { "django": os.path.join(development_dir, f"django/djangoVue/{filename}"), "docker": os.path.join(development_dir, f"{filename}") } for dict_env_key, dict_env_file in dict_env.items(): try: with open(dict_env_file, "w") as f: for key, value in settings[dict_env_key].items(): f.write(f"{key}={value}\n") f.close() logging.info(f"The environment variable for '{dict_env_key}'' from the settings.json file was successfully written to the .env file.: '{dict_env_file}'") except: logging.error( f"It was not possible to write to the file: '{dict_env_file}'") sys.exit(1) inv_logging.success(setenvironment.__name__) return dict_env
def build(c): """This task is used to build the Javascript components""" inv_logging.task(build.__name__) user, group = inv_base.uid_gid(c) inv_base.docker_compose(c, f"run -u {user}:{group} node npm run build", pty=True) logging.info("The Javascript components were built, minified and zipped.") inv_docker.stop(c) inv_logging.success(build.__name__)
def reset_db(c): """Resets postgres database and migrate django migrations.""" inv_logging.task(reset_db.__name__) inv_docker.stop(c) inv_base.manage_py(c, "reset_db") inv_docker.start(c) inv_django.makemigrations(c) inv_django.migrate(c) inv_logging.success(reset_db.__name__)
def deploy(c): """Everything you need to deploy""" inv_logging.task(deploy.__name__) c.run("./task.py local.node.build") c.run("./task.py local.django.collectstatic") inv_docker.stop(c) inv_rsync.push(c) setproductionenvironment(c) inv_docker.rebuild(c) inv_django.migrate(c) inv_docker.start(c) inv_logging.success(deploy.__name__)
def quickinstallation(c): """A task for quick installation of cigsanalysistool and start of a development server""" inv_logging.task(quickinstallation.__name__) folders(c) setenvironment(c, "development") inv_docker.rebuild(c) inv_node.npm(c, "install") inv_django.migrate(c) inv_django.createsuperuser(c) inv_django.loadexampledata(c) inv_node.build(c) inv_django.collectstatic(c) inv_docker.serve(c) inv_logging.success(quickinstallation.__name__)
def getdockercert(c): """A task to store the batch of docker certificates under ./fabric/cert""" inv_logging.task(getdockercert.__name__) settings = inv_base.read_settings("production") cert_path = settings["docker"]["DOCKER_CERT_PATH"] logging.info(f"The following path is used to store the certificates: {cert_path}") if os.path.exists(cert_path): shutil.rmtree(cert_path) logging.info("The old certificates were deleted.") if not os.path.exists(cert_path): os.mkdir(cert_path) logging.info(f"The {cert_path} folder was created.") inv_rsync.scp_get(c, "", settings["REMOTE_HOST"], "~/.docker/*", cert_path) inv_logging.success(getdockercert.__name__)
def get_last_production_backup(c): """With this task the last database dump can be downloaded from the server.""" inv_logging.task(get_last_production_backup.__name__) settings_development = inv_base.read_settings("development") settings_production = inv_base.read_settings("production") postgres_backup_server_folder = f"{settings_production['docker']['INSTALLFOLDER']}{settings_production['postgres_backup_server_folder']}" remote_postgresdata_backup_server_files = os.popen( f"ssh {settings_production['REMOTE_USER']}@{settings_production['REMOTE_HOST']} ls {postgres_backup_server_folder}" ).read().strip().split("\n") backup_file = f"{remote_postgresdata_backup_server_files[-1]}" inv_rsync.scp_get( c, settings_production["REMOTE_USER"], settings_production["REMOTE_HOST"], f"{postgres_backup_server_folder}/{backup_file}", f"{settings_development['postgres_backup_server_folder']}/{backup_file}" ) inv_logging.success(get_last_production_backup.__name__)
def starttest(c): """This function is used to start the production test environment""" inv_logging.task(starttest.__name__) static_folder = os.path.join(os.getcwd(), "django/static") try: shutil.rmtree(static_folder) logging.info(f"{static_folder} folder was deleted.") except: logging.error(f"{static_folder} could not be deleted.") inv_install.setenvironment(c, "test") inv_django.makemigrations(c) inv_django.migrate(c) inv_django.collectstatic(c) inv_base.docker_compose(c, f"up") inv_install.setenvironment(c, "development") inv_logging.success(starttest.__name__)
def folders(c): """This task is used to create the folder structure""" inv_logging.task(folders.__name__) for d in c.config["initFolders"]: d = os.path.join(os.getcwd(), d) if not os.path.exists(d): try: os.makedirs(d) logging.info(f"The folder {d} has been created.") except: logging.error(f"The folder {d} could not be created.") sys.exit(1) else: logging.warning(f"The folder {d} already exists.") inv_logging.success(folders.__name__)
def dump_production_backup(c): """With this task the production database can be dumped into a tar.gz file.""" inv_logging.task(dump_production_backup.__name__) dump_backup(c, host="production") inv_logging.success(dump_production_backup.__name__)
def docker(c, cmd): """The Task can execute a Docker command including cmd: docker ps""" inv_logging.task(restart.__name__) inv_logging.cmd(cmd) inv_base.dockerdaemon(c, cmd) inv_logging.success(restart.__name__)
def restart(c): """Restart all docker containers""" inv_logging.task(restart.__name__) inv_base.docker_compose(c, "up -d --remove-orphans") inv_logging.success(restart.__name__)
def rebuildhard(c): """Rebuild all containers with --no-cache""" inv_logging.task(rebuildhard.__name__) inv_base.docker_compose(c, "build --no-cache") fullrestart(c) inv_logging.success(rebuildhard.__name__)
def import_last_production_backup(c): """With this task the last production database dump can be imported from a tar.gz file.""" inv_logging.task(import_last_production_backup.__name__) read_backup(c, "postgres_backup_server_folder", "/var/backup", "production") inv_logging.success(import_last_production_backup.__name__)
def rebuild(c): """Rebuild all docker containers""" inv_logging.task(rebuild.__name__) inv_base.docker_compose(c, "build") restart(c) inv_logging.success(rebuild.__name__)
def serve(c): """Serve the development environment""" inv_logging.task(serve.__name__) inv_base.docker_compose(c, "up") inv_logging.success(serve.__name__)
def lint(c): """This task is used to embellish the code""" inv_logging.task(lint.__name__) user, group = inv_base.uid_gid(c) inv_base.docker_compose(c, f"run -u {user}:{group} node npm run lint", pty=True) inv_logging.success(lint.__name__)
def logs(c, cmd): """Show the log files from the Docker Services, for example: django""" inv_logging.task(logs.__name__) inv_base.docker_compose(c, 'logs -f {}'.format(cmd)) inv_logging.cmd(cmd) inv_logging.success(logs.__name__)
def stop(c): """Stop all running Docker Containers""" inv_logging.task(stop.__name__) inv_base.docker_compose(c, "down --remove-orphans") inv_logging.success(stop.__name__)
def start(c): """Start in detached Modus""" inv_logging.task(start.__name__) #inv_django.migrate(c) inv_base.docker_compose(c, "up -d") inv_logging.success(start.__name__)
def import_last_development_backup(c): """With this task the last development database dump can be imported from a tar.gz file.""" inv_logging.task(import_last_development_backup.__name__) read_backup(c, "postgres_backup_folder", "/var/backup", "development") inv_logging.success(import_last_development_backup.__name__)
def import_last_production_backup_into_local_db(c): """With this task the last production database dump can be imported from a tar.gz file into the local database.""" inv_logging.task(import_last_production_backup_into_local_db.__name__) read_backup(c, "postgres_backup_server_folder", "/var/backup_server", "development") inv_logging.success(import_last_production_backup_into_local_db.__name__)
def dump_development_backup(c): """With this task the development database can be dumped into a tar.gz file.""" inv_logging.task(dump_development_backup.__name__) dump_backup(c, host="development") inv_logging.success(dump_development_backup.__name__)
def fullrestart(c): """Restart all docker containers with force""" inv_logging.task(fullrestart.__name__) inv_base.docker_compose(c, "up -d --force-recreate") inv_logging.success(fullrestart.__name__)