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__)
