#!/usr/bin/python3
import sys
from os import path
import os
import subprocess
import settings

def create_app(domain, app):
    domain_path = path.join(settings.ROOT, "sites-enabled", domain)
    domain_caddy_file_path = path.join(settings.ROOT, "sites-enabled", f"{domain}.caddy")
    app_path = path.join(domain_path, app)
    log_path = path.join(app_path, "log")

    if not path.exists(domain_path):
        print(f"Domain '{domain}' does not exists")
        return

    if path.exists(app_path):
        print(f"App '{app}' already exists under domain '{domain}'" )
        return

    os.makedirs(app_path, exist_ok=True)
    os.makedirs(log_path, exist_ok=True)

    deploy_file_path = path.join(app_path, f"deploy.toml" )
    deploy_file = open(deploy_file_path, "w")
    deploy_file.write(f"""healthcheck_url = "http://127.0.0.1/up"
healthcheck_interval = 5
max_healthchecks = 5

entrypoint = []

volumes = []

[env]
""")
    deploy_file.close()

    app_caddy_file_path = path.join(app_path, f"{app}.caddy" )
    app_caddy_file = open(app_caddy_file_path, "w")
    app_caddy_file.write(f"""@{app} path /{app} /{app}/*
route @{app} {{
	forward_auth authelia:9091 {{
		uri /api/authz/forward-auth
		copy_headers Remote-User Remote-Groups Remote-Email Remote-Name
	}}
	uri strip_prefix /{app}
	reverse_proxy {app}:8080
}}""")
    app_caddy_file.close()

    original_data = ""
    original_file = open(domain_caddy_file_path, 'r')
    original_data = original_file.read()
    original_file.close()

    modified_file = open(domain_caddy_file_path, 'w')
    modified_file.write(f"import {domain}/{app}/{app}.caddy\n{original_data}")
    modified_file.close()

    subprocess.run(["podman", "exec", "-w", "/etc/caddy", "caddy", "caddy", "reload"])

def main():
    if len(sys.argv) < 2:
        print("Correct syntaxis is podman-create-app domain/app-name")
        return

    args = [x.strip() for x in sys.argv[1].split("/")]
    if len(args) != 2 or args[0] == "" or args[1] == "":
        print("Correct syntaxis is podman-create-app domain/app-name")
        return

    create_app(args[0], args[1])

if __name__ == "__main__":
    main()

#!/usr/bin/python3
import sys
import os
import subprocess
import random
import string
import time
import tomllib
import json

from os import path
import settings as global_settings

def parse_settings(domain, app):
    settings = {
        'container_name': '',
        'log_file': '',
        'env': {},
        'app_path': '',
        'healthcheck_url': 'http://127.0.0.1/up',
        'volumes': [],
        'entrypoint': [],
        'healthcheck_interval': 5,
        'max_healthchecks': 5,
    }

    domain_path = path.join(global_settings.ROOT, "sites-enabled", domain)
    settings['app_path'] = path.join(domain_path, app)
    log_path = path.join(settings['app_path'], "log")

    if not path.exists(domain_path):
        raise Exception(f"Domain '{domain}' does not exists")

    if not path.exists(settings['app_path']):
        raise Exception(f"App '{app}' does not exists under domain '{domain}'" )

    deploy_settings_path = path.join(settings['app_path'], "deploy.toml")
    with open(deploy_settings_path, "rb") as f:
        deploy_settings = tomllib.load(f)
        settings['healthcheck_url'] = deploy_settings['healthcheck_url']
        settings['healthcheck_interval'] = deploy_settings['healthcheck_interval']
        settings['max_healthchecks'] = deploy_settings['max_healthchecks']

        if len(deploy_settings['entrypoint']) > 0:
            settings['entrypoint'] = json.dumps(deploy_settings['entrypoint'])

        settings['env'] = deploy_settings['env']
        settings['volumes'] = deploy_settings['volumes']

    random_string = ''.join(random.choices(string.ascii_lowercase + string.digits, k=6))
    settings['container_name'] = f"{app}-{random_string}"

    settings['log_file'] = path.join(log_path, settings['container_name']) 
    
    return settings

def create_container(settings):
    create_args = [
            "podman",
            "run", "-d",
            "--network", "podman",
            "--log-opt", f"path={settings['log_file']}",
            "--name", settings['container_name'],
            "--restart", "always"]
    for v in settings['volumes']:
        create_args.append("-v")
        create_args.append(v)
    for key,value in settings['env'].items():
        create_args.append("-e")
        create_args.append(f"{key}={value}")
    if len(settings['entrypoint']) > 0:
        create_args.append("--entrypoint")
        create_args.append(settings['entrypoint'])

    create_args.append(settings['image'])
    subprocess.run(create_args, stdout = subprocess.DEVNULL, cwd=settings['app_path'])

    pid = subprocess.run(["podman", "inspect", settings['container_name'], "-f", '{{.State.Pid}}'], capture_output=True)
    if pid.returncode != 0:
        raise Exception(f"Could not get pid of new container {pid.stderr}")
        return

    print(f"Waiting for container to be online...")
    is_up = False
    attempt = 0
    while not is_up and attempt < settings['max_healthchecks']:
        print(f"Waiting {settings['healthcheck_interval']} seconds")
        time.sleep(settings['healthcheck_interval'])
        print(f"Attempt {attempt + 1} to {settings['healthcheck_url']}")
        status = subprocess.run(["nsenter", "-t", pid.stdout.strip(), "-U", "-n", "curl", settings['healthcheck_url'], "-s", "-o", "/dev/null", "-w", "%{http_code}"], capture_output=True)
        is_up = status.returncode == 0 and (status.stdout == b"200" or status.stdout == b"404")
        attempt += 1

    if attempt == settings['max_healthchecks']:
        print(f"Container is created but not connected to the network")
        print(f"When ready run `podman network connect --alias {settings['app']} {global_settings.MAIN_NETWORK} {settings['container_name']}` to connect it")
        print(f"Current pods still alive")
        raise Exception(f"Failed to check health after {attempt} attempts")
    else:
        subprocess.run(["podman", "network", "connect", "--alias", settings['app'], global_settings.MAIN_NETWORK, settings['container_name']])

def remove_old_containers(settings):
    old_ids = subprocess.run(["podman", "ps", "--no-trunc", "--filter", "status=running", "--filter", f"name={settings['app']}-.*", "--format", "{{.Names}}"], capture_output=True, text=True)
    if old_ids.returncode != 0:
        raise Exception(f"Could not get ids of old containers {old_ids.stderr}")
        return

    for old_name in [str(name.strip()) for name in old_ids.stdout.splitlines()]:
        if old_name != settings['container_name']:
            subprocess.run(["podman", "stop", old_name], stdout = subprocess.DEVNULL, stderr = subprocess.DEVNULL)
            print(f"Removed old container '{old_name}'")

def deploy_app(domain, app, image):
    try:
        settings = parse_settings(domain,app)
        settings['image'] = image
        settings['app'] = app

        print(f"Creating container for '{domain}/{app}")
        create_container(settings)

        print(f"Removing old containers...")
        remove_old_containers(settings)
    except Exception as e:
        print(e)
        return

def main():
    if len(sys.argv) < 3:
        print("Correct syntaxis is podman-deploy-app domain/app-name image-identifier")
        return

    args = [x.strip() for x in sys.argv[1].split("/")]
    if len(args) != 2 or args[0] == "" or args[1] == "":
        print("Correct syntaxis is podman-deploy-app domain/app-name image-identifier")
        return


    deploy_app(args[0], args[1], sys.argv[2].strip())

if __name__ == "__main__":
    main()