release-uyuni

#!/usr/bin/python3
import argparse
import configparser
import os
import time
import socket
import urllib.parse
import urllib.request
import xml.etree.ElementTree as ET

BASE_PRJ = "systemsmanagement:Uyuni"
STABLE_PRJ = BASE_PRJ + ":Stable"
MASTER_PRJ = BASE_PRJ + ":Master"
MASTER_PRJ_OTHER = BASE_PRJ + ":Master:Other"
MASTER_PRJ_KIT = BASE_PRJ + ":Master:Kit"
URL_PRJ = "https://www.uyuni-project.org/"


def obs_urlopen(args, path, method='GET', data=None):
    """ Make a request to OBS API """
    url = args.obsurl + path
    user = args.user
    password = args.password
    password_mgr = urllib.request.HTTPPasswordMgrWithDefaultRealm()
    password_mgr.add_password(None, url, user, password)
    auth_handler = urllib.request.HTTPBasicAuthHandler(password_mgr)
    opener = urllib.request.build_opener(auth_handler)
    urllib.request.install_opener(opener)
    if data is not None:
        if isinstance(data, str):
            data = bytes(data, "utf-8")
        else:
            data = urllib.parse.urlencode(data, doseq=True).encode("utf-8")
        req = urllib.request.Request(url=url, data=data, method=method)
    else:
        req = urllib.request.Request(url)
    if method == 'PUT':
        req.add_header('Content-Type', 'application/octet-stream')
    resource = urllib.request.urlopen(req)
    charset = resource.headers.get_content_charset()
    if charset is None:
        charset = 'utf-8'
    return resource.read().decode(charset)


def copy_prjconf(args, prj):
    """ Copy prjconfig between projects """
    oprj = prj['origin']
    dprj = prj['name']
    print("Reading prjconf from %s..." % oprj)
    prjconfig = obs_urlopen(args, "/source/" + oprj + "/_config")
    # We need this as a project returns 404 while it's being
    # created after sending the meta information
    code = None
    while code is None:
        try:
            ret = obs_urlopen(args, "/source/" + dprj +
                              "/_config", 'PUT', prjconfig)
            code = ET.fromstring(ret).attrib['code']
        except urllib.error.HTTPError as err:
            if err.code == 404:
                print("Got HTTP %s: waiting for the project to be created..." % err.code)
                time.sleep(10)
                continue
            else:
                raise
        except:
            raise


def clean_packages(args, oprj, dprj, keep_removed):
    """ Clean packages present at destionation project, but not at origin project """
    opackages = []
    dpackages = []
    rpackages = []
    for package in ET.fromstring(obs_urlopen(args, "/source/" + oprj)):
        opackages.append(package.attrib['name'])
    for package in ET.fromstring(obs_urlopen(args, "/source/" + dprj)):
        dpackages.append(package.attrib['name'])
    for dpackage in dpackages:
        if not dpackage in opackages:
            rpackages.append(dpackage)
    if rpackages:
        print("The following packages from %s are not present at %s" %
              (dprj, oprj))
        for package in rpackages:
            print("- " + package)
        if keep_removed:
            print("As --keep_removed is present, the packages will not be removed")
            return
        print("As --keep_removed is not present, the packages will be removed")
        for package in rpackages:
            data = {'comment': 'Package removed for %s submission' % args.uyuniver}
            obs_urlopen(args, "/source/" + dprj +
                        '/' + package, 'DELETE', data)


def create_meta_repo(args, meta, name, projects, own=False, release_target=None):
    """ Create a repository into meta for a project """
    repo = ET.SubElement(meta, 'repository', name=name)
    if release_target is not None:
        ET.SubElement(repo, 'releasetarget', project=release_target,
                      repository=name, trigger='manual')
    for project, repository in projects.items():
        if meta.get('name') == project and not own:
            continue
        ET.SubElement(repo, 'path', project=project, repository=repository)
    for arch in args.archs:
        ET.SubElement(repo, 'arch').text = arch


def add_meta(args, prj):
    """ Add meta to a project """
    dprj = prj['name']
    vprj = prj['versioned']
    release_target = prj['release_target']
    meta = ET.Element('project', name=dprj)
    title = 'Uyuni release ' + args.uyuniver
    # This is a snapshot project
    if vprj:
        title += ' (Snapshot)'
    else:
        title += ' (Latest stable version available)'
    ET.SubElement(meta, 'title').text = title
    ET.SubElement(meta, 'description')
    ET.SubElement(meta, 'url').text = URL_PRJ
    ET.SubElement(meta, 'person', userid=args.user, role='maintainer')
    projects = {dprj: "openSUSE_Leap_" + args.leapver,
                "openSUSE:Leap:%s:Update" % args.leapver: 'standard'}
    create_meta_repo(args, meta, "openSUSE_Leap_" +
                     args.leapver, projects, False, release_target)
    create_meta_repo(args, meta, "images", projects, True, release_target)
    meta = ET.tostring(meta).decode()
    print("Configuring meta for the project...")
    obs_urlopen(args, "/source/" + dprj + '/_meta', 'PUT', meta)


def disable_build(args, prj):
    """ Disable builds for a project """
    meta = ET.fromstring(obs_urlopen(
        args, "/source/" + prj['name'] + "/_meta"))
    # Release projects always have build disabled
    build = ET.SubElement(meta, 'build')
    ET.SubElement(build, 'disable')
    meta = ET.tostring(meta).decode()
    print("Disabling builds for the project...")
    obs_urlopen(args, "/source/" + prj['name'] + '/_meta', 'PUT', meta)


def release_project(args, prj):
    """ Release packages to a project from an origin """
    data = {'cmd': 'release', 'nodelay': 1}
    print("Releasing packages from %s to %s..." % (prj['origin'], prj['name']))
    try:
        obs_urlopen(args, "/source/" + prj['origin'], 'POST', data)
    except (urllib.request.URLError, socket.timeout) as error:
        print("Error releasing: %s" % error)


def lock_project(args, prj):
    """ Lock a project """
    data = {'cmd': 'lock'}
    print("Locking project %s..." % prj)
    obs_urlopen(args, "/source/" + prj, 'POST', data)


def project_exists(args, prj):
    """ Check if a project exists """
    try:
        obs_urlopen(args, "/source/" + prj + '/_meta')
        return True
    # Wait until project is created
    except urllib.error.HTTPError as err:
        if err.code == 404:
            return False
        else:
            raise


def remove_project(args, prj, force=False):
    """ Remove a project """
    if force:
        data = {'force': 1}
    else:
        data = {'force': 1}
    print("Removing %s..." % prj)
    obs_urlopen(args, "/source/" + prj, 'DELETE', data)


def project_is_locked(args, prj):
    """ Check if a project exists """
    try:
        tree = ET.fromstring(obs_urlopen(args, "/build/" + prj + "/_result"))
    except urllib.error.HTTPError as err:
        if err.code == 404:
            return False
    if tree is None:
        return False
    if tree.find("result/status[@code='locked']"):
        return True
    return False


def parse_arguments():
    """ Parse arguments from command line """
    parser = argparse.ArgumentParser(
        description="Release a new Uyuni version to %s and a new directory %s:Snapshots:X:Y.Z" % (MASTER_PRJ, BASE_PRJ))
    parser.add_argument("-U", "--user", action="store", dest="user",
                        help="OBS Username or read from ~/.oscrc")
    parser.add_argument("-P", "--password", action="store", dest="password",
                        help="OBS Password or read from ~/.oscrc")
    parser.add_argument("-u", "--uyuni-version", action="store", dest="uyuniver",
                        help="The Uyunu major version to be released (e.g. 4.0.0)")
    parser.add_argument("-l", "--leap-version", action="store", dest="leapver",
                        help="The Leap version for the base system (Default: 42.3)",
                        default="42.3")
    parser.add_argument("-O", "--obs-url", action="store", dest="obsurl",
                        default="https://api.opensuse.org",
                        help="OBS URL (Default: https://api.opensuse.org")
    parser.add_argument("-a", "--archs", action="store", dest="archs",
                        help="Comma separated list of architectures (x86_64 by default)",
                        default="x86_64")
    parser.add_argument("--force", action="store_true", dest="force",
                        help="If present, removes the version project, and recreates it again",
                        default=False)
    parser.add_argument("--keep-removed", action="store_true", dest="keep_removed",
                        help="If present, keeps the packages removed from %s and %s"
                        % (MASTER_PRJ, MASTER_PRJ_OTHER), default=False)
    parser.add_argument("--copy-all", action="store_true", dest="copy_all",
                        help="If present, copy all packages to the %s, regardless of whatever are differences or not" % STABLE_PRJ,
                        default=False)
    args = parser.parse_args()
    if not args.uyuniver:
        raise RuntimeError('The new Uyuni version is mandatory')
    if not args.user or not args.password:
        try:
            creds_path = "%s/.oscrc" % os.path.expanduser('~')
            creds = configparser.ConfigParser()
            creds.read(creds_path)
            args.user = creds.get(args.obsurl, 'user')
            args.password = creds.get(args.obsurl, 'pass')
        except Exception:
            raise RuntimeError(
                'Could not find credentials for %s at %s' % (args.obsurl, creds_path))
    args.archs = args.archs.split(',')
    return args


def main():
    """ Main function """
    args = parse_arguments()
    vprj = BASE_PRJ + ':Snapshots:' + args.uyuniver
    # Versioned project must always be the first in creation, as we need to declare it
    # as release_target for STABLE_PRJ at meta, but then it will be the last in promotion
    prjs_publish = [
        {'name': vprj, 'copy_all': True, 'versioned': True, 'origin': STABLE_PRJ,
         'release_target': None, 'prj_config': STABLE_PRJ},
        {'name': STABLE_PRJ, 'copy_all': args.copy_all, 'versioned': False,
         'origin': MASTER_PRJ, 'release_target': vprj, 'prj_config': None}
    ]
    for prj in prjs_publish:
        if project_is_locked(args, prj['name']):
            raise RuntimeError(
                "Project %s is locked, unlock it first with 'osc unlock %s', and then wait until all packages are unlocked" % (prj['name'], prj['name']))

    if project_exists(args, vprj):
        if not args.force:
            raise RuntimeError(
                'Project %s already exists and --force is not enabled' % vprj)
        else:
            print('WARNING! Project %s will be removed and recreated!' % vprj)
            remove_project(args, vprj, force=True)
    # Evaluate and clean removed packages for Stable repository, if required
    clean_packages(args, MASTER_PRJ, STABLE_PRJ, args.keep_removed)
    for prj in prjs_publish:
        print(
            "########################## Configuring %s... ##########################" % prj['name'])
        add_meta(args, prj)
        # Despite disabling build is done at meta, it cannot be done during
        # creaton, so it's done as separate step
        disable_build(args, prj)
        if prj['prj_config'] is not None:
            copy_prjconf(args, prj)
    print("########################## Releasing projects... ##########################")
    for prj in reversed(prjs_publish):
        release_project(args, prj)
    lock_project(args, vprj)
    print("All done!")


if __name__ == "__main__":
    try:
        main()
    except RuntimeError as err:
        print("ERROR: %s" % err)
    except Exception as err:
        print("ERROR: %s" % err)
        raise