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):
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
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 download(self):
while not self.d_q.empty():
domain = self.d_q.get()
if domain == "":
continue
six.print_("downloading current verions for {}".format(domain))
if utils.download_website(domain):
six.print_("Downloded successfully")
else:
six.print_("Download Error")
time.sleep(5)
utils.git_commit(self.path)
self.__class__.commit(self.domains)
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)
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():
# Init args
parser = argparse.ArgumentParser(
description='Copy file from given commits')
parser.add_argument(
'old_commit', metavar='old_commit', type=str, nargs=1,
help='commit hash in upstream branch or browser repository '
'we want to uprev from')
parser.add_argument(
'new_commit', metavar='new_commit', type=str, nargs=1,
help='commit hash in upstream branch or browser repository '
'we want ot uprev to')
parser.add_argument(
'--dry_run', dest='dry_run', action='store_const', const=True, default=False)
parser.add_argument(
'--is_browser', dest='is_browser', action='store_const', const=True, default=False,
help='is the commit hash in browser repository')
arg = parser.parse_args(sys.argv[1:])
# Get old and new files.
old_files = utils.get_file_list(arg.old_commit[0])
new_files = utils.get_file_list(arg.new_commit[0])
if arg.is_browser:
old_files = filters.filter_file([], old_files)
new_files = filters.filter_file([], new_files)
assert filters.filter_file(old_files, []) == []
assert filters.filter_file(new_files, []) == []
# Generate a tree object for new files.
old_tree = utils.git_mktree(old_files)
new_tree = utils.git_mktree(new_files)
newroot = utils.git_commit(old_tree, [])
squashed = utils.git_commit(new_tree, [newroot])
# Generate patch for git am
patch = subprocess.check_output(['git', 'format-patch', '--stdout', newroot+b'..'+squashed])
if arg.dry_run:
print(patch.decode('utf-8'))
else:
subprocess.run(['git', 'am', '-3'], input=patch)
def push_to_git(files):
local_repo = join(os.getcwd(), 'gh-pages')
if not os.path.exists(local_repo):
utils.run_cmd("git clone --branch gh-pages --single-branch https://github.com/SAP/SapMachine.git gh-pages".split(' '))
else:
utils.run_cmd("git pull origin gh-pages".split(' '), cwd=local_repo)
commits = False
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'])
_, diff, _ = utils.run_cmd("git diff".split(' '), cwd=local_repo, std=True)
if diff.strip():
utils.git_commit(local_repo, _file['commit_message'], [location])
commits = True
if commits:
utils.run_cmd(str.format('git push {0}', sapMachinePushURL).split(' '), cwd=local_repo)
def replace_cask(cask_file_name, cask_content, sapMachineTag, homebrew_dir):
cask_version_pattern = re.compile('version \'((\d+\.?)+)(,(\d+))?\'')
current_cask_version = None
current_cask_build_number = None
cask_dir = join(homebrew_dir, 'Casks')
cask_file_path = join(cask_dir, cask_file_name)
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)])
return True
else:
print(
str.format(
"Current cask has version {0} which is not lower than {1}, no update.",
current_cask_version, sapMachineTag.get_version_tuple()))
return False
def connect_base(current_commit, base_commit):
"""Creates a merge commit that takes files from base_commit.
Literally it's identical to git merge base_commit in current_commit.
Args:
current_commit: commit hashes on where to commit to.
base_commit: commit hashes contains file histories.
"""
current_files = utils.get_file_list(current_commit)
base_files = utils.get_file_list(base_commit)
tree = utils.git_mktree(current_files + base_files)
return utils.git_commit(tree, [current_commit, base_commit],
message=b'Connect history with base %s' %
(base_commit.encode('ascii')))
def disconnect(source_commit, ref_commit):
"""Creates a commit that disconnects files from source_commit.
All files existing in ref_commit will be removed from source_commit.
Args:
source_commit: commit hash to disconnect from.
ref_commit: commit hash to be a file list reference.
"""
source_files = utils.get_file_list(source_commit)
ref_files = utils.get_file_list(ref_commit)
ref_files_set = set(ref.path for ref in ref_files)
kept_files = [ref for ref in source_files if ref.path not in ref_files_set]
tree = utils.git_mktree(kept_files)
return utils.git_commit(tree, [source_commit],
message=b'Disconnect history from %s' %
(source_commit.encode('ascii')))
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
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('--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):
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():
# Init args
parser = argparse.ArgumentParser(description='Reconnect git history')
parser.add_argument('disconnect_from',
metavar='disconnect_from',
type=str,
nargs=1,
help='disconnect history from this commit')
parser.add_argument('base_commit',
metavar='base_commit',
type=str,
nargs=1,
help='base commit to use the history')
parser.add_argument('amend_commits',
metavar='amend_commits',
type=str,
nargs='+',
help='commits to amend histories from base_commit')
arg = parser.parse_args(sys.argv[1:])
empty_commit = disconnect(arg.disconnect_from[0], arg.base_commit[0])
connected_base = connect_base(empty_commit, arg.base_commit[0])
commit_msg_cache = CommitMetadataFactory()
commit_choice_cache = {}
last_commit = connected_base
# In each iteration of the loop, it
# - re-create the new goal commit, (base + committed history + (one giant)
# uncommited history).
# - blame on new goal commit and tot of amend commits. map line-by-line
# from uncommited to past histories.
# - choose one of the past commits, reconstruct files to reflect changes in
# that commit, and create a new commits.
# last_commit, commit_msg_cache, commit_choice_cache will be persistent
# across iteratins.
while True:
# One commit is processed per iteration.
# Create virtual target commit, and its diff.
virtual_goal = utils.git_commit(arg.disconnect_from[0] + '^{tree}',
[last_commit])
diffs = utils.git_difftree(None, virtual_goal)
if not diffs:
print('No diffs are found between %s and goal.' %
(last_commit.decode('ascii'), ))
break
blames = blame_files(virtual_goal, [diff.file.path for diff in diffs])
blames_combined = search_blame_line(blames, arg.amend_commits,
virtual_goal)
commits_to_track, blame_untracked_lines = get_track_from_blames(
blames_combined, virtual_goal, arg.amend_commits,
commit_choice_cache, commit_msg_cache)
if not commits_to_track:
print('no commits to track, stopping')
break
# Stablely choose one commit from commits_to_track, and reconstruct it.
track_commit = min(commits_to_track)
print('Reconstructing commit %s: %s' %
(track_commit, commit_msg_cache[track_commit].title))
constructed_files = reconstruct_files(track_commit,
blame_untracked_lines, blames,
last_commit, virtual_goal)
# Mktree and commit with re-constructed_files.
tree = lazytree.LazyTree(filtered_utils.get_metadata(last_commit).tree)
for filename, filedata in constructed_files.items():
blob = subprocess.check_output(
['git', 'hash-object', '-w', '/dev/stdin'],
input=filedata).strip()
tree[filename] = utils.GitFile(filename, tree[filename].mode, blob)
meta = commit_msg_cache[track_commit]
last_commit = utils.git_commit(
tree.hash(), [last_commit],
(meta.message + b'\n(Reconstructed from ' + track_commit + b')\n'),
dict(GIT_AUTHOR_NAME=meta.authorship.name,
GIT_AUTHOR_EMAIL=meta.authorship.email,
GIT_AUTHOR_DATE=b' '.join(
[meta.authorship.time, meta.authorship.timezone])))
print('Reconstructed as', last_commit)
# Make last commit for history reconstruction.
print(
utils.git_commit(
filtered_utils.get_metadata(arg.disconnect_from[0]).tree,
[last_commit],
b'Finished history reconstruction\n\nRemoving unnecessary lines\n')
)
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)
