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
