Пример #1
0
def main(argv=None):
    parser = argparse.ArgumentParser()
    parser.add_argument('--workdir',
                        help='specify the working directory',
                        metavar='DIR',
                        default='docker_work',
                        required=False)
    args = parser.parse_args()

    workdir = os.path.realpath(args.workdir)
    git_dir = join(workdir, 'sapmachine-infrastructure')

    utils.remove_if_exists(workdir)
    os.makedirs(workdir)

    releases = github_api_request('releases', per_page=100)
    infrastructure_tags = github_api_request(
        'tags', repository='SapMachine-infrastructure', per_page=100)
    lts_release = None
    lts_release_major = 0
    stable_release = None

    for release in releases:
        if release['prerelease']:
            continue

        version, version_part, major, build_number, sap_build_number, os_ext = utils.sapmachine_tag_components(
            release['name'])

        if utils.sapmachine_is_lts(major) and not lts_release:
            lts_release = release
            lts_release_major = major
        else:
            if not stable_release and major > lts_release_major:
                stable_release = release

        if lts_release and stable_release:
            break

    if lts_release or stable_release:
        utils.git_clone('github.com/SAP/SapMachine-infrastructure', 'master',
                        git_dir)

    if lts_release and not stable_release:
        stable_release = lts_release

    if lts_release:
        print(str.format('found latest LTS release "{0}"',
                         lts_release['name']))
        process_release(lts_release, 'lts', infrastructure_tags, git_dir)

    if stable_release:
        print(
            str.format('found latest stable release "{0}"',
                       stable_release['name']))
        process_release(stable_release, 'stable', infrastructure_tags, git_dir)

    utils.remove_if_exists(workdir)

    return 0
def main(argv=None):
    parser = argparse.ArgumentParser()
    parser.add_argument('--workdir', help='the temporary working directory', metavar='DIR', default="tags_work", required=False)
    args = parser.parse_args()

    workdir = os.path.realpath(args.workdir)
    utils.remove_if_exists(workdir)
    os.makedirs(workdir)

    # fetch all branches
    sapmachine_branches = utils.get_active_sapmachine_branches()

    # fetch all tags
    tags = utils.get_github_tags()

    # iterate all tags to find the latest jdk tag for a JDK major release
    jdk_tags = {}
    for tag in tags:
        # filter for jdk tags
        jdk_tag = JDKTag.from_string(tag['name'])
        if jdk_tag is None:
            continue

        # only remember the latest jdk tag (version comparison)
        # filter out jdk update tags with build number "0" like jdk-11.0.3+0
        if ((jdk_tag.get_major() not in jdk_tags or jdk_tag.is_greater_than(jdk_tags[jdk_tag.get_major()])) and
            not (jdk_tag.get_update() > 0 and (jdk_tag.get_build_number() if jdk_tag.get_build_number() is not None else 0) == 0)):
            jdk_tags[jdk_tag.get_major()] = jdk_tag

    # clone the SapMachine repository
    git_target_dir = join(workdir, 'sapmachine')
    utils.git_clone('github.com/SAP/SapMachine.git', 'sapmachine', git_target_dir)

    # for each "sapmachine" branch, check whether it contains the latest jdk tag with matching major version
    for sapmachine_branch in sapmachine_branches:
        # get the latest jdk tag for this major version
        latest_tag = jdk_tags[sapmachine_branch[1]]

        print(str.format('latest tag for branch "{0}" is "{1}"', sapmachine_branch, latest_tag.as_string()))

        # check whether the jdk tag is already contained in the sapmachine branch
        _, out, _ = utils.run_cmd(str.format('git branch -a --contains tags/{0}', latest_tag.as_string()).split(' '), cwd=git_target_dir, std=True, throw=False)
        containing_branches_pattern = re.compile('{0}|pr-jdk-{1}.*'.format(sapmachine_branch[0], sapmachine_branch[1]))
        match = re.search(containing_branches_pattern, out)

        if match is None:
            # the jdk tag is not contained in a sapmachine branch
            # create a pull request branch and a pull request.
            print(str.format('creating pull request "pr-{0}" with base branch "{1}"', latest_tag.as_string(), sapmachine_branch))
            utils.run_cmd(str.format('git checkout {0}', latest_tag.as_string()).split(' '), cwd=git_target_dir)
            utils.run_cmd(str.format('git checkout -b pr-{0}', latest_tag.as_string()).split(' '), cwd=git_target_dir)
            utils.run_cmd(str.format('git push origin pr-{0}', latest_tag.as_string()).split(' '), cwd=git_target_dir)

            pull_request = str.format('{{ "title": "Merge to tag {0}", "body": "please pull", "head": "pr-{1}", "base": "{2}" }}',
                latest_tag.as_string(), latest_tag.as_string(), sapmachine_branch[0])

            utils.github_api_request('pulls', data=pull_request, method='POST')

    utils.remove_if_exists(workdir)
    return 0
def main(argv=None):
    token = utils.get_github_api_accesstoken()
    asset_pattern = re.compile(utils.sapmachine_asset_pattern())
    asset_map_jre = {}
    asset_map_jdk = {}

    releases = utils.get_github_releases()

    for release in releases:
        if release['prerelease'] is True:
            continue

        t = SapMachineTag.from_string(release['name'])
        if t is None:
            continue

        assets = release['assets']
        for asset in assets:
            match = asset_pattern.match(asset['name'])
            if match is None:
                continue

            asset_image_type = match.group(1)
            asset_os = match.group(3)

            if asset_os == 'linux-x64':
                sapmachine_version = t.get_version()
                build_number = t.get_build_number()

                buildpack_version = str.format(
                    '{0}.{1}.{2}_{3}.{4}.b{5}', sapmachine_version[0],
                    sapmachine_version[1], sapmachine_version[2],
                    sapmachine_version[3], sapmachine_version[4],
                    build_number if build_number else '0')

                if asset_image_type == 'jre':
                    asset_map_jre[buildpack_version] = asset[
                        'browser_download_url']
                else:
                    asset_map_jdk[buildpack_version] = asset[
                        'browser_download_url']

    local_repo = join(os.getcwd(), 'gh-pages')
    utils.git_clone('github.com/SAP/SapMachine.git', 'gh-pages', local_repo)
    write_index_yaml(
        asset_map_jre,
        join(local_repo, 'assets', 'cf', 'jre', 'linux', 'x86_64'))
    write_index_yaml(
        asset_map_jdk,
        join(local_repo, 'assets', 'cf', 'jdk', 'linux', 'x86_64'))
    utils.git_commit(local_repo, 'Updated index.yml', ['assets'])
    utils.git_push(local_repo)
    utils.remove_if_exists(local_repo)

    return 0
Пример #4
0
def main(argv=None):
    parser = argparse.ArgumentParser()
    parser.add_argument('-t',
                        '--tag',
                        help='the tag to create the alpine packages from',
                        metavar='TAG',
                        required=True)
    parser.add_argument('-d',
                        '--templates-directory',
                        help='specify the templates directory',
                        metavar='DIR',
                        required=True)
    args = parser.parse_args()

    templates_dir = realpath(args.templates_directory)
    tag = args.tag

    if tag.endswith('-alpine'):
        # the "-alpine" tags do not contain any assets
        tag = tag[:-len('-alpine')]

    cwd = os.getcwd()
    home = expanduser("~")
    work_dir = join(cwd, 'apk_work')
    version, version_part, major, build_number, sap_build_number, os_ext = utils.sapmachine_tag_components(
        tag)
    jdk_url, jre_url = utils.get_asset_url(tag, 'linux-x64-musl')
    jdk_name = str.format('sapmachine-{0}-jdk', major)
    jre_name = str.format('sapmachine-{0}-jre', major)
    jdk_dir = join(work_dir, jdk_name)
    jre_dir = join(work_dir, jre_name)

    utils.remove_if_exists(work_dir)

    mkdir(work_dir)
    mkdir(jdk_dir)
    mkdir(jre_dir)

    generate_configuration(templates_dir, jdk_dir, jdk_name, version, '0',
                           'The SapMachine Java Development Kit', jdk_url)
    generate_configuration(templates_dir, jre_dir, jre_name, version, '0',
                           'The SapMachine Java Runtime Environment', jre_url)

    utils.run_cmd(['abuild', 'checksum'], cwd=jdk_dir)
    utils.run_cmd(['abuild', 'checksum'], cwd=jre_dir)

    utils.run_cmd(['abuild', '-r', '-K'], cwd=jdk_dir)
    utils.run_cmd(['abuild', '-r', '-K'], cwd=jre_dir)

    rmtree(work_dir)

    apk_files = glob.glob(join(home, 'packages', 'apk_work', '*', '*.apk'))

    for apk_file in apk_files:
        copy(apk_file, cwd)
Пример #5
0
def _setup_fifo_hack():
    from utils import remove_if_exists
    fifos = ('/tmp/in', '/tmp/out', '/tmp/err')
    for fifo in fifos:
        remove_if_exists(fifo)
        os.mkfifo(fifo)
    global stdin, stdout, stderr
    # Weird blocking: http://stackoverflow.com/q/5782279/341970
    stdin = open('/tmp/in', 'r+')  # but we will only read
    stdout = open('/tmp/out', 'r+')  # but we will only write
    stderr = open('/tmp/err', 'r+')  # but we will only write
Пример #6
0
def combine_all_bowtie_results(minRNA, maxRNA, lib):
    '''
    Combine all bowtie results and re-format result line
    '''
    logging.info('Combining all bowtie hits...')
    remove_if_exists('{}_allGS.bed'.format(lib))
    for length in range(minRNA, maxRNA + 1):
        OUTgs = '{}_allGS.bed'.format(lib)
        A1 = '{}_{}.hits'.format(lib, length)
        cmd = 'awk -v N={}-1 -F"\\t" \'{{print $3"\\t"$4"\\t"$4+N"\\t"$1" "$5" "$6"\\t1\\t"$2}}\' {} >> {}'.format(length, A1, OUTgs)
        os.system(cmd)
    return OUTgs
Пример #7
0
def main(argv=None):
    token = utils.get_github_api_accesstoken()
    asset_pattern = re.compile(utils.sapmachine_asset_pattern())
    asset_map = {}

    releases = utils.github_api_request('releases', per_page=100)

    for release in releases:
        if release['prerelease'] is True:
            continue

        version, version_part, major, build_number, sap_build_number, os_ext = utils.sapmachine_tag_components(
            release['name'])
        assets = release['assets']

        if version is None or os_ext:
            continue

        for asset in assets:
            match = asset_pattern.match(asset['name'])

            if match is not None:
                asset_image_type = match.group(1)
                asset_os = match.group(3)

                if asset_os == 'linux-x64' and asset_image_type == 'jre':
                    sapmachine_version = [
                        int(e) for e in version_part.split('.')
                    ]
                    sapmachine_version += [
                        0 for sapmachine_version in range(
                            0, 5 - len(sapmachine_version))
                    ]

                    if sap_build_number:
                        sapmachine_version[4] = int(sap_build_number)

                    buildpack_version = str.format(
                        '{0}.{1}.{2}_{3}.{4}.b{5}', sapmachine_version[0],
                        sapmachine_version[1], sapmachine_version[2],
                        sapmachine_version[3], sapmachine_version[4],
                        build_number if build_number else '0')
                    asset_map[buildpack_version] = asset[
                        'browser_download_url']

    local_repo = join(os.getcwd(), 'gh-pages')
    utils.git_clone('github.com/SAP/SapMachine.git', 'gh-pages', local_repo)
    write_index_yaml(
        asset_map, join(local_repo, 'assets', 'cf', 'jre', 'linux', 'x86_64'))
    utils.git_commit(local_repo, 'Updated index.yml', ['assets'])
    utils.git_push(local_repo)
    utils.remove_if_exists(local_repo)
Пример #8
0
def combine_all_bowtie_results(minRNA, maxRNA, lib):
    '''
    Combine all bowtie results and re-format result line
    '''
    logging.info('Combining all bowtie hits...')
    remove_if_exists('{}_allGS.bed'.format(lib))
    for length in range(minRNA, maxRNA + 1):
        OUTgs = '{}_allGS.bed'.format(lib)
        A1 = '{}_{}.hits'.format(lib, length)
        cmd = 'awk -v N={}-1 -F"\\t" \'{{print $3"\\t"$4"\\t"$4+N"\\t"$1" "$5" "$6"\\t1\\t"$2}}\' {} >> {}'.format(
            length, A1, OUTgs)
        os.system(cmd)
    return OUTgs
Пример #9
0
def push_to_git(files):
    local_repo = join(os.getcwd(), 'gh-pages')
    utils.git_clone('github.com/SAP/SapMachine.git', 'gh-pages', local_repo)

    for _file in files:
        location = join(local_repo, _file['location'])
        if not os.path.exists(os.path.dirname(location)):
            os.makedirs(os.path.dirname(location))
        with open(location, 'w+') as out:
            out.write(_file['data'])
        utils.git_commit(local_repo, _file['commit_message'], [location])

    utils.git_push(local_repo)
    utils.remove_if_exists(local_repo)
Пример #10
0
def set_up_output_folder(fi, out_path):
    '''
    Get file name components and create IntermediateFiles directory and
    output directories
    '''
    dr, fi_name = os.path.dirname(fi), os.path.basename(fi)
    fi_base, fi_ext = os.path.splitext(fi_name)
    dr_i = '{}/{}./IntermediateFiles'.format(dr, fi_base)
    if not os.path.isdir(dr_i):
        os.makedirs(dr_i)
    out_dir = '{}{}'.format(out_path, fi_base)
    remove_if_exists(out_dir)
    for out_loc in ['output', 'log', 'temp']:
        os.makedirs('{}/{}'.format(out_dir, out_loc))
    return dr, dr_i, fi_base
Пример #11
0
def set_up_output_folder(fi, out_path):
    '''
    Get file name components and create IntermediateFiles directory and
    output directories
    '''
    dr, fi_name = os.path.dirname(fi), os.path.basename(fi)
    fi_base, fi_ext = splitext(fi_name)
    dr_i = '{}/{}./IntermediateFiles'.format(dr, fi_base)
    if not os.path.isdir(dr_i):
        os.makedirs(dr_i)
    out_dir = '{}{}'.format(out_path, fi_base)
    remove_if_exists(out_dir)
    for out_loc in ['output', 'log', 'temp']:
        os.makedirs('{}/{}'.format(out_dir, out_loc))
    return dr, dr_i, fi_base
def main(argv=None):
    parser = argparse.ArgumentParser()
    parser.add_argument('-s', '--srcdir', help='the source directory (Jenkins home directory)', metavar='DIR', required=True)
    parser.add_argument('-b', '--backuprepodir', help='the backup repository', metavar='DIR', default='SapMachine-Infrastructure')
    parser.add_argument('-d', '--dryrun', help='do not push the Jenkins configuration', action='store_true', default=False)
    args = parser.parse_args()

    target_dir = join(args.backuprepodir, jenkins_configuration)

    prepare_sapmachine_infra(args.backuprepodir)
    utils.remove_if_exists(target_dir)
    os.mkdir(target_dir)
    copy_configurations(args.srcdir, target_dir)
    create_plugin_list(args.srcdir, target_dir)

    if not args.dryrun:
        push_sapmachine_infra(args.backuprepodir)
Пример #13
0
def main(argv=None):
    token = utils.get_github_api_accesstoken()
    github_api = 'https://api.github.com/repos/SAP/SapMachine/releases'
    asset_pattern = re.compile(utils.sapmachine_asset_pattern())
    asset_map = {}

    request = Request(github_api)

    if token is not None:
        request.add_header('Authorization', str.format('token {0}', token))

    response = json.loads(urlopen(request).read())
    for release in response:
        if release['prerelease'] is True:
            continue

        version, version_part, major, build_number, sap_build_number, os_ext = utils.sapmachine_tag_components(release['name'])
        assets = release['assets']

        if version is None or os_ext:
            continue

        for asset in assets:
            match = asset_pattern.match(asset['name'])

            if match is not None:
                asset_image_type = match.group(1)
                asset_os = match.group(3)

                if asset_os == 'linux-x64' and asset_image_type == 'jdk':
                    sapmachine_version = [int(e) for e in version_part.split('.')]
                    sapmachine_version += [0 for sapmachine_version in range(0, 5 - len(sapmachine_version))]

                    if sap_build_number:
                        sapmachine_version[4] = int(sap_build_number)

                    buildpack_version = '.'.join([str(e) for e in sapmachine_version])
                    buildpack_version += str.format('_b{0}', build_number if build_number else '0')
                    asset_map[buildpack_version] = asset['browser_download_url']

    local_repo = join(os.getcwd(), 'gh-pages')
    utils.git_clone('github.com/SAP/SapMachine.git', 'gh-pages', local_repo)
    write_index_yaml(asset_map, join(local_repo, 'assets', 'cf', 'jre', 'linux', 'x86_64'))
    utils.git_commit(local_repo, 'Updated index.yml', ['assets'])
    utils.git_push(local_repo)
    utils.remove_if_exists(local_repo)
Пример #14
0
def process_release(release, tags, git_dir):
    version, version_part, major, update, version_sap, build_number, os_ext = utils.sapmachine_tag_components(
        release['name'])
    tag_name = version_part
    skip_tag = False
    dockerfile_dir = join(git_dir, 'dockerfiles', 'official', major)

    for tag in tags:
        if tag['name'] == tag_name:
            print(
                str.format('tag "{0}" already exists for release "{1}"',
                           tag_name, release['name']))
            skip_tag = True
            break

    if not skip_tag:
        utils.remove_if_exists(dockerfile_dir)
        os.makedirs(dockerfile_dir)

        dockerfile_path = join(dockerfile_dir, 'Dockerfile')
        with open(dockerfile_path, 'w+') as dockerfile:
            dockerfile.write(
                Template(dockerfile_template).substitute(version=str.format(
                    'sapmachine-{0}-jdk={1}', major, version_part),
                                                         major=major))

        if utils.sapmachine_is_lts(major):
            what = 'long term support'
            docker_tag = major
        else:
            what = 'stable'
            docker_tag = 'stable'
        readme_path = join(dockerfile_dir, 'README.md')
        with open(readme_path, 'w+') as readmefile:
            readmefile.write(
                Template(readmefile_template).substitute(docker_tag=docker_tag,
                                                         what=what,
                                                         major=major,
                                                         version=version_part))

        utils.git_commit(git_dir, 'updated Dockerfile',
                         [dockerfile_path, readme_path])
        utils.git_tag(git_dir, tag_name)
        utils.git_push(git_dir)
        utils.git_push_tag(git_dir, tag_name)
def main(argv=None):
    parser = argparse.ArgumentParser()
    parser.add_argument('-s',
                        '--srcdir',
                        help='the Jenkins home directory',
                        metavar='DIR',
                        required=True)
    parser.add_argument('-d',
                        '--dryrun',
                        help='do not push the Jenkins configuration',
                        action='store_true',
                        default=False)
    parser.add_argument('--keepworkdir',
                        help='do not delete the temporary work directory',
                        action='store_true',
                        default=False)
    args = parser.parse_args()

    src_dir = args.srcdir
    git_dir = tempfile.mkdtemp(suffix='sapmachine_jenkins_backup')
    target_dir = join(git_dir, jenkins_configuration)

    utils.remove_if_exists(git_dir)
    clone_sapmachine_infra(git_dir)
    utils.remove_if_exists(target_dir)
    os.mkdir(target_dir)
    copy_configurations(src_dir, target_dir)
    create_plugin_list(src_dir, target_dir)

    if not args.dryrun:
        push_sapmachine_infra(git_dir)

    if not args.keepworkdir:
        utils.remove_if_exists(git_dir)
def main(argv=None):
    parser = ArgumentParser()
    parser.add_argument('-m',
                        '--major',
                        help='The SapMachine major version to build',
                        metavar='MAJOR',
                        required=True)
    parser.add_argument('-d',
                        '--dir',
                        help='The dir to extract jtreg to',
                        metavar='DIR',
                        required=True)
    args = parser.parse_args()

    ver = int(args.major)
    if ver >= 17:
        url = 'https://github.com/SAP/SapMachine-infrastructure/releases/download/jtreg-6.1/jtreg.zip'
    else:
        url = 'https://github.com/SAP/SapMachine-infrastructure/releases/download/jtreg-5.1/jtreg.zip'

    print(
        str.format('Downloading "{0}" and extracting to "{1}"', url, args.dir))

    archive_path = join(args.dir, 'jtreg.zip')
    utils.remove_if_exists(archive_path)
    utils.download_artifact(url, archive_path)
    path = join(args.dir, 'jtreg')
    utils.remove_if_exists(path)
    os.makedirs(path)
    with ZipFile(archive_path, 'r') as zipObj:
        zipObj.extractall(path)

    utils.remove_if_exists(archive_path)
Пример #17
0
def main(argv=None):
    parser = argparse.ArgumentParser()
    parser.add_argument('--workdir',
                        help='specify the working directory',
                        metavar='DIR',
                        default='docker_work',
                        required=False)
    args = parser.parse_args()

    workdir = os.path.realpath(args.workdir)
    git_dir = join(workdir, 'sapmachine-infrastructure')

    utils.remove_if_exists(workdir)
    os.makedirs(workdir)

    releases = github_api_request('releases', per_page=100)
    infrastructure_tags = utils.get_github_infrastructure_tags()
    docker_releases = {}
    stable_release = None

    for release in releases:
        if release['prerelease']:
            continue

        version, version_part, major, update, version_sap, build_number, os_ext = utils.sapmachine_tag_components(
            release['name'])

        if utils.sapmachine_is_lts(major):
            if major in docker_releases:
                _, _, _, lts_update, _, _, _ = utils.sapmachine_tag_components(
                    docker_releases[major]['name'])
                if int(lts_update) < int(update):
                    docker_releases[major] = release
            else:
                docker_releases[major] = release

        if stable_release == None:
            stable_release = release
        else:
            _, _, stable_major, stable_update, _, _, _ = utils.sapmachine_tag_components(
                stable_release['name'])
            if int(major) > int(stable_major) or (
                    int(major) == int(stable_major)
                    and int(update) > int(stable_update)):
                stable_release = release

    print('Determined the following versions for processing:')
    for release in docker_releases:
        version, _, _, _, _, _, _ = utils.sapmachine_tag_components(
            docker_releases[release]['name'])
        print(str.format('LTS {1}: {0}', version, release))
    stable_version, _, stable_major, _, _, _, _ = utils.sapmachine_tag_components(
        stable_release['name'])
    print(str.format('stable: {0}', stable_version))

    if not (stable_version in docker_releases):
        docker_releases[stable_major] = stable_release

    utils.git_clone('github.com/SAP/SapMachine-infrastructure', 'master',
                    git_dir)

    versions_dir = join(git_dir, 'dockerfiles', 'official')
    removed = []
    for f in os.listdir(versions_dir):
        if not f in docker_releases:
            utils.remove_if_exists(join(versions_dir, f))
            removed.append(join(versions_dir, f))
    if removed != []:
        utils.git_commit(git_dir, 'remove discontinued versions', removed)

    for release in docker_releases:
        process_release(docker_releases[release], infrastructure_tags, git_dir)

    utils.remove_if_exists(workdir)

    return 0
Пример #18
0
def main(argv=None):
    parser = argparse.ArgumentParser()
    parser.add_argument('-t',
                        '--tag',
                        help='the SapMachine tag',
                        metavar='TAG',
                        required=True)
    parser.add_argument('--sha256sum',
                        help='the sha256 sum',
                        metavar='SHA256',
                        required=True)
    parser.add_argument('-i',
                        '--imagetype',
                        help='The image type',
                        metavar='IMAGETYPE',
                        choices=['jdk', 'jre'])
    parser.add_argument('-p',
                        '--prerelease',
                        help='this is a pre-release',
                        action='store_true',
                        default=False)
    args = parser.parse_args()

    work_dir = join(os.getcwd(), 'cask_work')
    utils.remove_if_exists(work_dir)
    os.makedirs(work_dir)

    cask_version_pattern = re.compile('version \'((\d+\.?)+)(,(\d+))?\'')

    sapMachineTag = SapMachineTag.from_string(args.tag)
    if sapMachineTag is None:
        print(str.format("Tag {0} seems to be invalid. Aborting...", args.tag))
        sys.exit()

    if args.prerelease:
        if sapMachineTag.get_build_number() is None:
            print('No build number given for pre-release. Aborting ...')
            sys.exit()

        cask_content = Template(pre_release_cask_template).substitute(
            MAJOR=sapMachineTag.get_major(),
            VERSION=sapMachineTag.get_version_string_without_build(),
            BUILD_NUMBER=sapMachineTag.get_build_number(),
            IMAGE_TYPE=args.imagetype,
            SHA256=args.sha256sum)
        cask_file_name = str.format('sapmachine{0}-ea-{1}.rb',
                                    sapMachineTag.get_major(), args.imagetype)
    else:
        cask_content = Template(release_cask_template).substitute(
            MAJOR=sapMachineTag.get_major(),
            VERSION=sapMachineTag.get_version_string_without_build(),
            IMAGE_TYPE=args.imagetype,
            SHA256=args.sha256sum)
        cask_file_name = str.format('sapmachine{0}-{1}.rb',
                                    sapMachineTag.get_major(), args.imagetype)

    homebrew_dir = join(work_dir, 'homebrew')
    cask_dir = join(homebrew_dir, 'Casks')
    cask_file_path = join(cask_dir, cask_file_name)

    utils.git_clone('github.com/SAP/homebrew-SapMachine', 'master',
                    homebrew_dir)

    current_cask_version = None
    current_cask_build_number = None

    if os.path.exists(cask_file_path):
        with open(cask_file_path, 'r') as cask_file:
            cask_version_match = cask_version_pattern.search(cask_file.read())

            if cask_version_match is not None:
                if len(cask_version_match.groups()) >= 1:
                    current_cask_version = cask_version_match.group(1)
                if len(cask_version_match.groups()) >= 4:
                    current_cask_build_number = cask_version_match.group(4)

    current_cask_version = versions.version_to_tuple(
        current_cask_version, current_cask_build_number)

    if current_cask_version is None or sapMachineTag.get_version_tuple(
    ) >= current_cask_version:
        print(
            str.format("Creating/updating cask for version {0}...",
                       sapMachineTag.get_version_tuple()))
        with open(cask_file_path, 'w') as cask_file:
            cask_file.write(cask_content)

        utils.git_commit(
            homebrew_dir,
            str.format('Update {0} ({1}).', cask_file_name,
                       sapMachineTag.get_version_string()),
            [join('Casks', cask_file_name)])
        utils.git_push(homebrew_dir)
    else:
        print(
            str.format(
                "Current cask has version {0} which is higher than {1}, no update.",
                current_cask_version, sapMachineTag.get_version_tuple()))

    return 0
def main(argv=None):
    parser = argparse.ArgumentParser()
    parser.add_argument('-m', '--major', help='the SapMachine major version to build', metavar='MAJOR', required=True)
    parser.add_argument('-d', '--destination', help='the download destination', metavar='DIR', required=True)
    args = parser.parse_args()

    boot_jdk_major_max = int(args.major)
    boot_jdk_major_min = boot_jdk_major_max - 1
    destination = os.path.realpath(args.destination)
    releases = utils.github_api_request('releases', per_page=100)
    platform = str.format('{0}-{1}_bin', utils.get_system(), utils.get_arch())

    for release in releases:

        if release['prerelease']:
            continue

        version, version_part, major, build_number, sap_build_number, os_ext = utils.sapmachine_tag_components(release['name'])

        if major is None:
            continue

        major = int(major)

        if major <= boot_jdk_major_max and major >= boot_jdk_major_min:
            assets = release['assets']

            for asset in assets:
                asset_name = asset['name']
                asset_url = asset['browser_download_url']

                if 'jdk' in asset_name and platform in asset_name and not asset_name.endswith('.txt'):
                    archive_path = join(destination, asset_name)
                    utils.remove_if_exists(archive_path)
                    utils.download_artifact(asset_url, archive_path)
                    boot_jdk_exploded = join(destination, 'boot_jdk')
                    utils.remove_if_exists(boot_jdk_exploded)
                    os.makedirs(boot_jdk_exploded)
                    utils.extract_archive(archive_path, boot_jdk_exploded)

                    sapmachine_folder = glob.glob(join(boot_jdk_exploded, 'sapmachine*'))

                    if sapmachine_folder is not None:
                        sapmachine_folder = sapmachine_folder[0]
                        files = os.listdir(sapmachine_folder)

                        for f in files:
                            shutil.move(join(sapmachine_folder, f), boot_jdk_exploded)

                        utils.remove_if_exists(sapmachine_folder)

                        if utils.get_system() == 'osx':
                            files = os.listdir(join(boot_jdk_exploded, 'Contents', 'Home'))

                            for f in files:
                                shutil.move(join(boot_jdk_exploded, 'Contents', 'Home', f), boot_jdk_exploded)

                            utils.remove_if_exists(join(boot_jdk_exploded, 'Contents'))

                    return 0

    return 0
def main(argv=None):
    parser = argparse.ArgumentParser()
    parser.add_argument('-r',
                        '--repository',
                        help='specify the repository directory',
                        metavar='DIR',
                        required=True)
    parser.add_argument('-s',
                        '--sign',
                        help='PGP sign the repository',
                        action='store_true',
                        default=False)
    args = parser.parse_args()

    repository = args.repository
    pgp_sign = args.sign

    utils.remove_if_exists(join(repository, 'Packages'))
    utils.remove_if_exists(join(repository, 'Packages.gz'))
    utils.remove_if_exists(join(repository, 'Release'))
    utils.remove_if_exists(join(repository, 'InRelease'))
    utils.remove_if_exists(join(repository, 'Release.gpg'))

    retcode, out, err = utils.run_cmd(
        ['dpkg-scanpackages', '-m', '.', '/dev/null'],
        cwd=repository,
        std=True)

    with open(join(repository, 'Packages'), 'w+') as packages_file:
        packages_file.write(out)

    utils.make_gz_archive(join(repository, 'Packages'),
                          join(repository, 'Packages.gz'))

    retcode, out, err = utils.run_cmd(['md5sum', 'Packages'],
                                      cwd=repository,
                                      std=True)
    packages_md5sum = out.split(' ')[0]
    retcode, out, err = utils.run_cmd(['sha1sum', 'Packages'],
                                      cwd=repository,
                                      std=True)
    packages_sha1sum = out.split(' ')[0]
    retcode, out, err = utils.run_cmd(['sha256sum', 'Packages'],
                                      cwd=repository,
                                      std=True)
    packages_sha256sum = out.split(' ')[0]
    retcode, out, err = utils.run_cmd(['sha512sum', 'Packages'],
                                      cwd=repository,
                                      std=True)
    packages_sha512sum = out.split(' ')[0]

    retcode, out, err = utils.run_cmd(['md5sum', 'Packages.gz'],
                                      cwd=repository,
                                      std=True)
    packages_gz_md5sum = out.split(' ')[0]
    retcode, out, err = utils.run_cmd(['sha1sum', 'Packages.gz'],
                                      cwd=repository,
                                      std=True)
    packages_gz_sha1sum = out.split(' ')[0]
    retcode, out, err = utils.run_cmd(['sha256sum', 'Packages.gz'],
                                      cwd=repository,
                                      std=True)
    packages_gz_sha256sum = out.split(' ')[0]
    retcode, out, err = utils.run_cmd(['sha512sum', 'Packages.gz'],
                                      cwd=repository,
                                      std=True)
    packages_gz_sha512sum = out.split(' ')[0]

    packages_size = os.path.getsize(join(repository, 'Packages'))
    packages_gz_size = os.path.getsize(join(repository, 'Packages.gz'))

    now = datetime.datetime.utcnow().strftime('%a, %d %b %Y %H:%M:%S +0000')

    with open(join(repository, 'Release'), 'w+') as release_file:
        release_file.write(str.format('Date: {0}\n', now))
        release_file.write('MD5Sum:\n')
        release_file.write(
            str.format(' {0} {1:>16s} Packages.gz\n', packages_gz_md5sum,
                       str(packages_gz_size)))
        release_file.write(
            str.format(' {0} {1:>16s} Packages\n', packages_md5sum,
                       str(packages_size)))
        release_file.write('SHA1:\n')
        release_file.write(
            str.format(' {0} {1:>16s} Packages.gz\n', packages_gz_sha1sum,
                       str(packages_gz_size)))
        release_file.write(
            str.format(' {0} {1:>16s} Packages\n', packages_sha1sum,
                       str(packages_size)))
        release_file.write('SHA256:\n')
        release_file.write(
            str.format(' {0} {1:>16s} Packages.gz\n', packages_gz_sha256sum,
                       str(packages_gz_size)))
        release_file.write(
            str.format(' {0} {1:>16s} Packages\n', packages_sha256sum,
                       str(packages_size)))
        release_file.write('SHA512:\n')
        release_file.write(
            str.format(' {0} {1:>16s} Packages.gz\n', packages_gz_sha512sum,
                       str(packages_gz_size)))
        release_file.write(
            str.format(' {0} {1:>16s} Packages\n', packages_sha512sum,
                       str(packages_size)))
        release_file.write('\n')

    if pgp_sign is True:
        utils.run_cmd([
            'gpg', '--clearsign', '--digest-algo', 'SHA512', '--no-tty', '-o',
            'InRelease', 'Release'
        ],
                      cwd=repository)
        utils.run_cmd([
            'gpg', '-abs', '--digest-algo', 'SHA512', '--no-tty', '-o',
            'Release.gpg', 'Release'
        ],
                      cwd=repository)
def main(argv=None):
    parser = argparse.ArgumentParser()
    parser.add_argument('--workdir',
                        help='the temporary working directory',
                        metavar='DIR',
                        default="tags_work",
                        required=False)
    args = parser.parse_args()

    workdir = os.path.realpath(args.workdir)
    utils.remove_if_exists(workdir)
    os.makedirs(workdir)

    pull_requests = utils.github_api_request('pulls',
                                             per_page=100,
                                             url_parameter=['state=all'])

    # clone the SapMachine repository
    git_target_dir = join(workdir, 'sapmachine')
    utils.git_clone('github.com/SAP/SapMachine.git', 'sapmachine',
                    git_target_dir)

    # fetch all branches
    branches = utils.github_api_request('branches', per_page=100)
    sapmachine_latest = 0
    sapmachine_branches = []

    # iterate all branches of the SapMachine repository
    for branch in branches:
        # filter for sapmachine branches
        match = branch_pattern.match(branch['name'])

        if match is not None:
            # found sapmachine branch
            if match.group(1) is not None:
                major = int(match.group(1))
                sapmachine_branches.append([branch['name'], major])
                sapmachine_latest = max(major, sapmachine_latest)
            else:
                sapmachine_branches.append([branch['name'], 0])

    sapmachine_latest += 1

    for branch in sapmachine_branches:
        if branch[1] == 0:
            branch[1] = sapmachine_latest

        major = branch[1]
        utils.run_cmd(str.format('git checkout {0}', branch[0]).split(' '),
                      cwd=git_target_dir)

        # find the last merge commit and check wether it is a merge from the jdk branch
        _, commit_messages, _ = utils.run_cmd(
            'git log --merges -n 50 --format=%s'.split(' '),
            cwd=git_target_dir,
            std=True,
            throw=False)
        _, commit_ids, _ = utils.run_cmd(
            'git log --merges -n 50 --format=%H'.split(' '),
            cwd=git_target_dir,
            std=True,
            throw=False)

        if commit_messages and commit_ids:
            commit_messages = [
                commit_message
                for commit_message in commit_messages.split(os.linesep)
                if commit_message
            ]
            commit_ids = [
                commit_id for commit_id in commit_ids.split(os.linesep)
                if commit_id
            ]

        merge_commits = map(lambda x, y: [x, y], commit_messages, commit_ids)

        for merge_commit in merge_commits:
            commit_message = merge_commit[0]
            commit_id = merge_commit[1]
            match_merge_commit = re.search(merge_commit_pattern,
                                           commit_message)
            match_jdk_tag = re.search(JDKTag.jdk_tag_pattern, commit_message)

            if match_merge_commit is not None and match_jdk_tag is not None:
                jdk_tag = JDKTag(match_jdk_tag)
                print(
                    str.format(
                        'found latest merge commit "{0}" for branch "{1}"',
                        commit_message, branch))
                _, tags, _ = utils.run_cmd(str.format('git tag --contains {0}',
                                                      commit_id).split(' '),
                                           cwd=git_target_dir,
                                           std=True,
                                           throw=False)

                if not tags:
                    # not tagged yet
                    # create sapmachine tag
                    create_sapmachine_tag(jdk_tag, commit_id, git_target_dir)
                    run_jenkins_jobs(major, jdk_tag.as_sapmachine_tag())
                elif not jdk_tag.is_ga():
                    tags = tags.splitlines()
                    # check wether there is a JDK GA tag which has no corresponding sapmachine tag yet
                    # get the commit to which the most recent (before GA) tag is pointing to
                    _, jdk_tag_commit, _ = utils.run_cmd(str.format(
                        'git rev-list -n 1 {0}',
                        jdk_tag.as_string()).split(' '),
                                                         cwd=git_target_dir,
                                                         std=True,
                                                         throw=False)

                    if jdk_tag_commit:
                        jdk_tag_commit = jdk_tag_commit.rstrip()
                        # get all tags associated with the commit
                        _, tags_for_commit, _ = utils.run_cmd(
                            str.format('git tag --contains {0}',
                                       jdk_tag_commit).split(' '),
                            cwd=git_target_dir,
                            std=True,
                            throw=False)

                        if tags_for_commit:
                            tags_for_commit = tags_for_commit.splitlines()

                            # search for a GA tag
                            for tag in tags_for_commit:
                                match = re.search(JDKTag.jdk_tag_pattern, tag)

                                if match:
                                    as_jdk_tag = JDKTag(match)

                                    if as_jdk_tag.is_ga(
                                    ) and as_jdk_tag.as_sapmachine_tag(
                                    ) not in tags:
                                        # GA tag found
                                        # check whether there is already a pull request for this tag
                                        pull_request_title = str.format(
                                            'Merge to tag {0}',
                                            as_jdk_tag.as_string())
                                        pull_request_exits = False

                                        for pull_request in pull_requests:
                                            if pull_request[
                                                    'title'] == pull_request_title:
                                                # there is already a pull request for this tag
                                                # don't create sapmachine tag
                                                pull_request_exits = True
                                                break

                                        if not pull_request_exits:
                                            # create sapmachine tag
                                            create_sapmachine_tag(
                                                as_jdk_tag, commit_id,
                                                git_target_dir)
                                            run_jenkins_jobs(
                                                major,
                                                as_jdk_tag.as_sapmachine_tag())

                                        break

                    else:
                        print('already tagged ...')

                break

    utils.remove_if_exists(workdir)
    return 0
Пример #22
0
def main(argv=None):
    parser = argparse.ArgumentParser()
    parser.add_argument('-t', '--tag', help='the tag to create the debian packages from', metavar='TAG', required=True)
    parser.add_argument('-d', '--templates-directory', help='specify the templates directory', metavar='DIR', required=True)
    args = parser.parse_args()

    templates_dir = realpath(args.templates_directory)
    tag = args.tag

    if tag.endswith('-alpine'):
        # the "-alpine" tags do not contain any assets
        tag = tag[:-len('-alpine')]

    cwd = os.getcwd()
    work_dir = join(cwd, 'deb_work')
    version, version_part, major, build_number, sap_build_number, os_ext = utils.sapmachine_tag_components(tag)
    version = version.replace('-', '.')
    jdk_name = str.format('sapmachine-{0}-jdk-{1}', major, version)
    jre_name = str.format('sapmachine-{0}-jre-{1}', major, version)

    jdk_url, jre_url = utils.fetch_tag(tag, 'linux-x64', utils.get_github_api_accesstoken())

    utils.remove_if_exists(work_dir)
    mkdir(work_dir)

    jdk_archive = join(work_dir, jdk_url.rsplit('/', 1)[-1])
    jre_archive = join(work_dir, jre_url.rsplit('/', 1)[-1])

    utils.download_artifact(jdk_url, jdk_archive)
    utils.download_artifact(jre_url, jre_archive)

    clone_sapmachine(join(work_dir, 'sapmachine_master'))
    src_dir = join(work_dir, 'sapmachine_master')

    jdk_dir = join(work_dir, jdk_name)
    jre_dir = join(work_dir, jre_name)

    mkdir(jdk_dir)
    mkdir(jre_dir)

    utils.extract_archive(jdk_archive, jdk_dir)
    utils.extract_archive(jre_archive, jre_dir)

    env = os.environ.copy()
    env['DEBFULLNAME'] = 'SapMachine'
    env['DEBEMAIL'] = '*****@*****.**'
    utils.run_cmd(['dh_make', '-n', '-s', '-y'], cwd=jdk_dir, env=env)
    utils.run_cmd(['dh_make', '-n', '-s', '-y'], cwd=jre_dir, env=env)

    jre_exploded_image = glob.glob(join(jre_dir, 'sapmachine-*'))[0]

    generate_configuration(
        templates_dir=join(templates_dir, 'jre'),
        major=major,
        target_dir=join(jre_dir, 'debian'),
        exploded_image=jre_exploded_image,
        src_dir=src_dir,
        download_url=jre_url)

    jdk_exploded_image = glob.glob(join(jdk_dir, 'sapmachine-*'))[0]

    generate_configuration(
        templates_dir=join(templates_dir, 'jdk'),
        major=major,
        target_dir=join(jdk_dir, 'debian'),
        exploded_image=jdk_exploded_image,
        src_dir=src_dir,
        download_url=jdk_url)

    utils.run_cmd(['debuild', '-b', '-uc', '-us'], cwd=jre_dir, env=env)
    utils.run_cmd(['debuild', '-b', '-uc', '-us'], cwd=jdk_dir, env=env)

    deb_files = glob.glob(join(work_dir, '*.deb'))

    for deb_file in deb_files:
        copy(deb_file, cwd)
        remove(deb_file)
Пример #23
0
def main(argv=None):
    parser = argparse.ArgumentParser()
    parser.add_argument('-a',
                        '--asset',
                        help='the SapMachine asset file',
                        metavar='ASSET',
                        required=True)
    parser.add_argument('-j',
                        '--jre',
                        help='Build SapMachine JRE installer',
                        action='store_true',
                        default=False)
    parser.add_argument('-s',
                        '--sapmachine-directory',
                        help='specify the SapMachine GIT directory',
                        metavar='DIR',
                        required=True)
    args = parser.parse_args()

    cwd = os.getcwd()
    work_dir = join(cwd, 'msi_work')
    asset = os.path.realpath(args.asset)
    is_jre = args.jre
    sapmachine_git_dir = args.sapmachine_directory
    products = None
    product_id = None
    upgrade_code = None

    utils.remove_if_exists(work_dir)
    os.makedirs(work_dir)

    utils.extract_archive(asset, work_dir, remove_archive=False)
    sapmachine_folder = glob.glob(join(work_dir, 'sapmachine*'))
    os.rename(sapmachine_folder[0], join(work_dir, 'SourceDir'))

    _, _, version_output = utils.run_cmd(
        [join(work_dir, 'SourceDir', 'bin', 'java.exe'), '-version'], std=True)

    version, version_part, major, version_sap, build_number = utils.sapmachine_version_components(
        version_output, multiline=True)
    sapmachine_version = [e for e in version_part.split('.')]

    if len(sapmachine_version) < 3:
        sapmachine_version += [
            '0' for sapmachine_version in range(0, 3 - len(sapmachine_version))
        ]

    if len(sapmachine_version) == 4:
        sapmachine_version[3] = str((int(sapmachine_version[3]) << 8) & 0xFF00)

    if len(sapmachine_version) == 5:
        merged_version = str((int(sapmachine_version[3]) << 8)
                             | (int(sapmachine_version[4]) & 0xFF))

        del sapmachine_version[4]
        sapmachine_version[3] = merged_version

    sapmachine_version = '.'.join(sapmachine_version)

    shutil.copyfile(
        join(sapmachine_git_dir, 'src', 'java.base', 'windows', 'native',
             'launcher', 'icons', 'awt.ico'), join(work_dir, 'sapmachine.ico'))
    write_as_rtf(join(sapmachine_git_dir, 'LICENSE'),
                 join(work_dir, 'license.rtf'))

    infrastructure_dir = join(work_dir, 'sapmachine_infrastructure')
    templates_dir = join(infrastructure_dir, 'wix-templates')
    utils.git_clone('github.com/SAP/SapMachine-infrastructure', 'master',
                    infrastructure_dir)

    with open(join(templates_dir, 'products.yml'), 'r') as products_yml:
        products = yaml.safe_load(products_yml.read())

    image_type = 'jre' if is_jre else 'jdk'

    if products[image_type] is None or major not in products[image_type]:
        product_id = str(uuid.uuid4())
        upgrade_code = str(uuid.uuid4())
        if products[image_type] is None:
            products[image_type] = {}
        products[image_type][major] = {
            'product_id': product_id,
            'upgrade_code': upgrade_code
        }

        with open(join(templates_dir, 'products.yml'), 'w') as products_yml:
            products_yml.write(yaml.dump(products, default_flow_style=False))

        utils.git_commit(infrastructure_dir, 'Updated product codes.',
                         [join('wix-templates', 'products.yml')])
        utils.git_push(infrastructure_dir)
    else:
        product_id = products[image_type][major]['product_id']
        upgrade_code = products[image_type][major]['upgrade_code']

    create_sapmachine_wxs(
        join(
            templates_dir, 'SapMachine.jre.wxs.template'
            if is_jre else 'SapMachine.jdk.wxs.template'),
        join(work_dir, 'SapMachine.wxs'), product_id, upgrade_code,
        sapmachine_version, major)

    shutil.copyfile(join(work_dir, 'SourceDir', 'release'),
                    join(work_dir, 'release'))
    utils.remove_if_exists(join(work_dir, 'SourceDir', 'release'))

    utils.run_cmd(
        'heat dir SourceDir -swall -srd -gg -platform x64 -template:module -cg SapMachineGroup -out SapMachineModule.wxs'
        .split(' '),
        cwd=work_dir)

    with open(join(work_dir, 'SapMachineModule.wxs'),
              'r+') as sapmachine_module:
        sapmachine_module_content = sapmachine_module.read()
        sapmachine_module_content = sapmachine_module_content.replace(
            'PUT-MODULE-NAME-HERE', 'SapMachineModule')
        sapmachine_module_content = sapmachine_module_content.replace(
            'PUT-COMPANY-NAME-HERE', 'SapMachine Team')
        sapmachine_module.seek(0)
        sapmachine_module.truncate()
        sapmachine_module.write(sapmachine_module_content)

    utils.run_cmd('candle -arch x64 SapMachineModule.wxs'.split(' '),
                  cwd=work_dir)
    utils.run_cmd('light SapMachineModule.wixobj'.split(' '), cwd=work_dir)
    utils.run_cmd('candle -arch x64 SapMachine.wxs'.split(' '), cwd=work_dir)
    utils.run_cmd('light -ext WixUIExtension SapMachine.wixobj'.split(' '),
                  cwd=work_dir)

    msi_name = os.path.basename(asset)
    msi_name = os.path.splitext(msi_name)[0]
    os.rename(join(work_dir, 'SapMachine.msi'),
              join(cwd, str.format('{0}.msi', msi_name)))

    return 0
Пример #24
0
def main(argv=None):
    parser = argparse.ArgumentParser()
    parser.add_argument('--workdir',
                        help='the temporary working directory',
                        metavar='DIR',
                        default="tags_work",
                        required=False)
    args = parser.parse_args()

    workdir = os.path.realpath(args.workdir)
    utils.remove_if_exists(workdir)
    os.makedirs(workdir)
    global git_target_dir
    git_target_dir = join(workdir, 'sapmachine')

    # fetch all branches
    sapmachine_branches = utils.get_active_sapmachine_branches()
    if sapmachine_branches is None or len(sapmachine_branches) == 0:
        print("No sapmachine branches found")
        return 0

    # clone the SapMachine repository to the first branch in list
    utils.git_clone('github.com/SAP/SapMachine.git', sapmachine_branches[0][0],
                    git_target_dir)

    # go through all sapmachine branches, find the latest OpenJDK merge commit and make sure it's correctly sapmachine-tagged
    for branch in sapmachine_branches:
        # checkout branch
        utils.run_cmd(str.format('git checkout {0}', branch[0]).split(' '),
                      cwd=git_target_dir)

        # find latest merge commit
        merge_commits = get_merge_commits()
        jdk_tag = None
        for merge_commit in merge_commits:
            if re.search(merge_commit_pattern, merge_commit[0]) is None:
                print(
                    str.format('merge commit "{0}" is no OpenJDK merge',
                               merge_commit[0]))
                continue

            match_jdk_tag = re.search(JDKTag.tag_pattern, merge_commit[0])
            if match_jdk_tag is None:
                print(
                    str.format(
                        'merge commit "{0}" does not contain an OpenJDK tag pattern',
                        merge_commit[0]))
                continue

            jdk_tag = JDKTag(match_jdk_tag)
            merge_commit_message = merge_commit[0]
            merge_commit_id = merge_commit[1]
            break

        if jdk_tag is None:
            print(
                str.format('No merge commits found for branch "{0}"',
                           branch[0]))
            continue
        else:
            print(
                str.format(
                    'latest merge commit for branch "{0}" is {1}: "{2}"',
                    branch[0], merge_commit_id, merge_commit_message))

        # if the merge commit is already contained in a SapMachine tag, we're done if the merge commit's JDK tag is a ga tag
        # otherwise we run some logic to make sure a corresponding JDK ga tag is not missed out
        _, tags_of_merge_commit, _ = utils.run_cmd(str.format(
            'git tag --contains {0}', merge_commit_id).split(' '),
                                                   cwd=git_target_dir,
                                                   std=True,
                                                   throw=False)
        if tags_of_merge_commit:
            print(
                str.format('Merge commit for "{0}" was already tagged.',
                           jdk_tag.as_string()))
            if not jdk_tag.is_ga():
                check_for_untagged_ga(jdk_tag,
                                      tags_of_merge_commit.splitlines(),
                                      merge_commit_id)
            continue

        # this merge commit is not contained in a SapMachine tag but a corresponding sapmachine tag already exists pointing to somewhere else.
        # That's weird, but we don't change things now...
        if exists_tag(jdk_tag.as_sapmachine_tag_string()):
            print(
                str.format(
                    '"{0}" is already tagged as "{1}" but does not include this merge commit. That could be a problem.',
                    jdk_tag.as_string(), jdk_tag.as_sapmachine_tag_string()))
            continue

        # create the sapmachine tag
        create_sapmachine_tag(jdk_tag, merge_commit_id)

        if jdk_tag.is_ga():
            # when the tag is a GA tag and the last non-ga tag was not yet tagged, we tag it to the same commit and build it
            make_sure_last_non_ga_is_tagged(jdk_tag, merge_commit_id)
        else:
            # build the new tag (EA release)
            run_jenkins_jobs(jdk_tag.get_major(),
                             jdk_tag.as_sapmachine_tag_string())

    utils.remove_if_exists(workdir)
    return 0
Пример #25
0
def main(argv=None):
    parser = argparse.ArgumentParser()
    parser.add_argument('-t', '--tag', help='the tag to create the debian packages from', metavar='TAG', required=True)
    args = parser.parse_args()

    tag = args.tag

    cwd = os.getcwd()
    work_dir = join(cwd, 'rpm_work')
    version, version_part, major, update, version_sap, build_number, os_ext = utils.sapmachine_tag_components(tag)
    version = version.replace('-', '.')
    jdk_name = str.format('sapmachine-jdk-{0}', version)

    jdk_url, jre_url = utils.get_asset_url(tag, 'linux-x64')

    utils.remove_if_exists(work_dir)
    mkdir(work_dir)

    jdk_archive = join(work_dir, jdk_url.rsplit('/', 1)[-1])

    utils.download_artifact(jdk_url, jdk_archive)
    utils.extract_archive(jdk_archive, work_dir)

    bin_dir = join(work_dir, jdk_name, 'bin')
    tools = [f for f in listdir(bin_dir) if isfile(join(bin_dir, f))]
    alternatives = []
    alternatives_t = Template(alternatives_template)

    for tool in tools:
        alternatives.append(alternatives_t.substitute(tool=tool, major=major))

    alternatives = '\n'.join(alternatives)

    specfile_t = Template(spec_template)
    specfile_content = specfile_t.substitute(
        version=version,
        major=major,
        alternatives=alternatives,
        workdir=work_dir
    )

    with open(join(work_dir, 'sapmachine.spec'), 'w') as specfile:
        specfile.write(specfile_content)

    rpmbuild_dir = join(work_dir, 'rpmbuild')
    mkdir(rpmbuild_dir)

    rpmbuild_cmd = str.format('rpmbuild -bb -v --buildroot={0}/BUILD {0}/sapmachine.spec', work_dir)
    rpmbuild_cmd = rpmbuild_cmd.split(' ')
    rpmbuild_cmd.append('--define')
    rpmbuild_cmd.append(str.format('_rpmdir {0}', work_dir))
    rpmbuild_cmd.append('--define')
    rpmbuild_cmd.append(str.format('_topdir {0}', rpmbuild_dir))
    utils.run_cmd(rpmbuild_cmd, cwd=work_dir)

    rpm_files = glob.glob(join(work_dir, 'x86_64', '*.rpm'))

    for rpm_file in rpm_files:
        copy(rpm_file, cwd)
        remove(rpm_file)

    return 0
Пример #26
0
def main(argv=None):
    parser = argparse.ArgumentParser()
    parser.add_argument('-t',
                        '--tag',
                        help='the GIT tag to build the image from',
                        metavar='GIT_TAG',
                        required=True)
    parser.add_argument('-i',
                        '--imagetype',
                        help='sets the image type',
                        choices=['jdk', 'test'],
                        required=True)
    parser.add_argument('-p',
                        '--publish',
                        help='publish the image',
                        action='store_true',
                        default=False)
    parser.add_argument('--latest',
                        help='tag image as latest',
                        action='store_true',
                        default=False)
    parser.add_argument('--workdir',
                        help='specify the working directory',
                        metavar='DIR',
                        required=False)
    args = parser.parse_args()

    tag = args.tag
    image_type = args.imagetype
    publish = args.publish
    latest = args.latest
    workdir = args.workdir
    tag_is_release = utils.sapmachine_tag_is_release(tag)

    version, version_part, major, build_number, sap_build_number, os_ext = utils.sapmachine_tag_components(
        tag)

    if version is None:
        raise Exception(str.format('Invalid tag: {0}', tag))

    dependencies = 'wget ca-certificates'

    if image_type == 'test':
        dependencies += ' zip git unzip realpath python binutils'
        add_user = '******'
    else:
        add_user = ''

    if build_number:
        package = str.format('sapmachine-{0}-jdk={1}+{2}.{3}', major,
                             version_part, build_number,
                             sap_build_number if sap_build_number else '0')
    else:
        package = str.format('sapmachine-{0}-jdk={1}', major, version_part)

    if workdir is None:
        workdir = join(os.getcwd(), 'docker_work', image_type)

    utils.remove_if_exists(workdir)
    os.makedirs(workdir)

    template = template_ubuntu

    with open(join(workdir, 'Dockerfile'), 'w+') as dockerfile:
        dockerfile.write(
            Template(template).substitute(dependencies=dependencies,
                                          package=package,
                                          add_user=add_user))

    if 'DOCKER_USER' in os.environ and image_type != 'test':
        docker_user = os.environ['DOCKER_USER']
        sapmachine_version = [int(e) for e in version_part.split('.')]
        expand = 5 if sap_build_number else 3
        sapmachine_version += [
            0 for sapmachine_version in range(0, expand -
                                              len(sapmachine_version))
        ]

        if sap_build_number:
            sapmachine_version[4] = int(sap_build_number)

        sapmachine_version_string = '.'.join(
            [str(e) for e in sapmachine_version])

        docker_tag = str.format('{0}/jdk{1}:{2}{3}', docker_user, major,
                                sapmachine_version_string,
                                '.b' + build_number if build_number else '')

        docker_tag_latest = str.format('{0}/jdk{1}:latest', docker_user, major)

        if latest:
            utils.run_cmd([
                'docker', 'build', '-t', docker_tag, '-t', docker_tag_latest,
                workdir
            ])
        else:
            utils.run_cmd(['docker', 'build', '-t', docker_tag, workdir])

        retcode, out, err = utils.run_cmd(
            ['docker', 'run', docker_tag, 'java', '-version'],
            throw=False,
            std=True)

        if retcode != 0:
            raise Exception(str.format('Failed to run Docker image: {0}', err))

        version_2, version_part_2, major_2, build_number_2, sap_build_number_2 = utils.sapmachine_version_components(
            err, multiline=True)

        if version_part != version_part_2 or (
                build_number and (build_number != build_number_2)) or (
                    sap_build_number and
                    (sap_build_number != sap_build_number_2)):
            raise Exception(
                str.format('Invalid version found in Docker image:\n{0}', err))

        retcode, out, err = utils.run_cmd(
            ['docker', 'run', docker_tag, 'which', 'javac'],
            throw=False,
            std=True)

        if retcode != 0 or not out:
            raise Exception('Image type is not JDK')

        if publish and 'DOCKER_PASSWORD' in os.environ:
            docker_password = os.environ['DOCKER_PASSWORD']
            utils.run_cmd(
                ['docker', 'login', '-u', docker_user, '-p', docker_password])
            utils.run_cmd(['docker', 'push', docker_tag])

            if latest:
                utils.run_cmd(['docker', 'push', docker_tag_latest])
Пример #27
0
def main(argv=None):
    parser = argparse.ArgumentParser()
    parser.add_argument('-m',
                        '--major',
                        help='the SapMachine major version',
                        metavar='MAJOR',
                        required=True)
    args = parser.parse_args()

    token = utils.get_github_api_accesstoken()
    github_api = 'https://api.github.com/repos/SAP/SapMachine/releases'
    asset_pattern = re.compile(utils.sapmachine_asset_pattern())
    asset_map = {}

    request = Request(github_api)

    if token is not None:
        request.add_header('Authorization', str.format('token {0}', token))

    response = json.loads(urlopen(request).read())
    for release in response:
        if release['prerelease'] is True:
            continue

        version, version_part, major, build_number, sap_build_number, os_ext = utils.sapmachine_tag_components(
            release['name'])
        assets = release['assets']

        if version is None or os_ext:
            continue

        if args.major == major:
            for asset in assets:
                match = asset_pattern.match(asset['name'])

                if match is not None:
                    asset_image_type = match.group(1)
                    asset_os = match.group(3)

                    if asset_os == 'linux-x64' and asset_image_type == 'jre':
                        buildpack_version = ''
                        parts = version_part.split('.')
                        num_parts = len(parts)
                        if num_parts == 3:
                            buildpack_version = str.format(
                                '{0}_', version_part)
                        elif num_parts < 3:
                            buildpack_version = str.format(
                                '{0}{1}_', version_part,
                                '.0' * (3 - num_parts))
                        elif num_parts > 3:
                            buildpack_version = str.format(
                                '{0}.{1}.{2}_{3}', parts[0], parts[1],
                                parts[2], parts[3])

                        buildpack_version += str.format('b{0}', build_number)

                        if sap_build_number:
                            buildpack_version += str.format(
                                's{0}', sap_build_number)

                        asset_map[buildpack_version] = asset[
                            'browser_download_url']

    local_repo = join(os.getcwd(), 'gh-pages')
    utils.git_clone('github.com/SAP/SapMachine.git', 'gh-pages', local_repo)
    write_index_yaml(
        asset_map,
        join(local_repo, 'assets', 'cf', 'jre', args.major, 'linux', 'x86_64'))
    utils.git_commit(local_repo, 'Updated index.yml', ['assets'])
    utils.git_push(local_repo)
    utils.remove_if_exists(local_repo)
Пример #28
0
def main(argv=None):
    parser = argparse.ArgumentParser()
    parser.add_argument('-t',
                        '--tag',
                        help='the SapMachine tag',
                        metavar='TAG',
                        required=True)
    parser.add_argument(
        '-d',
        '--dual',
        help='this is going to be a dual architecture cask (x64 and aarch64)',
        action='store_true',
        default=False)
    args = parser.parse_args()

    work_dir = join(os.getcwd(), 'cask_work')
    utils.remove_if_exists(work_dir)
    os.makedirs(work_dir)

    raw_tag = args.tag
    sapMachineTag = SapMachineTag.from_string(raw_tag)
    if sapMachineTag is None:
        print(str.format("Tag {0} seems to be invalid. Aborting...", args.tag))
        sys.exit(1)

    os_name = 'osx' if sapMachineTag.get_major() < 17 or (
        sapMachineTag.get_major() == 17 and sapMachineTag.get_update() is None
        and sapMachineTag.get_build_number() < 21) else 'macos'
    prerelease = not sapMachineTag.is_ga()
    if prerelease:
        jdk_cask_file_name = str.format('sapmachine{0}-ea-jdk.rb',
                                        sapMachineTag.get_major())
        jre_cask_file_name = str.format('sapmachine{0}-ea-jre.rb',
                                        sapMachineTag.get_major())
        cask_tag = str.format('{0}-ea', sapMachineTag.get_major())
        cask_version = str.format(
            '{0},{1}', sapMachineTag.get_version_string_without_build(),
            sapMachineTag.get_build_number())
        ruby_version = 'version.before_comma'
        ea_ext = '-ea.'
        url_version1 = '#{version.before_comma}%2B#{version.after_comma}'
        url_version2 = '#{version.before_comma}-ea.#{version.after_comma}'
    else:
        jdk_cask_file_name = str.format('sapmachine{0}-jdk.rb',
                                        sapMachineTag.get_major())
        jre_cask_file_name = str.format('sapmachine{0}-jre.rb',
                                        sapMachineTag.get_major())
        cask_tag = str.format('{0}', sapMachineTag.get_major())
        cask_version = str.format(
            '{0}', sapMachineTag.get_version_string_without_build())
        ruby_version = 'version'
        ea_ext = '.'
        url_version1 = '#{version}'
        url_version2 = '#{version}'

    if args.dual:
        try:
            aarch_jdk_sha_url, aarch_jre_sha_url = utils.get_asset_url(
                raw_tag, os_name + '-aarch64', '.sha256.dmg.txt')
            intel_jdk_sha_url, intel_jre_sha_url = utils.get_asset_url(
                raw_tag, os_name + '-x64', '.sha256.dmg.txt')
        except Exception as e:
            print('Not both platforms ready yet')
            sys.exit(0)

        aarch_jdk_sha, code1 = utils.download_asset(aarch_jdk_sha_url)
        aarch_jre_sha, code2 = utils.download_asset(aarch_jre_sha_url)
        intel_jdk_sha, code3 = utils.download_asset(intel_jdk_sha_url)
        intel_jre_sha, code4 = utils.download_asset(intel_jre_sha_url)
        if code1 != 200 or code2 != 200 or code3 != 200 or code4 != 200:
            print('Download failed')
            sys.exit(1)
        aarch_jdk_sha = aarch_jdk_sha.split(' ')[0]
        aarch_jre_sha = aarch_jre_sha.split(' ')[0]
        intel_jdk_sha = intel_jdk_sha.split(' ')[0]
        intel_jre_sha = intel_jre_sha.split(' ')[0]

        jdk_cask_content = Template(duplex_cask_template).substitute(
            CASK_TAG=cask_tag,
            IMAGE_TYPE='jdk',
            CASK_VERSION=cask_version,
            URL_VERSION1=url_version1,
            URL_VERSION2=url_version2,
            OS_NAME=os_name,
            INTELSHA256=intel_jdk_sha,
            AARCHSHA256=aarch_jdk_sha,
            RUBY_VERSION=ruby_version,
            EA_EXT=ea_ext)

        jre_cask_content = Template(duplex_cask_template).substitute(
            CASK_TAG=cask_tag,
            IMAGE_TYPE='jre',
            CASK_VERSION=cask_version,
            URL_VERSION1=url_version1,
            URL_VERSION2=url_version2,
            OS_NAME=os_name,
            INTELSHA256=intel_jre_sha,
            AARCHSHA256=aarch_jre_sha,
            RUBY_VERSION=ruby_version,
            EA_EXT=ea_ext)
    else:
        try:
            intel_jdk_sha_url, intel_jre_sha_url = utils.get_asset_url(
                raw_tag, os_name + '-x64', '.sha256.dmg.txt')
        except Exception as e:
            print('Asset not found')
            sys.exit(1)

        intel_jdk_sha, code1 = utils.download_asset(intel_jdk_sha_url)
        intel_jre_sha, code2 = utils.download_asset(intel_jre_sha_url)
        if code1 != 200 or code2 != 200:
            print('Download failed')
            sys.exit(1)
        intel_jdk_sha = intel_jdk_sha.split(' ')[0]
        intel_jre_sha = intel_jre_sha.split(' ')[0]
        try:
            intel_jdk_url, intel_jre_url = utils.get_asset_url(
                raw_tag, os_name + '-x64', '.dmg')
        except Exception as e:
            print('Asset not found')
            sys.exit(1)

        jdk_cask_content = Template(cask_template).substitute(
            CASK_TAG=cask_tag,
            IMAGE_TYPE='jdk',
            CASK_VERSION=cask_version,
            SHA256=intel_jdk_sha,
            URL_VERSION1=url_version1,
            URL_VERSION2=url_version2,
            OS_NAME=os_name,
            RUBY_VERSION=ruby_version,
            EA_EXT=ea_ext)

        jre_cask_content = Template(cask_template).substitute(
            CASK_TAG=cask_tag,
            IMAGE_TYPE='jre',
            CASK_VERSION=cask_version,
            SHA256=intel_jre_sha,
            URL_VERSION1=url_version1,
            URL_VERSION2=url_version2,
            OS_NAME=os_name,
            RUBY_VERSION=ruby_version,
            EA_EXT=ea_ext)

    homebrew_dir = join(work_dir, 'homebrew')
    utils.git_clone('github.com/SAP/homebrew-SapMachine', 'master',
                    homebrew_dir)

    jdk_replaced = replace_cask(jdk_cask_file_name, jdk_cask_content,
                                sapMachineTag, homebrew_dir)
    jre_replaced = replace_cask(jre_cask_file_name, jre_cask_content,
                                sapMachineTag, homebrew_dir)
    if jdk_replaced or jre_replaced:
        utils.git_push(homebrew_dir)
    utils.remove_if_exists(work_dir)

    return 0
Пример #29
0
def main(argv=None):
    parser = argparse.ArgumentParser()
    parser.add_argument('-t',
                        '--tag',
                        help='the GIT tag to build the image from',
                        metavar='GIT_TAG',
                        required=True)
    parser.add_argument('-i',
                        '--imagetype',
                        help='sets the image type',
                        choices=['jdk', 'jre', 'test'],
                        required=True)
    parser.add_argument('-p',
                        '--publish',
                        help='publish the image',
                        action='store_true',
                        default=False)
    parser.add_argument('--alpine',
                        help='build Alpine Linux image',
                        action='store_true',
                        default=False)
    parser.add_argument('--latest',
                        help='tag image as latest',
                        action='store_true',
                        default=False)
    args = parser.parse_args()

    tag = args.tag
    image_type = args.imagetype
    publish = args.publish
    build_alpine = args.alpine
    latest = args.latest

    version, version_part, major, build_number, sap_build_number, os_ext = utils.sapmachine_tag_components(
        tag)

    if version is None:
        raise Exception(str.format('Invalid tag: {0}', tag))

    dependencies = 'wget ca-certificates'

    if image_type == 'test':
        if build_alpine:
            dependencies += ' zip git unzip coreutils python binutils shadow bash'
            add_user = '******'
        else:
            dependencies += ' zip git unzip realpath python binutils'
            add_user = '******'
    else:
        add_user = ''

    if build_alpine:
        package = str.format('sapmachine-{0}-{1}={2}.{3}.{4}-r0', major,
                             'jdk' if image_type == 'test' else image_type,
                             version_part, build_number, sap_build_number)
    else:
        package = str.format('sapmachine-{0}-{1}={2}+{3}.{4}', major,
                             'jdk' if image_type == 'test' else image_type,
                             version_part, build_number, sap_build_number)

    docker_work = join(os.getcwd(), 'docker_work', image_type)

    utils.remove_if_exists(join(os.getcwd(), 'docker_work'))
    os.makedirs(docker_work)

    if build_alpine:
        template = template_alpine
    else:
        template = template_ubuntu

    with open(join(docker_work, 'Dockerfile'), 'w+') as dockerfile:
        dockerfile.write(
            Template(template).substitute(dependencies=dependencies,
                                          package=package,
                                          add_user=add_user))

    if 'DOCKER_USER' in os.environ and image_type != 'test':
        docker_user = os.environ['DOCKER_USER']
        match = re.match(r'([0-9]+)(\.[0-9]+)?(\.[0-9]+)?', version_part)
        version_part_expanded = version_part

        i = 0
        while i < (3 - match.lastindex):
            version_part_expanded += '.0'
            i += 1

        docker_tag = str.format('{0}/jdk{1}:{2}.{3}.{4}{5}{6}', docker_user,
                                major, version_part_expanded, build_number,
                                sap_build_number,
                                '-jre' if image_type == 'jre' else '',
                                '-alpine' if build_alpine else '')

        docker_tag_latest = str.format('{0}/jdk{1}:latest{2}{3}', docker_user,
                                       major,
                                       '-jre' if image_type == 'jre' else '',
                                       '-alpine' if build_alpine else '')

        if latest:
            utils.run_cmd([
                'docker', 'build', '-t', docker_tag, '-t', docker_tag_latest,
                docker_work
            ])
        else:
            utils.run_cmd(['docker', 'build', '-t', docker_tag, docker_work])

        retcode, out, err = utils.run_cmd(
            ['docker', 'run', docker_tag, 'java', '-version'],
            throw=False,
            std=True)

        if retcode != 0:
            raise Exception(str.format('Failed to run Docker image: {0}', err))

        version_2, version_part_2, major_2, build_number_2, sap_build_number_2 = utils.sapmachine_version_components(
            err, multiline=True)

        if version_part != version_part_2 or build_number != build_number_2 or sap_build_number != sap_build_number_2:
            raise Exception(
                str.format('Invalid version found in Docker image:\n{0}', err))

        retcode, out, err = utils.run_cmd(
            ['docker', 'run', docker_tag, 'which', 'javac'],
            throw=False,
            std=True)

        if image_type == 'jdk':
            if retcode != 0 or not out:
                raise Exception('Image type is not JDK')
        else:
            if retcode == 0:
                raise Exception('Image type is not JRE')

        if publish and 'DOCKER_PASSWORD' in os.environ:
            docker_password = os.environ['DOCKER_PASSWORD']
            utils.run_cmd(
                ['docker', 'login', '-u', docker_user, '-p', docker_password])
            utils.run_cmd(['docker', 'push', docker_tag])

            if latest:
                utils.run_cmd(['docker', 'push', docker_tag_latest])
def main(argv=None):
    parser = argparse.ArgumentParser()
    parser.add_argument('-m',
                        '--major',
                        help='the SapMachine major version to build',
                        metavar='MAJOR',
                        required=True)
    parser.add_argument('-d',
                        '--destination',
                        help='the download destination',
                        metavar='DIR',
                        required=True)
    args = parser.parse_args()

    boot_jdk_major_max = int(args.major)
    boot_jdk_major_min = boot_jdk_major_max - 1
    destination = os.path.realpath(args.destination)
    releases = utils.get_github_releases()
    platform = str.format('{0}-{1}_bin', utils.get_system(), utils.get_arch())
    retries = 2

    releases = extra_bootjdks + releases

    while retries > 0:
        for release in releases:

            if release['prerelease']:
                continue

            tag = SapMachineTag.from_string(release['name'])

            if tag is None:
                print(
                    str.format("SapMachine release {0} not recognized",
                               release['name']))
                continue
            major = tag.get_major()

            if major <= boot_jdk_major_max and major >= boot_jdk_major_min:
                assets = release['assets']

                for asset in assets:
                    asset_name = asset['name']
                    asset_url = asset['browser_download_url']

                    if 'jdk' in asset_name and platform in asset_name and (
                            asset_name.endswith('.tar.gz')
                            or asset_name.endswith('.zip')
                    ) and 'symbols' not in asset_name:
                        archive_path = join(destination, asset_name)
                        utils.remove_if_exists(archive_path)
                        utils.download_artifact(asset_url, archive_path)
                        boot_jdk_exploded = join(destination, 'boot_jdk')
                        utils.remove_if_exists(boot_jdk_exploded)
                        os.makedirs(boot_jdk_exploded)
                        utils.extract_archive(archive_path, boot_jdk_exploded)

                        sapmachine_folder = [
                            f for f_ in [
                                glob.glob(join(boot_jdk_exploded, e))
                                for e in ('sapmachine*', 'jdk*')
                            ] for f in f_
                        ]

                        if sapmachine_folder is not None:
                            sapmachine_folder = sapmachine_folder[0]
                            files = os.listdir(sapmachine_folder)

                            for f in files:
                                shutil.move(join(sapmachine_folder, f),
                                            boot_jdk_exploded)

                            utils.remove_if_exists(sapmachine_folder)

                            if utils.get_system() == 'osx':
                                files = os.listdir(
                                    join(boot_jdk_exploded, 'Contents',
                                         'Home'))

                                for f in files:
                                    shutil.move(
                                        join(boot_jdk_exploded, 'Contents',
                                             'Home', f), boot_jdk_exploded)

                                utils.remove_if_exists(
                                    join(boot_jdk_exploded, 'Contents'))

                        return 0
        retries -= 1
        if retries == 1:
            boot_jdk_major_min = boot_jdk_major_max - 2

    return 0
def main(argv=None):
    parser = argparse.ArgumentParser()
    parser.add_argument('--workdir',
                        help='the temporary working directory',
                        metavar='DIR',
                        default="tags_work",
                        required=False)
    args = parser.parse_args()

    workdir = os.path.realpath(args.workdir)
    utils.remove_if_exists(workdir)
    os.makedirs(workdir)

    sapmachine_latest = 0
    sapmachine_branches = []

    # fetch all branches
    branches = utils.github_api_request('branches', per_page=100)

    # iterate all branches of the SapMachine repository
    for branch in branches:
        # filter for sapmachine branches
        match = branch_pattern.match(branch['name'])

        if match is not None:
            if match.group(1) is not None:
                # found sapmachine branch
                major = int(match.group(1))
                print(
                    str.format(
                        'found sapmachine branch "{0}" with major "{1}"',
                        branch['name'], major))
                sapmachine_branches.append([branch['name'], major])
                sapmachine_latest = max(sapmachine_latest, major)
            else:
                print(
                    str.format('found sapmachine branch "{0}"',
                               branch['name']))
                sapmachine_branches.append([branch['name'], 0])

    sapmachine_latest += 1

    # set the major version for "sapmachine" branch which always contains the latest changes from "jdk/jdk"
    for sapmachine_branch in sapmachine_branches:
        if sapmachine_branch[1] is 0:
            sapmachine_branch[1] = sapmachine_latest

    # fetch all tags
    jdk_tags = {}
    tags = utils.github_api_request('tags', per_page=300)

    # iterate all tags
    for tag in tags:
        # filter for jdk tags
        match = JDKTag.jdk_tag_pattern.match(tag['name'])

        if match is not None:
            # found a jdk tag
            jdk_tag = JDKTag(match)
            major = jdk_tag.get_major()

            # only store the latest jdk tag (version comparison)
            if major not in jdk_tags or jdk_tag.is_greater_than(
                    jdk_tags[major]):
                # filter jdk update tags with build number "0" like jdk-11.0.3+0
                if not (jdk_tag.is_update()
                        and jdk_tag.get_build_number() == 0):
                    jdk_tags[major] = jdk_tag

    # clone the SapMachine repository
    git_target_dir = join(workdir, 'sapmachine')
    utils.git_clone('github.com/SAP/SapMachine.git', 'sapmachine',
                    git_target_dir)

    # for each "sapmachine" branch, check whether it contains the latest jdk tag with matching major version
    for sapmachine_branch in sapmachine_branches:
        # get the latest jdk tag for this major version
        latest_tag_for_branch = jdk_tags[sapmachine_branch[1]]

        print(
            str.format('latest tag for branch "{0}" is "{1}"',
                       sapmachine_branch, latest_tag_for_branch.as_string()))

        # check whether the jdk tag is already contained in the sapmachine branch
        _, out, _ = utils.run_cmd(str.format(
            'git branch -a --contains tags/{0}',
            latest_tag_for_branch.as_string()).split(' '),
                                  cwd=git_target_dir,
                                  std=True,
                                  throw=False)
        match = re.search(containing_branches_pattern, out)

        if match is None:
            # the jdk tag is not contained i a sapmachine branch
            # create a pull request branch and a pull request.
            print(
                str.format(
                    'creating pull request "pr-{0}" with base branch "{1}"',
                    latest_tag_for_branch.as_string(), sapmachine_branch))
            utils.run_cmd(
                str.format('git checkout {0}',
                           latest_tag_for_branch.as_string()).split(' '),
                cwd=git_target_dir)
            utils.run_cmd(
                str.format('git checkout -b pr-{0}',
                           latest_tag_for_branch.as_string()).split(' '),
                cwd=git_target_dir)
            utils.run_cmd(
                str.format('git push origin pr-{0}',
                           latest_tag_for_branch.as_string()).split(' '),
                cwd=git_target_dir)

            pull_request = str.format(
                '{{ "title": "Merge to tag {0}", "body": "please pull", "head": "pr-{1}", "base": "{2}" }}',
                latest_tag_for_branch.as_string(),
                latest_tag_for_branch.as_string(), sapmachine_branch[0])

            utils.github_api_request('pulls', data=pull_request, method='POST')

    utils.remove_if_exists(workdir)
    return 0
Пример #32
0
def main(argv=None):
    parser = argparse.ArgumentParser()
    parser.add_argument('-t',
                        '--tag',
                        help='the SapMachine tag',
                        metavar='TAG',
                        required=True)
    parser.add_argument('--sha256sum',
                        help='the sha256 sum',
                        metavar='SHA256',
                        required=True)
    parser.add_argument('-i',
                        '--imagetype',
                        help='The image type',
                        metavar='IMAGETYPE',
                        choices=['jdk', 'jre'])
    parser.add_argument('-p',
                        '--prerelease',
                        help='this is a pre-release',
                        action='store_true',
                        default=False)
    args = parser.parse_args()

    cwd = os.getcwd()
    work_dir = join(cwd, 'cask_work')
    tag = args.tag
    sha256sum = args.sha256sum
    image_type = args.imagetype
    is_prerelease = args.prerelease

    cask_version_pattern = re.compile('version \'((\d+\.?)+)(,(\d+))?\'')

    utils.remove_if_exists(work_dir)
    os.makedirs(work_dir)

    version, version_part, major, build_number, sap_build_number, os_ext = utils.sapmachine_tag_components(
        tag)

    if is_prerelease:
        if build_number is None:
            print('No build number given. Aborting ...')
            sys.exit()

        cask_content = Template(pre_release_cask_template).substitute(
            MAJOR=major,
            VERSION=version_part,
            BUILD_NUMBER=build_number,
            IMAGE_TYPE=image_type,
            SHA256=sha256sum)
        cask_file_name = str.format('sapmachine{0}-ea-{1}.rb', major,
                                    image_type)
    else:
        cask_content = Template(release_cask_template).substitute(
            MAJOR=major,
            VERSION=version_part,
            IMAGE_TYPE=image_type,
            SHA256=sha256sum)
        cask_file_name = str.format('sapmachine{0}-{1}.rb', major, image_type)

    homebrew_dir = join(work_dir, 'homebrew')
    cask_dir = join(homebrew_dir, 'Casks')
    utils.git_clone('github.com/SAP/homebrew-SapMachine', 'master',
                    homebrew_dir)

    current_cask_version = None
    current_cask_build_number = None

    if os.path.exists(join(cask_dir, cask_file_name)):
        with open(join(cask_dir, cask_file_name), 'r') as cask_file:
            cask_version_match = cask_version_pattern.search(cask_file.read())

            if cask_version_match is not None:
                if len(cask_version_match.groups()) >= 1:
                    current_cask_version = cask_version_match.group(1)
                if len(cask_version_match.groups()) >= 4:
                    current_cask_build_number = cask_version_match.group(4)

    current_cask_version = version_to_tuple(current_cask_version,
                                            current_cask_build_number)
    new_cask_version = version_to_tuple(version_part, build_number)

    if new_cask_version >= current_cask_version:
        with open(join(cask_dir, cask_file_name), 'w') as cask_file:
            cask_file.write(cask_content)

        utils.git_commit(homebrew_dir,
                         str.format('Updated {0}.', cask_file_name),
                         [join('Casks', cask_file_name)])
        utils.git_push(homebrew_dir)

    return 0