def process_release(release, prefix, tags, git_dir): version, version_part, major, build_number, sap_build_number, os_ext = utils.sapmachine_tag_components( release['name']) tag_name = str.format('{0}-{1}', prefix, version_part) skip_tag = False dockerfile_dir = join(git_dir, 'dockerfiles', 'official', prefix) 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: 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))) utils.git_commit(git_dir, 'updated Dockerfile', [dockerfile_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('-m', '--major', help='the SapMachine major version', metavar='MAJOR', required=True) parser.add_argument('-s', '--separator', help='the separator char', metavar='SEPARATOR', required=False, default=' ') parser.add_argument('-p', '--include-prereleases', help='include pre-releases', action='store_true', default=False) args = parser.parse_args() requested_major = args.major separator = args.separator include_prereleases = args.include_prereleases tag_list = [] releases = github_api_request('releases') for release in releases: if release['prerelease'] is True and not include_prereleases: continue version, version_part, major, update, version_sap, build_number, os_ext = utils.sapmachine_tag_components(release['name']) if major is None or major != requested_major or os_ext: continue tag_list.append(release['name']) print(separator.join([tag for tag in tag_list]))
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('-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)
def main(argv=None): parser = argparse.ArgumentParser() parser.add_argument('-t', '--tag', help='the SapMachine tag', metavar='TAG', required=True) args = parser.parse_args() tag = args.tag version, version_part, major, build_number, sap_build_number, os_ext = utils.sapmachine_tag_components(tag) print(str.format('version: {0}, version_part: {1}, major: {2}, build_number: {3}, sap_build_number: {4}, os_ext: {5}', version, version_part, major, build_number, sap_build_number, os_ext))
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)
def main(argv=None): parser = argparse.ArgumentParser() parser.add_argument('-m', '--major', help='the SapMachine major version', metavar='MAJOR', required=True) parser.add_argument('-s', '--separator', help='the separator char', metavar='SEPARATOR', required=False, default=' ') parser.add_argument('-p', '--include-prereleases', help='include pre-releases', action='store_true', default=False) args = parser.parse_args() requested_major = args.major separator = args.separator include_prereleases = args.include_prereleases tag_list = [] token = utils.get_github_api_accesstoken() org = 'SAP' repository = 'SapMachine' github_api = str.format('https://api.github.com/repos/{0}/{1}/releases', org, repository) asset_pattern = re.compile(utils.sapmachine_asset_pattern()) 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 and not include_prereleases: continue version, version_part, major, build_number, sap_build_number, os_ext = utils.sapmachine_tag_components( release['name']) if major is None or major != requested_major or os_ext: continue tag_list.append(release['name']) print(separator.join([tag for tag in tag_list]))
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)
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('-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)
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])
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
def main(argv=None): token = utils.get_github_api_accesstoken() org = 'SAP' repository = 'SapMachine' github_api = str.format('https://api.github.com/repos/{0}/{1}/releases', org, repository) asset_pattern = re.compile(utils.sapmachine_asset_pattern()) major_dict = {} releases_dict = {} image_type_dict = {} latest_link_dict = {} 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: version, version_part, major, build_number, sap_build_number, os_ext = utils.sapmachine_tag_components( release['name']) if version is None or os_ext: continue if major in major_dict: continue major_dict[major] = True assets = release['assets'] if release['prerelease'] is not True and major not in latest_link_dict: latest_link_dict[major] = Template(latest_template).substitute( major=major, url=release['html_url']) 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) tag = release['name'] image_type = major + '-' + asset_image_type if release['prerelease'] is True: image_type += '-ea' if image_type not in image_type_dict: image_type_dict[image_type] = str.format( 'SapMachine {0} {1}{2}', major, asset_image_type, " (pre-release)" if release['prerelease'] else "") if image_type in releases_dict: releases = releases_dict[image_type] else: releases = Releases(image_type) releases_dict[image_type] = releases releases_dict[image_type].add_asset( asset['browser_download_url'], asset_os, tag) json_root = {'imageTypes': [], 'os': [], 'assets': {}} for image_type in sorted(image_type_dict): json_root['imageTypes'].append({ 'key': image_type, 'value': image_type_dict[image_type] }) def get_os_key(os): print(os) return os_description[os]['ordinal'] for os in sorted(os_description, key=get_os_key): json_root['os'].append({ 'key': os, 'value': os_description[os]['name'], 'ordinal': os_description[os]['ordinal'] }) for release in releases_dict: json_root['assets'].update(releases_dict[release].transform()) files = [{ 'location': join('assets', 'data', 'sapmachine_releases.json'), 'data': json.dumps(json_root, indent=4), 'commit_message': 'Updated release data.' }] for major in latest_link_dict: files.append({ 'location': join('latest', major, 'index.md'), 'data': latest_link_dict[major], 'commit_message': str.format('Updated latest link for SapMachine {0}', major) }) push_to_git(files)
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): token = utils.get_github_api_accesstoken() org = 'SAP' repository = 'SapMachine' asset_pattern = re.compile(utils.sapmachine_asset_pattern()) major_dict = {} release_dict = {} image_dict = {} latest_link_dict = {} releases = utils.github_api_request('releases', per_page=100) for release in releases: version, version_part, major, build_number, sap_build_number, os_ext = utils.sapmachine_tag_components( release['name']) is_prerelease = release['prerelease'] if version is None or os_ext: continue if major in major_dict: if not is_prerelease and major_dict[major]: # this is not a pre-release but the release before this was a pre-release # remove all assets if major in release_dict: release_dict[major].clear_assets() # remove entry in the image dictionary if major in image_dict: del image_dict[major] else: if not major_dict[major]: # the release before this was a release # skip, we only keep the latest release version continue major_dict[major] = is_prerelease assets = release['assets'] if is_prerelease is not True and major not in latest_link_dict: latest_link_dict[major] = Template(latest_template).substitute( major=major, url=release['html_url']) has_dmg = False for asset in assets: match = asset_pattern.match(asset['name']) if match is not None: asset_image_type = match.group(1) if asset_image_type == 'jdk': asset_os = match.group(3) file_type = match.group(4) if asset_os == 'windows-x64' and file_type == '.msi': asset_os = 'windows-x64-installer' if asset_os == 'osx-x64': if file_type == '.dmg': has_dmg = True elif has_dmg: continue tag = release['name'] image_is_lts = utils.sapmachine_is_lts( major) and not release['prerelease'] if major not in image_dict: image_dict[major] = { 'label': str.format('SapMachine {0}', major), 'lts': image_is_lts, 'ea': release['prerelease'] } if major in release_dict: releases = release_dict[major] else: releases = Releases(major) release_dict[major] = releases release_dict[major].add_asset( asset['browser_download_url'], asset_os, tag) latest_lts_version = 0 latest_non_lts_version = 0 for major in image_dict: if image_dict[major]['lts'] and int(major) > latest_lts_version: latest_lts_version = int(major) if not image_dict[major]['lts'] and not image_dict[major][ 'ea'] and int(major) > latest_non_lts_version: latest_non_lts_version = int(major) json_root = {'imageTypes': [], 'os': [], 'assets': {}} for major in sorted(image_dict): add = False if image_dict[major]['lts']: if int(major) >= latest_lts_version: add = True else: if int(major) >= latest_non_lts_version and int( major) >= latest_lts_version: add = True if add: json_root['imageTypes'].append({ 'id': major, 'label': image_dict[major]['label'], 'lts': image_dict[major]['lts'], 'ea': image_dict[major]['ea'] }) else: del image_dict[major] def get_os_key(os): return os_description[os]['ordinal'] for os in sorted(os_description, key=get_os_key): json_root['os'].append({ 'key': os, 'value': os_description[os]['name'], 'ordinal': os_description[os]['ordinal'] }) for major in release_dict: if major in image_dict: json_root['assets'].update(release_dict[major].transform()) files = [{ 'location': join('assets', 'data', 'sapmachine_releases.json'), 'data': json.dumps(json_root, indent=4), 'commit_message': 'Updated release data.' }] for major in latest_link_dict: files.append({ 'location': join('latest', major, 'index.md'), 'data': latest_link_dict[major], 'commit_message': str.format('Updated latest link for SapMachine {0}', major) }) push_to_git(files) return 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
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)
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('-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