def test_simple(self):
r1 = git_temp_repo(debug=self.DEBUG)
r1.add_file('coconut', 'coconut')
r1.push('origin', 'master')
r2 = git_repo(self.make_temp_dir(), address=r1.address)
r2.clone_or_pull()
r2.add_file('kiwi', 'kiwi')
r1.add_file('lemon', 'lemon')
r1.push()
r2.push_with_rebase()
r3 = git_repo(self.make_temp_dir(), address=r1.address)
r3.clone_or_pull()
self.assertEqual(['coconut', 'kiwi', 'lemon'], r3.find_all_files())
def __init__(self, working_dir, repo_address, branch):
root_dir = path.join(
working_dir,
git_address_util.sanitize_for_local_path(repo_address), branch)
self.repo = git_repo(root_dir, repo_address)
self.repo.clone_or_pull()
self.repo.checkout(branch)
def remote_print(self, name):
check.check_string(name)
repo = git_repo(self.options.root_dir)
url = repo.remote_get_url(name = name)
print(url or '')
return 0
def _test_many_concurrent_worker(clazz, fruit, address):
tmp_dir = clazz.make_temp_dir()
content = clazz._make_content(fruit)
repo = git_repo(tmp_dir, address=address)
repo.clone_or_pull()
repo.add_file(fruit, content=fruit, commit=True)
repo.push_with_rebase(num_tries=10, retry_wait_seconds=0.250)
file_util.remove(tmp_dir)
return 0
def test_push_conflict(self):
r1 = git_temp_repo(debug = self.DEBUG)
if host.is_windows():
script = self.native_filename('fruits/kiwi.bat')
content = '''\
@echo off
echo %1 > %1
git add %1
git commit -m"add %1" %1
exit 0
'''
elif host.is_unix():
script = self.native_filename('fruits/kiwi.sh')
content = '''\
#!/bin/bash
echo ${1} > ${1}
git add ${1}
git commit -m"add ${1}" ${1}
exit 0
'''
else:
assert False
xp_script = self.native_filename(script)
r1.add_file(self.native_filename(xp_script), content, mode = 0o0755)
r1.push('origin', 'master')
jobs = []
for fruit in self._FRUITS:
p = multiprocessing.Process(target = self._worker_test_push_conflict, args = ( fruit, r1.address, xp_script ) )
jobs.append(p)
p.start()
for job in jobs:
job.join()
r2 = git_repo(self.make_temp_dir(), address = r1.address)
r2.clone_or_pull()
self.assertEqual( {
xp_script,
'apple',
'blueberry',
'kiwi',
'lemon',
'melon',
'orange',
'papaya',
'pineapple',
'watermelon',
}, set(r2.find_all_files()) )
'''
def run(self):
args = self.parser.parse_args()
blurb.set_verbose(args.verbose)
args.python_versions = dim_python.resolve_python_versions(
args.python_versions)
args.systems = dim_system.resolve_systems(args.systems)
args.steps = dim_step.resolve_steps(args.steps)
self.logs_dir = path.join(os.getcwd(), 'BUILD', 'logs')
self.egoist = self._find_egoist()
self.temp_dir = temp_file.make_temp_dir(suffix='build')
self.repo = git_repo('.', find_root=True)
if args.print_ecr_images:
self._print_ecr_images()
return 0
self.bes_version = args.bes_version or self.repo.greatest_remote_tag()
self.blurb(' steps: {}'.format(' '.join(args.steps)))
self.blurb(' systems: {}'.format(' '.join(args.systems)))
self.blurb(' python_versions: {}'.format(' '.join(
args.python_versions)))
self.blurb(' build: {}'.format(args.build))
self.blurb(' test: {}'.format(args.test))
self.blurb(' publish_egoist: {}'.format(args.publish_egoist))
self.blurb(' publish_image: {}'.format(args.publish_image))
self.blurb(' clean: {}'.format(args.clean))
self.blurb(' very_clean: {}'.format(args.very_clean))
self.blurb('bes_version: {}'.format(self.bes_version))
if args.clean and args.very_clean:
self.blurb('Only one of --clean or --very-clean should be given.')
return 1
if args.clean:
self._clean()
return 0
if args.very_clean:
self._very_clean()
return 0
result = self._do_run(args)
if result.success:
self.blurb('SUCCESS')
return 0
for failed_entry in result.failed_entries:
self.blurb('FAILED: {} => {}'.format(
failed_entry.descriptor.docker_tag, failed_entry.log))
return 1
def _worker_test_operation_with_reset_with_multiprocess_conflict(clazz, n, address):
worker_tmp_root = clazz.make_temp_dir(suffix = 'worker-{}'.format(n))
worker_repo = git_repo(worker_tmp_root, address = address)
worker_repo.clone_or_pull()
worker_repo.checkout('master')
def _op(repo):
old_content = repo.read_file('foo.txt', codec = 'utf8')
new_content = '{}\nworker {}'.format(old_content, n)
fp = repo.file_path('foo.txt')
file_util.save(fp, content = new_content, codec = 'utf8', mode = 0o644)
worker_repo.operation_with_reset(_op, 'from worker {}'.format(n))
file_util.remove(worker_tmp_root)
def _fetch_framework(self, revision):
assert revision != 'latest'
tmp_dir = temp_file.make_temp_dir(prefix = path.basename(self.framework_dir),
dir = path.normpath(path.join(self.framework_dir, path.pardir)),
delete = False)
options = git_clone_options(depth = 1,
num_tries = 3,
retry_wait_seconds = 5,
branch = revision)
repo = git_repo(tmp_dir, address = self._options.address)
repo.clone(options = options)
file_util.remove(self.framework_dir)
src_dir = path.join(tmp_dir, 'bash', 'bes_bash_one_file')
file_util.rename(src_dir, self.framework_dir)
file_util.remove(tmp_dir)
def bump_tag(self, component, dont_push, reset_lower, prefix):
check.check_string(component, allow_none = True)
check.check_bool(dont_push)
check.check_bool(reset_lower)
check.check_string(prefix, allow_none = True)
repo = git_repo(self.options.root_dir)
old_tag = repo.greatest_local_tag(prefix = prefix)
bump_rv = repo.bump_tag(component,
push = not dont_push,
dry_run = self.options.dry_run,
reset_lower = reset_lower,
prefix = prefix)
blurb = 'old_tag={} new_tag={}'.format(bump_rv.old_tag, bump_rv.new_tag)
if self.options.dry_run:
print('dry_run: {} dont_push={}'.format(blurb, dont_push))
if self.options.verbose:
print(blurb)
return 0
def remote_replace(self, name, new_url, test):
check.check_string(name)
check.check_string(new_url)
check.check_bool(test)
repo = git_repo(self.options.root_dir)
old_url = repo.remote_get_url(name = name)
repo.remote_set_url(new_url, name = name)
revert = False
if test:
try:
repo.list_remote_tags()
except git_error as ex:
revert = True
if revert:
print('Failed to test url {}'.format(new_url))
repo.remote_set_url(old_url, name = name)
print('Reverted to {}'.format(old_url))
return 0
def tags(self, local, remote, prefix, limit, sort_type, reverse):
check.check_bool(local, allow_none = True)
check.check_bool(remote, allow_none = True)
check.check_string(prefix, allow_none = True)
check.check_int(limit, allow_none = True)
check.check_string(sort_type, allow_none = True)
check.check_bool(reverse)
r = git_repo(self.options.root_dir)
tags = r.list_tags(sort_type = sort_type, reverse = reverse, limit = limit, prefix = prefix)
# return
# where = git_ref_where.determine_where(local, remote)
# if where == 'both':
# clazz._list_tags_both(self.options)
# return 0
# if where == 'local':
# tags = git.list_local_tags(self.options.root_dir)
# else:
# tags = git.list_remote_tags(self.options.root_dir)
tags.output(self.options.output_style, output_filename = self.options.output_filename)
return 0
def test_sync(self):
config = '''\
add commit1 commit1
kiwi.txt: kiwi.txt
tag 1.0.1 tag1 @commit1
push origin master
'''
r1 = git_temp_repo(remote = True, debug = self.DEBUG)
r1.apply_config_text(config)
tmp_dir = self.make_temp_dir(suffix = '-tmp-sync-dir')
args = [
'git_repo',
'sync',
r1.address,
tmp_dir,
]
rv = self.run_program(self._program, args)
self.assertEqual(0, rv.exit_code)
r2 = git_repo(tmp_dir)
self.assertEqual( '1.0.1', r2.greatest_local_tag().name )
self.assertEqual( [
'kiwi.txt',
], r2.find_all_files() )
def test_many_concurrent(self):
'''
Create a bunch of processes trying to push to the same repo simulataneously.
This creates git locking issues and exercises the safe_push retry code.
'''
r1 = git_temp_repo(debug=self.DEBUG)
initial_content = self._make_content('coconut')
r1.add_file('coconut', initial_content)
r1.push('origin', 'master')
jobs = []
for fruit in self._FRUITS:
p = multiprocessing.Process(
target=self._test_many_concurrent_worker,
args=(self.__class__, fruit, r1.address))
jobs.append(p)
p.start()
for job in jobs:
job.join()
r2 = git_repo(self.make_temp_dir(), address=r1.address)
r2.clone_or_pull()
self.assertEqual([
'apple',
'blueberry',
'coconut',
'kiwi',
'lemon',
'melon',
'orange',
'papaya',
'pineapple',
'watermelon',
], r2.find_all_files())
def create_git(self, root_dir, prefix, revision, output_filename, archive_format):
r = git_repo(root_dir)
r.archive_to_file(prefix, revision, output_filename,
archive_format = archive_format,
short_hash = True)
return 0