appmgr_build

#!/usr/bin/env python3

from os import supports_bytes_environ
from os.path import abspath
import sys
import yaml
import argparse
import os
import shutil
import configparser
import itertools
from pathlib import Path
import subprocess
import time
import shlex


# INTERNAL DIRECTORIES
# Move these to a seperate file
dirname = os.path.dirname(os.path.abspath(__file__))
RELEASE_CONF_DIR = os.path.join(dirname, "release_configs")
SPEC_DIR = os.path.join(dirname, "build/specs")
RPM_DIR = os.path.join(dirname, "RPMS")
ARCHIVE_DIR = os.path.join(dirname, "build/archives")
KEY_DIR = os.path.join(dirname, "build/archives/keys")
RPM_SOURCE_DIR = os.path.join(dirname, "build/archives/sources")


def archive_dir(package, *args):
    return os.path.join(ARCHIVE_DIR, package, *args)


def pkg_source_dir(package, *args):
    return archive_dir(package, "sources", *args)


def pkg_config_dir(package, *args):
    return archive_dir(package, "configs", *args)


def pkg_data_dir(package, *args):
    return archive_dir(package, "data", *args)

def pkg_service_dir(package, *args):
    return archive_dir(package, "service", *args)

def key_dir(*args):
    return archive_dir("keys", *args)

def get_build_version():
    try:
        proc = subprocess.run(
            "git rev-parse HEAD",
            shell=True,
            stdout=subprocess.PIPE,
            check=True,
        )
    except subprocess.CalledProcessError:
        return "unknown"
    else:
        return proc.stdout.decode().strip()

def list_of_strings(arg):
    return arg.split(',')

parser = argparse.ArgumentParser()

group = parser.add_mutually_exclusive_group(required=True)


parser.add_argument(
    "-p", "--package_names", type=list_of_strings, help="Package name to be built"
)
parser.add_argument(
    '--containerz', dest="containerz", default=False, help="option for containerz", action="store_true"
)
group.add_argument(
    "-b", "--build-config", dest="config", help="build configuration"
)
group.add_argument(
    "-c", "--clean", action="store_true", help="clean up build directories"
)

args = parser.parse_args()


def clean():
    shutil.rmtree(SPEC_DIR, ignore_errors=True)
    shutil.rmtree(ARCHIVE_DIR, ignore_errors=True)
    for f in Path(RPM_DIR).glob("**/*.rpm"):
        shutil.rmtree(f, ignore_errors=True)
    shutil.rmtree(Path(KEY_DIR), ignore_errors=True)


if args.clean:
    clean()
    sys.exit(0)

with open(args.config) as f:
    config = yaml.load(f, Loader=yaml.FullLoader)

release_conf = configparser.ConfigParser()

build_version = get_build_version()
print("Build version: {}".format(build_version))

def normjoin(path, *args):
    return os.path.normpath(os.path.join(path, *args))

def make_owner_rpm_spec(package, pre, post, preun, install, files):
    install.append("# Sources")
    source_dest = os.path.join(release_conf["paths"]["appmgr_source"], "owner")
    install.append("mkdir -p %{{buildroot}}{}".format(source_dest))
    source_list = package.get("sources")
    if source_list:
        source_name = source_list[0]["name"]
        files.append("%defattr(-,root,root)")
        files.append("{}".format(os.path.join(source_dest, source_name)))
        files.append(
            "%dir {}".format(os.path.join(source_dest, source_name))
        )
        files.append(
            os.path.join(
                source_dest, source_name, os.path.basename(source_list[0]["file"])
            )
        )
        install.append(
            "cp -ar {} %{{buildroot}}{}".format(
                os.path.join("sources", source_name), source_dest
            )
        )
        pre.append(
            "rm -rf $RPM_INSTALL_PREFIX{}".format(
                os.path.join(source_dest, source_name)
            )
        )

    install.append("")
    install.append("# Config directory")
    config_list = package.get("config-dir")
    if config_list:
        config_name = config_list[0]["name"]
        conf_dest = os.path.join(release_conf["paths"]["appmgr_source"], "owner", config_name, "config")
        conf_dir = os.path.join("configs", config_name)
        install.append("mkdir -p %{{buildroot}}{}".format(conf_dest))
        files.append("%dir {}".format(conf_dest))
        install.append(
            "cp -arT {} %{{buildroot}}{}".format(conf_dir, conf_dest)
        )

        prefix = pkg_config_dir(package_name, config_name)
        for root, subdirs, subfiles in os.walk(prefix):
            # Make path relative to pkg_conf_dir
            root = os.path.relpath(root, start=prefix)
            for name in subdirs:
                files.append("%dir {}".format(normjoin(conf_dest, root, name)))
            for name in subfiles:
                files.append("{}".format(normjoin(conf_dest, root, name)))

        if package.get("copy_ems_cert"):
            post.append(
                "cp /misc/config/grpc/ems.pem $RPM_INSTALL_PREFIX{}".format(
                    conf_dest
                )
            )
            preun.append(
                "rm -rf {}".format(
                    os.path.join("$RPM_INSTALL_PREFIX" + conf_dest, "ems.pem")
                )
            )

        if package.get("copy_hostname"):
            post.append(
                "cp /etc/hostname $RPM_INSTALL_PREFIX{}".format(conf_dest)
            )
            preun.append(
                "rm -rf {}".format(
                    os.path.join("$RPM_INSTALL_PREFIX" + conf_dest, "hostname")
                )
            )

    install.append("")
    install.append("# Data directory")
    data_list = package.get("data-dir")
    if data_list:
        data_name = data_list[0]["name"]
        # Destination directory
        data_dest = os.path.join(
            release_conf["paths"]["appmgr_source"], "owner",
            data_name, "data"
        )
        # Directory to copy
        data_dir = os.path.join("data", data_name)
        pre.append("rm -rf $RPM_INSTALL_PREFIX{}".format(data_dest))
        install.append("mkdir -p %{{buildroot}}{}".format(data_dest))
        files.append("%dir {}".format(data_dest))
        install.append(
            "cp -arT {} %{{buildroot}}{}".format(data_dir, data_dest)
        )

        prefix = pkg_data_dir(package_name, data_name)
        for root, subdirs, subfiles in os.walk(prefix):
            # Make path relative to pkg_data_dir
            root = os.path.relpath(root, start=prefix)
            for name in subdirs:
                files.append("%dir {}".format(normjoin(data_dest, root, name)))
            for name in subfiles:
                files.append("{}".format(normjoin(data_dest, root, name)))

    install.append("")
    install.append("# Service directory")
    service_list = package.get("service-dir")
    if args.containerz and service_list:
        service_name = service_list[0]["name"]
        # Destination directory
        service_dest = os.path.join(
            release_conf["paths"]["appmgr_source"], "owner",
            service_name, "service"
        )
        # Directory to copy
        service_dir = os.path.join("service", service_name)
        pre.append("rm -rf $RPM_INSTALL_PREFIX{}".format(service_dest))
        install.append("mkdir -p %{{buildroot}}{}".format(service_dest))
        files.append("%dir {}".format(service_dest))
        install.append(
            "cp -arT {} %{{buildroot}}{}".format(service_dir, service_dest)
        )

        prefix = pkg_service_dir(package_name, service_name)
        for root, subdirs, subfiles in os.walk(prefix):
            # Make path relative to pkg_service_dir
            root = os.path.relpath(root, start=prefix)
            for name in subdirs:
                files.append("%dir {}".format(normjoin(service_dest, root, name)))
            for name in subfiles:
                files.append("{}".format(normjoin(service_dest, root, name)))


def make_partner_rpm_spec(package, pre, post, preun, install, files):
    install.append("# Sources")
    source_dest = os.path.join(release_conf["paths"]["appmgr_source"], "partner", package["partner-name"])
    source_list = package.get("sources")
    if source_list:
        source_name = source_list[0]["name"]
        install.append("mkdir -p %{{buildroot}}{}".format(source_dest))
        files.append("%defattr(-,root,root)")
        files.append(source_dest)
        files.append(
            "%dir {}".format(os.path.join(source_dest, source_name))
        )
        files.append(
            os.path.join(
                source_dest, source_name, os.path.basename(source_list[0]["file"])
            )
        )
        install.append(
            "cp -ar {} %{{buildroot}}{}".format(
                os.path.join("sources", source_name), source_dest
            )
        )
        pre.append(
            "rm -rf $RPM_INSTALL_PREFIX{}".format(
                os.path.join(source_dest, source_name)
            )
        )

    install.append("")
    install.append("# Config directory")
    config_list = package.get("config-dir")
    if config_list:
        config_name = config_list[0]["name"]
        conf_dest = os.path.join(release_conf["paths"]["appmgr_source"], "partner", package["partner-name"], config_name,"config")
        conf_dir = os.path.join("configs", config_name)
        install.append("mkdir -p %{{buildroot}}{}".format(conf_dest))
        files.append("%dir {}".format(conf_dest))
        install.append(
            "cp -arT {} %{{buildroot}}{}".format(conf_dir, conf_dest)
        )

        prefix = pkg_config_dir(package_name, config_name)
        for root, subdirs, subfiles in os.walk(prefix):
            # Make path relative to pkg_conf_dir
            root = os.path.relpath(root, start=prefix)
            for name in subdirs:
                files.append("%dir {}".format(normjoin(conf_dest, root, name)))
            for name in subfiles:
                files.append("{}".format(normjoin(conf_dest, root, name)))

        if package.get("copy_ems_cert"):
            post.append(
                "cp /misc/config/grpc/ems.pem $RPM_INSTALL_PREFIX{}".format(
                    conf_dest
                )
            )
            preun.append(
                "rm -rf {}".format(
                    os.path.join("$RPM_INSTALL_PREFIX" + conf_dest, "ems.pem")
                )
            )

        if package.get("copy_hostname"):
            post.append(
                "cp /etc/hostname $RPM_INSTALL_PREFIX{}".format(conf_dest)
            )
            preun.append(
                "rm -rf {}".format(
                    os.path.join("$RPM_INSTALL_PREFIX" + conf_dest, "hostname")
                )
            )

    install.append("")
    install.append("# Data directory")
    data_list = package.get("data-dir")
    if data_list:
        data_name = data_list[0]["name"]
        # Destination directory
        data_dest = os.path.join(
            release_conf["paths"]["appmgr_source"], "partner", package["partner-name"],
            data_name, "data"
        )
        # Directory to copy
        data_dir = os.path.join("data", data_name)
        pre.append("rm -rf $RPM_INSTALL_PREFIX{}".format(data_dest))
        install.append("mkdir -p %{{buildroot}}{}".format(data_dest))
        files.append("%dir {}".format(data_dest))
        install.append(
            "cp -arT {} %{{buildroot}}{}".format(data_dir, data_dest)
        )
        prefix = pkg_data_dir(package_name, data_name)
        for root, subdirs, subfiles in os.walk(prefix):
            # Make path relative to pkg_data_dir
            root = os.path.relpath(root, start=prefix)
            for name in subdirs:
                files.append("%dir {}".format(normjoin(data_dest, root, name)))
            for name in subfiles:
                files.append("{}".format(normjoin(data_dest, root, name)))

    install.append("")
    install.append("# Service directory")
    service_list = package.get("service-dir")
    if args.containerz and service_list:
        service_name = service_list[0]["name"]
        # Destination directory
        service_dest = os.path.join(
            release_conf["paths"]["appmgr_source"], "partner", package["partner-name"],
            service_name, "service"
        )
        # Directory to copy
        service_dir = os.path.join("service", service_name)
        pre.append("rm -rf $RPM_INSTALL_PREFIX{}".format(service_dest))
        install.append("mkdir -p %{{buildroot}}{}".format(service_dest))
        files.append("%dir {}".format(service_dest))
        install.append(
            "cp -arT {} %{{buildroot}}{}".format(service_dir, service_dest)
        )

        prefix = pkg_service_dir(package_name, service_name)
        for root, subdirs, subfiles in os.walk(prefix):
            # Make path relative to pkg_service_dir
            root = os.path.relpath(root, start=prefix)
            for name in subdirs:
                files.append("%dir {}".format(normjoin(service_dest, root, name)))
            for name in subfiles:
                files.append("{}".format(normjoin(service_dest, root, name)))



def make_native_rpm_spec(package, pre, post, preun, install, files):
    install.append("# Sources")
    source_dest = release_conf["paths"]["appmgr_source"]
    install.append("mkdir -p %{{buildroot}}{}".format(source_dest))
    source_list = package.get("sources")
    if source_list:
        source_name = source_list[0]["name"]
        files.append(
            "%dir {}".format(os.path.join(source_dest, source_name))
        )
        files.append(
            os.path.join(
                source_dest, source_name, os.path.basename(source_list[0]["file"])
            )
        )
        install.append(
            "cp -ar {} %{{buildroot}}{}".format(
                os.path.join("sources", source_name), source_dest
            )
        )
        pre.append(
            "rm -rf $RPM_INSTALL_PREFIX{}".format(
                os.path.join(source_dest, source_name)
            )
        )

    install.append("")
    install.append("# Config directory")
    config_list = package.get("config-dir")
    if config_list:
        config_name = config_list[0]["name"]
        conf_dest = os.path.join(release_conf["paths"]["appmgr_config"],config_name)

        conf_dir = os.path.join("configs", config_name)
        pre.append("rm -rf $RPM_INSTALL_PREFIX{}".format(conf_dest))
        install.append("mkdir -p %{{buildroot}}{}".format(conf_dest))
        files.append("%dir {}".format(conf_dest))
        install.append(
            "cp -arT {} %{{buildroot}}{}".format(conf_dir, conf_dest)
        )

        prefix = pkg_config_dir(package_name, config_name)
        for root, subdirs, subfiles in os.walk(prefix):
            # Make path relative to pkg_conf_dir
            root = os.path.relpath(root, start=prefix)
            for name in subdirs:
                files.append("%dir {}".format(normjoin(conf_dest, root, name)))
            for name in subfiles:
                files.append("{}".format(normjoin(conf_dest, root, name)))

        if package.get("copy_ems_cert"):
            post.append(
                "cp /misc/config/grpc/ems.pem $RPM_INSTALL_PREFIX{}".format(
                    conf_dest
                )
            )
            preun.append(
                "rm -rf {}".format(
                    os.path.join("$RPM_INSTALL_PREFIX" + conf_dest, "ems.pem")
                )
            )

        if package.get("copy_hostname"):
            post.append(
                "cp /etc/hostname $RPM_INSTALL_PREFIX{}".format(conf_dest)
            )
            preun.append(
                "rm -rf {}".format(
                    os.path.join("$RPM_INSTALL_PREFIX" + conf_dest, "hostname")
                )
            )

    install.append("")
    install.append("# Data directory")
    data_list = package.get("data-dir")
    if data_list:
        data_name = data_list[0]["name"]
        # Directory to copy
        data_dir = os.path.join("data", data_name)
        # Destination directory
        data_dest = os.path.join(
            release_conf["paths"]["appmgr_data"],
            data_name,
        )
        pre.append("rm -rf $RPM_INSTALL_PREFIX{}".format(data_dest))
        install.append("mkdir -p %{{buildroot}}{}".format(data_dest))
        files.append("%dir {}".format(data_dest))
        install.append(
            "cp -arT {} %{{buildroot}}{}".format(data_dir, data_dest)
        )

        prefix = pkg_data_dir(package_name, data_name)
        for root, subdirs, subfiles in os.walk(prefix):
            # Make path relative to pkg_data_dir
            root = os.path.relpath(root, start=prefix)
            for name in subdirs:
                files.append("%dir {}".format(normjoin(data_dest, root, name)))
            for name in subfiles:
                files.append("{}".format(normjoin(data_dest, root, name)))

def make_pscript_rpm_spec(package, pre, post, preun, install, files):
    install.append("# Sources")
    source_dest = os.path.join(release_conf["paths"]["appmgr_source"], "exec")
    source_list = package.get("sources")
    if source_list:
        source_name = source_list[0]["name"]
        install.append("mkdir -p %{{buildroot}}{}".format(source_dest))
        files.append("%defattr(-,root,root)")
        files.append(source_dest)
        files.append(
            "%dir {}".format(os.path.join(source_dest, source_name))
        )
        install.append(
            "cp -ar {} %{{buildroot}}{}".format(
                os.path.join("sources", source_name), source_dest
            )
        )
        pre.append(
            "rm -rf $RPM_INSTALL_PREFIX{}".format(
                os.path.join(source_dest, source_name)
            )
        )


def make_ownerpscript_rpm_spec(package, pre, post, preun, install, files):
    install.append("# Sources")
    source_dest = os.path.join(release_conf["paths"]["appmgr_source"], "exec")
    source_list = package.get("sources")
    if source_list:
        source_name = source_list[0]["name"]
        install.append("mkdir -p %{{buildroot}}{}".format(source_dest))
        files.append("%defattr(-,root,root)")
        files.append(source_dest)
        files.append(
            "%dir {}".format(os.path.join(source_dest, source_name))
        )
        install.append(
            "cp -ar {} %{{buildroot}}{}".format(
                os.path.join("sources", source_name), source_dest
            )
        )
        pre.append(
            "rm -rf $RPM_INSTALL_PREFIX{}".format(
                os.path.join(source_dest, source_name)
            )
        )

def make_spec(package):
    # Seperate out by section
    headers = []
    prep = []
    install = []
    files = []
    pre = []
    post = []
    preun = []

    # Header
    headers.append("Name: {}".format(package["name"]))
    headers.append("Version: {}".format(package["version"]))
    if 'target-release' in package:
        package_name = "{name}-{version}-{target-release}".format(**package)
        headers.append("Release: {}".format(package["target-release"]))
    else:
        package_name = "{name}-{version}".format(**package)
        headers.append("Release: {}".format(package["release"]))
    # TODO: is this ok?
    headers.append(
        "License: Copyright (c) 2024 Cisco Systems Inc. All rights reserved"
    )
    headers.append("Packager: cisco")
    headers.append("SOURCE0 : {}.tar.gz".format(package_name))
    headers.append("Group: 3rd party application")
    if 'target-release' in package:
        headers.append(
            "Summary: {name} {version} compiled for IOS-XR {target-release}".format(
                **package
            )
        )
    else:
        headers.append(
            "Summary: {name} {version} compiled for IOS-XR {release}".format(
                **package
            )
        )
    headers.append("")
    headers.append("Prefix: /")
    headers.append("")
    headers.append("%description")
    headers.append("RPM built for use with IOS-XR appmgr.")
    headers.append("")
    headers.append("XR-appmgr-build version: {}".format(build_version))

    # init prep section
    prep.append("")
    prep.append("%prep")
    prep.append("%setup -q -n {}".format(package_name))
    prep.append("")

    # init pre section
    pre.append("")
    pre.append("%pre")

    # init post section
    post.append("")
    post.append("%post")

    # init preun section
    preun.append("")
    preun.append("%preun")

    # init install section
    install.append("")
    install.append("%install")
    install.append("")

    # init files section
    files.append("")
    files.append("%files")


    if package["name"].startswith('owner-pscript'):
        make_ownerpscript_rpm_spec(package, pre, post, preun, install, files)

    elif package["name"].startswith('pscript'):
        make_pscript_rpm_spec(package, pre, post, preun, install, files)

    elif package["name"].startswith('owner-'):
        make_owner_rpm_spec(package, pre, post, preun, install, files)

    elif package["name"].startswith('partner-'):
        make_partner_rpm_spec(package, pre, post, preun, install, files)

    else:
        make_native_rpm_spec(package, pre, post, preun, install, files)

    if release_conf["build"].getboolean("script_support"):
        sections = itertools.chain(headers, prep, install, files, pre, post, preun)
    else:
        sections = itertools.chain(headers, prep, install, files)

    # Concatenate and join the sections
    return "\n".join(sections)


clean()

def add_partner_rpm_files(package, package_name):
    rpm_type = package["name"]
    release_conf.read(
        os.path.join(RELEASE_CONF_DIR, rpm_type.split('-')[0] +".ini")
    )

    print("Building docker image {}...".format(release_conf["build"]["image"]))

    try:
        subprocess.run(["make", release_conf["build"]["image"]], cwd=dirname)
    except subprocess.CalledProcessError:
        print(
            "Could not build docker image {}".format(
                release_conf["build"]["image"]
            )
        )
        sys.exit(1)

    print("Adding sources...")
    source_list = package.get("sources")
    if source_list:
        source_name = source_list[0]["name"]
        print(" --->", source_name)
        if os.path.basename(source_list[0]["file"])[:-7] != source_name :
            print("Tar file name should match sources name, omitting:", source_name)
            sys.exit(1)
        dest = pkg_source_dir(package_name, source_name)
        os.makedirs(dest, exist_ok=False)
        shutil.copy(source_list[0]["file"], dest)

    print("Adding configs...")
    os.makedirs(pkg_config_dir(package_name), exist_ok=False)
    config_list = package.get("config-dir")
    if config_list:
        config_name = config_list[0]["name"]
        print(" --->", config_name)
        dest = pkg_config_dir(package_name, config_name)
        shutil.copytree(config_list[0]["dir"], dest)

    print("Adding data...")
    os.makedirs(pkg_data_dir(package_name), exist_ok=False)
    data_list = package.get("data-dir")
    if data_list:
        data_name = data_list[0]["name"]
        print(" --->", data_name)
        dest = pkg_data_dir(package_name, data_name)
        shutil.copytree(data_list[0]["dir"], dest)

    print("Adding service...")
    os.makedirs(pkg_service_dir(package_name), exist_ok=False)
    print(" --->", package["name"])
    service_list = package.get("service-dir")
    if args.containerz and service_list:
        service_name = service_list[0]["name"]
        print(" --->", service_name)
        dest = pkg_service_dir(package_name, service_name)
        shutil.copytree(service_list[0]["dir"], dest)

def add_owner_rpm_files(package, package_name):
    rpm_type = package["name"]
    release_conf.read(
        os.path.join(RELEASE_CONF_DIR, rpm_type.split('-')[0] +".ini")
    )

    print("Building docker image {}...".format(release_conf["build"]["image"]))

    try:
        subprocess.run(["make", release_conf["build"]["image"]], cwd=dirname)
    except subprocess.CalledProcessError:
        print(
            "Could not build docker image {}".format(
                release_conf["build"]["image"]
            )
        )
        sys.exit(1)

    print("Adding sources...")
    source_list = package.get("sources")
    if source_list:
        source_name = source_list[0]["name"]
        print(" --->", source_name)
        if os.path.basename(source_list[0]["file"])[:-7] != package["name"][len('owner-'):] :
            print("Tar file name should match package name, omitting:", package["name"])
            sys.exit(1)
        dest = pkg_source_dir(package_name, source_name)
        os.makedirs(dest, exist_ok=False)
        shutil.copy(source_list[0]["file"], dest)

    print("Adding configs...")
    os.makedirs(pkg_config_dir(package_name), exist_ok=False)
    config_list = package.get("config-dir")
    if config_list:
        config_name = config_list[0]["name"]
        print(" --->", config_name)
        dest = pkg_config_dir(package_name, config_name)
        shutil.copytree(config_list[0]["dir"], dest)

    print("Adding data...")
    os.makedirs(pkg_data_dir(package_name), exist_ok=False)
    print(" --->", package["name"])
    data_list = package.get("data-dir")
    if data_list:
        data_name = data_list[0]["name"]
        print(" --->", data_name)
        dest = pkg_data_dir(package_name, data_name)
        shutil.copytree(data_list[0]["dir"], dest)

    print("Adding service...")
    os.makedirs(pkg_service_dir(package_name), exist_ok=False)
    print(" --->", package["name"])
    service_list = package.get("service-dir")
    if args.containerz and service_list:
        service_name = service_list[0]["name"]
        print(" --->", service_name)
        dest = pkg_service_dir(package_name, service_name)
        shutil.copytree(service_list[0]["dir"], dest)


def add_native_rpm_files(package, package_name):
    rpm_type = package["release"]
    release_conf.read(
        os.path.join(RELEASE_CONF_DIR, rpm_type.split('_')[0] +".ini")
    )

    print("Building docker image {}...".format(release_conf["build"]["image"]))

    try:
        subprocess.run(["make", release_conf["build"]["image"]], cwd=dirname)
    except subprocess.CalledProcessError:
        print(
            "Could not build docker image {}".format(
                release_conf["build"]["image"]
            )
        )
        sys.exit(1)

    print("Adding sources...")
    source_list = package.get("sources")
    if source_list:
        source_name = source_list[0]["name"] 
        print(" --->", source_name)
        if os.path.basename(source_list[0]["file"])[:-7] != source_name :
            print("Tar file name should match source name, omitting:", source_name)
            sys.exit(1)
        dest = pkg_source_dir(package_name, source_name)
        os.makedirs(dest, exist_ok=False)
        shutil.copy(source_list[0]["file"], dest)

    print("Adding configs...")
    os.makedirs(pkg_config_dir(package_name), exist_ok=False)
    config_list = package.get("config-dir", [])
    if config_list:
        config_name = config_list[0]["name"]
        print(" --->", config_name)
        dest = pkg_config_dir(package_name, config_name)
        shutil.copytree(config_list[0]["dir"], dest)

    print("Adding data...")
    os.makedirs(pkg_data_dir(package_name), exist_ok=False)
    data_list = package.get("data-dir", [])
    if data_list:
        data_name = data_list[0]["name"]
        print(" --->", data_name)
        dest = pkg_data_dir(package_name, data_name)
        shutil.copytree(data_list[0]["dir"], dest)

def add_pscript_rpm_files(package, package_name):
    release_conf.read(
        os.path.join(RELEASE_CONF_DIR, package["name"] + ".ini")
    )

    print("Building docker image {}...".format(release_conf["build"]["image"]))

    try:
        subprocess.run(["make", release_conf["build"]["image"]], cwd=dirname)
    except subprocess.CalledProcessError:
        print(
            "Could not build docker image {}".format(
                release_conf["build"]["image"]
            )
        )
        sys.exit(1)

    print("Adding sources...")
    source_list = package.get("sources")
    if source_list:
        source_name = source_list[0]["name"]
        print(" --->", source_name)
        dest = pkg_source_dir(package_name, source_name)
        os.makedirs(dest, exist_ok=False)
        shutil.rmtree(dest, ignore_errors=True)
        if not os.listdir(source_list[0]["dir"]):
            print("The pscript directory should not be empty ", source_list[0]["dir"])
            sys.exit(1)
        elif len(os.listdir(source_list[0]["dir"])) == 1 and os.path.isfile(os.path.join(source_list[0]["dir"] + "/.gitignore")):
            print("Please add files to be added to pscript directory ", source_list[0]["dir"])
            sys.exit(1)
        shutil.copytree(source_list[0]["dir"], dest)

def add_ownerpscript_rpm_files(package, package_name):
    release_conf.read(
        os.path.join(RELEASE_CONF_DIR, package["name"] + ".ini")
    )

    print("Building docker image {}...".format(release_conf["build"]["image"]))

    try:
        subprocess.run(["make", release_conf["build"]["image"]], cwd=dirname)
    except subprocess.CalledProcessError:
        print(
            "Could not build docker image {}".format(
                release_conf["build"]["image"]
            )
        )
        sys.exit(1)

    print("Adding sources...")
    source_list = package.get("sources")
    if source_list:
        source_name = source_list[0]["name"]
        print(" --->", source_name)
        dest = pkg_source_dir(package_name, source_name)
        os.makedirs(dest, exist_ok=False)
        shutil.rmtree(dest, ignore_errors=True)
        if not os.listdir(source_list[0]["dir"]):
            print("The pscript directory should not be empty ", source_list[0]["dir"])
            sys.exit(1)
        elif len(os.listdir(source_list[0]["dir"])) == 1 and os.path.isfile(os.path.join(source_list[0]["dir"] + "/.gitignore")):
            print("Please add files to be added to pscript directory ", source_list[0]["dir"])
            sys.exit(1)
        shutil.copytree(source_list[0]["dir"], dest)

os.makedirs(SPEC_DIR, exist_ok=True)
os.makedirs(RPM_SOURCE_DIR, exist_ok=True)
os.makedirs(KEY_DIR, exist_ok=True)

package_found = False
for package in config["packages"]:
    if args.package_names:
        if not package["name"] in args.package_names:
            continue

    print("Starting to build package:", package["name"])

    if "sandbox" in package["name"]:
        print("package name sandbox is not permitted")
        continue

    package_found = True

    if 'target-release' in package:
        package_name = "{name}-{version}-{target-release}".format(**package)
    else:
        package_name = "{name}-{version}".format(**package)
    print(" --->", package["name"])
    if package["name"].startswith('partner-'):
        add_partner_rpm_files(package, package_name)
    elif package["name"].startswith('pscript'):
        add_pscript_rpm_files(package, package_name)
    elif package["name"].startswith('owner-pscript'):
        add_ownerpscript_rpm_files(package, package_name)
    elif package["name"].startswith('owner-'):
        add_owner_rpm_files(package, package_name)
    else:
        add_native_rpm_files(package, package_name)
    gpg_key = package.get("gpg_key")

    if gpg_key:
        print("Adding gpg key:", gpg_key)
        shutil.copy(gpg_key, key_dir(package_name))

    print("Creating source archive...")
    subprocess.run(
        [
            "tar",
            "-czf",
            os.path.join("sources", "{}.tar.gz".format(package_name)),
            "{}".format(package_name),
        ],
        cwd=ARCHIVE_DIR,
    )

    if 'target-release' in package:
        spec_name = "{name}-{version}-{target-release}.spec".format(**package)
    else:
        spec_name = "{name}-{version}.spec".format(**package)
    print("Generating spec file:", spec_name)
    spec = make_spec(package)
    with open(os.path.join(SPEC_DIR, spec_name), "w") as f:
        f.write(spec)

    spec_file = os.path.join(release_conf["build"]["rpm_spec_dir"], spec_name)
    command = [
        "/usr/sbin/build_rpm.sh",
        "--spec-file",
        spec_file,
        "--source-dir",
        release_conf["build"]["rpm_source_dir"],
        "--rpm-dir",
        release_conf["build"]["rpm_rpm_dir"],
        "--output-dir",
        release_conf["build"]["rpm_output_dir"],
        "--verbose",
    ]

    if gpg_key:
        command.extend(["--gpg-key", "/root/keys/{}".format(package_name)])

    print("Building RPM...")
    print(" ".join(command))

    os.makedirs(RPM_DIR, exist_ok=True)

    subprocess.run(
        [
            "docker",
            "run",
            "--rm",
            "--name",
            "appmgr_rpm_builder",
            "-v",
            "{}:{}".format(
                os.path.abspath(SPEC_DIR),
                release_conf["build"]["rpm_spec_dir"],
            ),
            "-v",
            "{}:{}".format(
                os.path.abspath(RPM_SOURCE_DIR),
                release_conf["build"]["rpm_source_dir"],
            ),
            "-v",
            "{}:{}".format(
                os.path.abspath(RPM_DIR),
                release_conf["build"]["rpm_output_dir"],
            ),
            # This one's for logs
            "-v",
            "{}:{}".format(
                os.path.join(os.path.abspath(dirname), "build"), "/tmp"
            ),
            "-v",
            "{}:{}".format(os.path.abspath(KEY_DIR), "/root/keys"),
            release_conf["build"]["image"],
        ]
        + command,
        cwd=RPM_SOURCE_DIR,
    )
    print()
    print("Done building package", package["name"])
    print()

if (package_found == False):
    print("Please provide correct package name")
    sys.exit(1)