def test_track_branches(): tmp_dir = mkdtemp() orig_dir = os.path.join(tmp_dir, 'orig') clone_dir = os.path.join(tmp_dir, 'clone') os.makedirs(orig_dir) os.makedirs(clone_dir) from subprocess import check_call, PIPE, check_output check_call('git init .', shell=True, cwd=orig_dir, stdout=PIPE) check_call('touch example.txt', shell=True, cwd=orig_dir, stdout=PIPE) check_call('git add *', shell=True, cwd=orig_dir, stdout=PIPE) check_call('git commit -m "Init"', shell=True, cwd=orig_dir, stdout=PIPE) check_call('git branch bloom', shell=True, cwd=orig_dir, stdout=PIPE) check_call('git branch upstream', shell=True, cwd=orig_dir, stdout=PIPE) check_call('git branch refactor', shell=True, cwd=orig_dir, stdout=PIPE) from vcstools import VcsClient clone = VcsClient('git', clone_dir) clone.checkout('file://{0}'.format(orig_dir), 'master') output = check_output('git branch --no-color', shell=True, cwd=clone_dir) assert output == '* master\n' from bloom.git import track_branches track_branches(['bloom', 'upstream'], clone_dir) output = check_output('git branch --no-color', shell=True, cwd=clone_dir) assert output == ' bloom\n* master\n upstream\n' track_branches(cwd=clone_dir) output = check_output('git branch --no-color', shell=True, cwd=clone_dir) assert output == ' bloom\n* master\n refactor\n upstream\n', \ output + ' == ` bloom\n* master\n refactor\n upstream\n`' track_branches(['fake'], clone_dir) output = check_output('git branch', shell=True, cwd=clone_dir) assert output.count('fake') == 0 rmtree(tmp_dir)
def checkout_distro_stack(distro_stack, from_url, spec): vcs_type = distro_stack.vcs_config.type tempdir = tempfile.mkdtemp() temp_repo = os.path.join(tempdir, distro_stack.name) client = VcsClient(vcs_type, temp_repo) client.checkout(from_url, spec) return temp_repo
def test_fuerte_package_repository(directory=None): """ Release a single catkin stack (fuerte) repository. """ directory = directory if directory is not None else os.getcwd() # Setup upstream_url = create_upstream_catkin_fuerte_repository('foo', directory) release_url = create_release_repo(upstream_url, 'git', 'fuerte_devel') release_dir = os.path.join(directory, 'foo_release_clone') release_client = VcsClient('git', release_dir) release_client.checkout(release_url) with change_directory(release_dir): ### ### Import upstream ### user('git-bloom-import-upstream --quiet') # does the upstream branch exist? assert branch_exists('upstream', local_only=True), "no upstream branch" # does the upstrea/0.1.0 tag exist? ret, out, err = user('git tag', return_io=True) assert out.count('upstream/0.1.0') == 1, "no upstream tag created" # Is the package.xml from upstream in the upstream branch now? with inbranch('upstream'): assert os.path.exists('stack.xml'), \ "upstream did not import: '" + os.getcwd() + "': " + \ str(os.listdir(os.getcwd())) assert open('stack.xml').read().count('0.1.0'), "not right file" ### ### Release generator ### with bloom_answer(bloom_answer.ASSERT_NO_QUESTION): ret = user('git-bloom-generate -y release -s upstream --quiet') # patch import should have reported OK assert ret == code.OK, "actually returned ({0})".format(ret) # do the proper branches exist? assert branch_exists('release/foo'), "no release/foo branch: " + \ str(get_branches()) assert branch_exists('patches/release/foo'), \ "no patches/release/foo branch" # was the release tag created? ret, out, err = user('git tag', return_io=True) assert out.count('release/foo/0.1.0') == 1, "no release tag created" ### ### Release generator, again ### with bloom_answer(bloom_answer.ASSERT_NO_QUESTION): ret = user('git-bloom-generate -y release -s upstream --quiet') # patch import should have reported OK assert ret == code.OK, "actually returned ({0})".format(ret) # do the proper branches exist? assert branch_exists('release/foo'), "no release/foo branch: " + \ str(get_branches()) assert branch_exists('patches/release/foo'), \ "no patches/release/foo branch" # was the release tag created? ret, out, err = user('git tag', return_io=True) assert out.count('release/foo/0.1.0') == 1, "no release tag created"
def auto_upstream_checkout(upstream_repo, upstream_url, devel_branch): info("Searching in upstream development branch for the name and version") info(" Upstream url: " + upstream_url) info(" Upstream type: " + upstream_repo.get_vcs_type_name()) if devel_branch: info(" Upstream branch: " + str(devel_branch)) # Handle special svn cases if upstream_repo.get_vcs_type_name() == 'svn': if devel_branch == '': upstream_url += '/trunk' else: upstream_url += '/branches/' + str(devel_branch) devel_branch = '' # Checkout to the upstream development branch retcode = try_vcstools_checkout(upstream_repo, upstream_url, devel_branch) if retcode != 0: return retcode # Look into the upstream devel branch for the version meta = get_upstream_meta(upstream_repo.get_path()) if meta is None or None in meta.values(): error("Failed to get the upstream meta data.") return 1 # Summarize the package.xml/stack.xml contents info("Found upstream with version: " + ansi('boldon') + meta['version'] + \ ansi('reset')) if meta['type'] == 'stack.xml': info("Upstream contains a stack called: " + ansi('boldon') + \ meta['name'][0] + ansi('reset')) else: info("Upstream contains package" + \ ('s: ' if len(meta['name']) > 1 else ': ') + ansi('boldon') + \ ', '.join(meta['name']) + ansi('reset')) # If svn recreate upstream_repo and checkout to the tag if upstream_repo.get_vcs_type_name() == 'svn': # Remove the /trunk from the url upstream_url = '/'.join(upstream_url.split('/')[:-1]) upstream_dir = upstream_repo.get_path() shutil.rmtree(upstream_dir) # Delete old upstream upstream_repo = VcsClient('svn', upstream_dir) checkout_url = upstream_url + '/tags/' + meta['version'] if not upstream_repo.checkout(checkout_url): got_it = False for name in meta['name']: warning("Didn't find the tagged version at " + checkout_url) checkout_url = upstream_url + '/tags/' + name + \ '-' + meta['version'] warning("Trying " + checkout_url) if upstream_repo.checkout(checkout_url): got_it = True break if not got_it: error("Could not checkout upstream version") return 1 # Return the meta data return meta
def main(sysargs=None): # Parse the commandline arguments parser = get_argument_parser() parser = add_global_arguments(parser) args = parser.parse_args(sysargs) handle_global_arguments(args) # Ensure we are in a git repository if execute_command('git status') != 0: parser.print_help() bailout("This is not a valid git repository.") # Track all the branches track_branches() if execute_command('git show-ref refs/heads/bloom') != 0: bailout("This does not appear to be a bloom release repo. " "Please initialize it first using:\n\n" " git bloom-set-upstream <UPSTREAM_VCS_URL> <VCS_TYPE> " "[<VCS_BRANCH>]") current_branch = get_current_branch() bloom_repo = VcsClient('git', os.getcwd()) result = 0 try: # update rosdep is needed if args.do_not_update_rosdep: info("Updating rosdep") rosdep2.catkin_support.update_rosdep() # do it result = execute_bloom_generate_debian(args, bloom_repo) finally: if current_branch: execute_command('git checkout ' + current_branch) return result
def test_get_current_branch(): # Create a temporary workfolder tmp_dir = mkdtemp() from subprocess import check_call, PIPE # Create a test repo check_call('git init .', shell=True, cwd=tmp_dir, stdout=PIPE) from bloom.git import get_current_branch assert get_current_branch(tmp_dir) == None, \ get_current_branch(tmp_dir) + ' == None' # Make a commit check_call('touch example.txt', shell=True, cwd=tmp_dir, stdout=PIPE) check_call('git add *', shell=True, cwd=tmp_dir, stdout=PIPE) check_call('git commit -a -m "Initial commit."', shell=True, cwd=tmp_dir, stdout=PIPE) # Make a branch check_call('git branch bloom', shell=True, cwd=tmp_dir, stdout=PIPE) assert get_current_branch(tmp_dir) == 'master' # Change to the bloom branch check_call('git checkout bloom', shell=True, cwd=tmp_dir, stdout=PIPE, stderr=PIPE) assert get_current_branch(tmp_dir) == 'bloom' from vcstools import VcsClient client = VcsClient('git', tmp_dir) spec = client.get_version('master') check_call('git checkout {0}'.format(spec), shell=True, cwd=tmp_dir, stdout=PIPE, stderr=PIPE) assert get_current_branch(tmp_dir) == None, \ get_current_branch(tmp_dir) + ' == None' rmtree(tmp_dir)
def test_set_upstream(self): # Initialize the git repo check_call("git init", shell=True, cwd=self.git_repo, stdout=PIPE) # Run the program and ok the initial commit option cmd = 'git-bloom-set-upstream https://github.com/ros/example.git git' p = Popen(cmd, shell=True, cwd=self.git_repo, stdin=PIPE, stdout=PIPE) p.communicate('y') assert p.returncode == 0 # Ensure the proper branch was created by checking out to it client = VcsClient('git', self.git_repo) client.update('bloom') # Ensure the bloom.conf file exists and that it is correct bloom_conf_path = os.path.join(self.git_repo, 'bloom.conf') assert os.path.exists(bloom_conf_path) expected_contents = '[bloom]\n\tupstream = https://github.' \ 'com/ros/example.git\n\tupstreamtype = git' \ '\n\tupstreambranch = \n' assert expected_contents == open(bloom_conf_path, 'r').read(), \ open(bloom_conf_path, 'r').read()
def import_upstream(cwd, tmp_dir, args): # Ensure the bloom and upstream branches are tracked locally track_branches(['bloom', 'upstream']) # Create a clone of the bloom_repo to help isolate the activity bloom_repo_clone_dir = os.path.join(tmp_dir, 'bloom_clone') os.makedirs(bloom_repo_clone_dir) os.chdir(bloom_repo_clone_dir) bloom_repo = VcsClient('git', bloom_repo_clone_dir) bloom_repo.checkout('file://{0}'.format(cwd)) # Ensure the bloom and upstream branches are tracked from the original track_branches(['bloom', 'upstream']) # Check for a bloom branch check_for_bloom(os.getcwd()) # Parse the bloom config file upstream_repo, upstream_type, upstream_branch = parse_bloom_conf() # Summarize the config contents summarize_repo_info(upstream_repo, upstream_type, upstream_branch) # If the upstream repo is git, then assert some things about the repo if upstream_type == 'git': info("Verifying a couple of things about the upstream git repo...") # Ensure the upstream repo is not setup as a gbp assert_is_not_gbp_repo(upstream_repo) # Checkout upstream upstream_dir = os.path.join(tmp_dir, 'upstream') upstream_client = VcsClient(upstream_type, upstream_dir) if args.upstream_branch != None: ver = args.upstream_branch warning("Overriding the bloom.conf branch with {0}".format(ver)) else: ver = upstream_branch if upstream_branch != '(No branch set)' else '' checkout_url = upstream_repo checkout_ver = ver # Handle svn if upstream_type == 'svn': if ver == '': checkout_url = upstream_repo + '/trunk' else: checkout_url = upstream_repo + '/branches/' + ver checkout_ver = '' debug("Checking out from url {0}".format(checkout_url)) else: debug("Checking out branch " "({0}) from url {1}".format(checkout_ver, checkout_url)) # XXX TODO: Need to validate if ver is valid for the upstream repo... # see: https://github.com/vcstools/vcstools/issues/4 if not upstream_client.checkout(checkout_url, checkout_ver): if upstream_type == 'svn': error("Could not checkout upstream repostiory " "({0})".format(checkout_url)) else: error("Could not checkout upstream repostiory " "({0})".format(checkout_url) + " to branch ({0})".format(ver)) return 1 # Get upstream meta data meta = get_upstream_meta(upstream_dir) if meta is None or None in meta.values(): print(meta) bailout("Failed to get the upstream meta data.") # Summarize the stack.xml contents info("Upstream has version " + ansi('boldon') + meta['version'] + ansi('reset')) if meta['type'] == 'stack.xml': info("Upstream contains a stack called " + ansi('boldon') + meta['name'][0] + ansi('reset')) else: info("Upstream contains package" \ + ('s: ' if len(meta['name']) > 1 else ': ') \ + ', '.join(meta['name'])) # For convenience name = meta['name'][0] if type(meta['name']) == list else meta['name'] version = meta['version'] # Export the repository to a tar ball tarball_prefix = 'upstream-' + str(version) info('Exporting version {0}'.format(version)) tarball_path = os.path.join(tmp_dir, tarball_prefix) # Change upstream_client for svn export_version = version if upstream_type == 'svn': upstream_client = VcsClient('svn', os.path.join(tmp_dir, 'svn_tag')) checkout_url = upstream_repo + '/tags/' + version if not upstream_client.checkout(checkout_url): warning("Didn't find the tagged version at " + checkout_url) checkout_url = upstream_repo + '/tags/' + name + '-' + version warning("Trying " + checkout_url) if not upstream_client.checkout(checkout_url): error("Could not checkout upstream version") return 1 export_version = '' if not upstream_client.export_repository(export_version, tarball_path): error("Failed to export upstream repository.") return 1 # Get the gbp version elements from either the last tag or the default last_tag = get_last_tag_by_date() if last_tag == '': gbp_major, gbp_minor, gbp_patch = segment_version(version) else: gbp_major, gbp_minor, gbp_patch = \ get_versions_from_upstream_tag(last_tag) info("The latest upstream tag in the release repository is " + ansi('boldon') + last_tag + ansi('reset')) # Ensure the new version is greater than the last tag full_version_strict = StrictVersion(version) last_tag_version = '.'.join([gbp_major, gbp_minor, gbp_patch]) last_tag_version_strict = StrictVersion(last_tag_version) if full_version_strict < last_tag_version_strict: warning("""\ Version discrepancy: The upstream version, {0}, should be greater than the previous \ release version, {1}. Upstream should re-release or you should fix the release repository.\ """.format(version, last_tag_version)) if full_version_strict == last_tag_version_strict: if args.replace: # Remove the conflicting tag first warning("""\ Version discrepancy: The upstream version, {0}, is equal to a previous import version. \ Removing conflicting tag before continuing because the '--replace' \ options was specified.\ """.format(version)) execute_command('git tag -d {0}'.format(last_tag)) execute_command('git push origin :refs/tags/' '{0}'.format(last_tag)) else: warning("""\ Version discrepancy: The upstream version, {0}, is equal to a previous import version. \ git-buildpackage will fail, if you want to replace the existing \ upstream import use the '--replace' option.\ """.format(version)) # Look for upstream branch output = check_output('git branch', shell=True) if output.count('upstream') == 0: info(ansi('boldon') + "No upstream branch" + ansi('reset') \ + "... creating an initial upstream branch.") create_initial_upstream_branch() # Go to the master branch bloom_repo.update('master') # Detect if git-import-orig is installed if not detect_git_import_orig(): bailout("git-import-orig not detected, did you install " "git-buildpackage?") # Import the tarball cmd = 'git import-orig {0}'.format(tarball_path + '.tar.gz') if not args.interactive: cmd += ' --no-interactive' if not args.merge: cmd += ' --no-merge' try: if check_call(cmd, shell=True) != 0: bailout("git-import-orig failed '{0}'".format(cmd)) except CalledProcessError: bailout("git-import-orig failed '{0}'".format(cmd)) # Push changes back to the original bloom repo execute_command('git push --all -f') execute_command('git push --tags')
def import_upstream(cwd, tmp_dir, args): # Ensure the bloom and upstream branches are tracked locally track_branches(['bloom', 'upstream']) # Create a clone of the bloom_repo to help isolate the activity bloom_repo_clone_dir = os.path.join(tmp_dir, 'bloom_clone') os.makedirs(bloom_repo_clone_dir) os.chdir(bloom_repo_clone_dir) bloom_repo = VcsClient('git', bloom_repo_clone_dir) bloom_repo.checkout('file://{0}'.format(cwd)) # Ensure the bloom and upstream branches are tracked from the original track_branches(['bloom', 'upstream']) # Check for a bloom branch check_for_bloom(os.getcwd()) # Parse the bloom config file upstream_repo, upstream_type, upstream_branch = parse_bloom_conf() # Summarize the config contents summarize_repo_info(upstream_repo, upstream_type, upstream_branch) # If the upstream repo is git, then assert some things about the repo if upstream_type == 'git': info("Verifying a couple of things about the upstream git repo...") # Ensure the upstream repo is not setup as a gbp assert_is_not_gbp_repo(upstream_repo) # Checkout upstream upstream_dir = os.path.join(tmp_dir, 'upstream') upstream_client = VcsClient(upstream_type, upstream_dir) if args.upstream_branch != None: ver = args.upstream_branch warning("Overriding the bloom.conf branch with {0}".format(ver)) else: ver = upstream_branch if upstream_branch != '(No branch set)' else '' checkout_url = upstream_repo checkout_ver = ver # Handle svn if upstream_type == 'svn': if ver == '': checkout_url = upstream_repo + '/trunk' else: checkout_url = upstream_repo + '/branches/' + ver checkout_ver = '' debug("Checking out from url {0}".format(checkout_url)) else: debug("Checking out branch " "({0}) from url {1}".format(checkout_ver, checkout_url)) # XXX TODO: Need to validate if ver is valid for the upstream repo... # see: https://github.com/vcstools/vcstools/issues/4 if not upstream_client.checkout(checkout_url, checkout_ver): if upstream_type == 'svn': error( "Could not checkout upstream repostiory " "({0})".format(checkout_url) ) else: error( "Could not checkout upstream repostiory " "({0})".format(checkout_url) + " to branch ({0})".format(ver) ) return 1 # Get upstream meta data meta = get_upstream_meta(upstream_dir) if meta is None or None in meta.values(): print(meta) bailout("Failed to get the upstream meta data.") # Summarize the stack.xml contents info("Upstream has version " + ansi('boldon') + meta['version'] + ansi('reset')) if meta['type'] == 'stack.xml': info("Upstream contains a stack called " + ansi('boldon') + meta['name'][0] + ansi('reset')) else: info("Upstream contains package" \ + ('s: ' if len(meta['name']) > 1 else ': ') \ + ', '.join(meta['name'])) # For convenience name = meta['name'][0] if type(meta['name']) == list else meta['name'] version = meta['version'] # Export the repository to a tar ball tarball_prefix = 'upstream-' + str(version) info('Exporting version {0}'.format(version)) tarball_path = os.path.join(tmp_dir, tarball_prefix) # Change upstream_client for svn export_version = version if upstream_type == 'svn': upstream_client = VcsClient('svn', os.path.join(tmp_dir, 'svn_tag')) checkout_url = upstream_repo + '/tags/' + version if not upstream_client.checkout(checkout_url): warning("Didn't find the tagged version at " + checkout_url) checkout_url = upstream_repo + '/tags/' + name + '-' + version warning("Trying " + checkout_url) if not upstream_client.checkout(checkout_url): error("Could not checkout upstream version") return 1 export_version = '' if not upstream_client.export_repository(export_version, tarball_path): error("Failed to export upstream repository.") return 1 # Get the gbp version elements from either the last tag or the default last_tag = get_last_tag_by_date() if last_tag == '': gbp_major, gbp_minor, gbp_patch = segment_version(version) else: gbp_major, gbp_minor, gbp_patch = \ get_versions_from_upstream_tag(last_tag) info("The latest upstream tag in the release repository is " + ansi('boldon') + last_tag + ansi('reset')) # Ensure the new version is greater than the last tag full_version_strict = StrictVersion(version) last_tag_version = '.'.join([gbp_major, gbp_minor, gbp_patch]) last_tag_version_strict = StrictVersion(last_tag_version) if full_version_strict < last_tag_version_strict: warning("""\ Version discrepancy: The upstream version, {0}, should be greater than the previous \ release version, {1}. Upstream should re-release or you should fix the release repository.\ """.format(version, last_tag_version)) if full_version_strict == last_tag_version_strict: if args.replace: # Remove the conflicting tag first warning("""\ Version discrepancy: The upstream version, {0}, is equal to a previous import version. \ Removing conflicting tag before continuing because the '--replace' \ options was specified.\ """.format(version)) execute_command('git tag -d {0}'.format(last_tag)) execute_command('git push origin :refs/tags/' '{0}'.format(last_tag)) else: warning("""\ Version discrepancy: The upstream version, {0}, is equal to a previous import version. \ git-buildpackage will fail, if you want to replace the existing \ upstream import use the '--replace' option.\ """.format(version)) # Look for upstream branch output = check_output('git branch', shell=True) if output.count('upstream') == 0: info(ansi('boldon') + "No upstream branch" + ansi('reset') \ + "... creating an initial upstream branch.") create_initial_upstream_branch() # Go to the master branch bloom_repo.update('master') # Detect if git-import-orig is installed if not detect_git_import_orig(): bailout("git-import-orig not detected, did you install " "git-buildpackage?") # Import the tarball cmd = 'git import-orig {0}'.format(tarball_path + '.tar.gz') if not args.interactive: cmd += ' --no-interactive' if not args.merge: cmd += ' --no-merge' try: if check_call(cmd, shell=True) != 0: bailout("git-import-orig failed '{0}'".format(cmd)) except CalledProcessError: bailout("git-import-orig failed '{0}'".format(cmd)) # Push changes back to the original bloom repo execute_command('git push --all -f') execute_command('git push --tags')
def import_upstream(cwd, tmp_dir, args): # Ensure the bloom and upstream branches are tracked locally track_branches(['bloom', 'upstream']) # Create a clone of the bloom_repo to help isolate the activity bloom_repo_clone_dir = os.path.join(tmp_dir, 'bloom_clone') os.makedirs(bloom_repo_clone_dir) os.chdir(bloom_repo_clone_dir) bloom_repo = VcsClient('git', bloom_repo_clone_dir) bloom_repo.checkout('file://{0}'.format(cwd)) # Ensure the bloom and upstream branches are tracked from the original track_branches(['bloom', 'upstream']) ### Fetch the upstream tag upstream_repo = None upstream_repo_dir = os.path.join(tmp_dir, 'upstream_repo') # If explicit svn url just export and git-import-orig if args.explicit_svn_url is not None: if args.upstream_version is None: error("'--explicit-svn-version' must be specified with " "'--explicit-svn-url'") return 1 info("Checking out upstream at version " + ansi('boldon') + \ str(args.upstream_version) + ansi('reset') + \ " from repository at " + ansi('boldon') + \ str(args.explicit_svn_url) + ansi('reset')) upstream_repo = VcsClient('svn', upstream_repo_dir) retcode = try_vcstools_checkout(upstream_repo, args.explicit_svn_url) if retcode != 0: return retcode meta = { 'name': None, 'version': args.upstream_version, 'type': 'manual' } # Else fetching from bloom configs else: # Check for a bloom branch check_for_bloom() # Parse the bloom config file upstream_url, upstream_type, upstream_branch = parse_bloom_conf() # If the upstream_tag is specified, don't search just fetch upstream_repo = VcsClient(upstream_type, upstream_repo_dir) if args.upstream_tag is not None: warning("Using specified upstream tag '" + args.upstream_tag + "'") if upstream_type == 'svn': upstream_url += '/tags/' + args.upstream_tag upstream_tag = '' else: upstream_tag = args.upstream_tag retcode = try_vcstools_checkout(upstream_repo, upstream_url, upstream_tag) if retcode != 0: return retcode meta = { 'name': None, 'version': args.upstream_tag, 'type': 'manual' } # We have to search for the upstream tag else: if args.upstream_devel is not None: warning("Overriding the bloom.conf upstream branch with " + \ args.upstream_devel) devel_branch = args.upstream_devel else: devel_branch = upstream_branch meta = auto_upstream_checkout(upstream_repo, upstream_url, devel_branch) if type(meta) not in [dict] and meta != 0: return meta ### Export the repository version = args.upstream_version if args.upstream_version is not None \ else meta['version'] # Export the repository to a tar ball tarball_prefix = 'upstream-' + str(version) info('Exporting version {0}'.format(version)) tarball_path = os.path.join(tmp_dir, tarball_prefix) if upstream_repo.get_vcs_type_name() == 'svn': upstream_repo.export_repository('', tarball_path) else: if args.upstream_tag is not None: upstream_repo.export_repository(args.upstream_tag, tarball_path) else: upstream_repo.export_repository(version, tarball_path) # Get the gbp version elements from either the last tag or the default last_tag = get_last_tag_by_date() if last_tag == '': gbp_major, gbp_minor, gbp_patch = segment_version(version) else: gbp_major, gbp_minor, gbp_patch = \ get_versions_from_upstream_tag(last_tag) info("The latest upstream tag in the release repository is " + ansi('boldon') + last_tag + ansi('reset')) # Ensure the new version is greater than the last tag last_tag_version = '.'.join([gbp_major, gbp_minor, gbp_patch]) if parse_version(version) < parse_version(last_tag_version): warning("""\ Version discrepancy: The upstream version, {0}, is not newer than the previous \ release version, {1}. """.format(version, last_tag_version)) if parse_version(version) <= parse_version(last_tag_version): if args.replace: if not gbp.has_replace(): error("The '--replace' flag is not supported on this " "version of git-buildpackage.") return 1 # Remove the conflicting tag first warning("""\ The upstream version, {0}, is equal to or less than a previous \ import version. Removing conflicting tag before continuing \ because the '--replace' options was specified.\ """.format(version)) execute_command('git tag -d {0}'.format('upstream/' + version)) execute_command('git push origin :refs/tags/' '{0}'.format('upstream/' + version)) else: warning("""\ The upstream version, {0}, is equal to a previous import version. \ git-buildpackage will fail, if you want to replace the existing \ upstream import use the '--replace' option.\ """.format(version)) # Look for upstream branch if not branch_exists('upstream', local_only=True): create_branch('upstream', orphaned=True, changeto=True) # Go to the bloom branch during import bloom_repo.update('bloom') # Detect if git-import-orig is installed tarball_path += '.tar.gz' if gbp.import_orig(tarball_path, args.interactive) != 0: return 1 # Push changes back to the original bloom repo execute_command('git push --all -f') execute_command('git push --tags')
def test_multi_package_repository(directory=None): """ Release a multi package catkin (groovy) repository. """ directory = directory if directory is not None else os.getcwd() # Setup pkgs = ['foo', 'bar', 'baz'] upstream_url = create_upstream_catkin_groovy_repository(pkgs, directory) release_url = create_release_repo(upstream_url, 'git', 'groovy_devel') release_dir = os.path.join(directory, 'foo_release_clone') release_client = VcsClient('git', release_dir) release_client.checkout(release_url) with change_directory(release_dir): ### ### Import upstream ### user('git-bloom-import-upstream --quiet') # does the upstream branch exist? assert branch_exists('upstream', local_only=True), "no upstream branch" # does the upstrea/0.1.0 tag exist? ret, out, err = user('git tag', return_io=True) assert out.count('upstream/0.1.0') == 1, "no upstream tag created" # Is the package.xml from upstream in the upstream branch now? with inbranch('upstream'): for pkg in pkgs: with change_directory(pkg): assert os.path.exists('package.xml'), \ "upstream did not import: " + os.listdir() assert open('package.xml').read().count('0.1.0'), \ "not right file" ### ### Release generator ### with bloom_answer(bloom_answer.ASSERT_NO_QUESTION): ret = user('git-bloom-generate -y release -s upstream --quiet') # patch import should have reported OK assert ret == code.OK, "actually returned ({0})".format(ret) # Check the environment after the release generator ret, out, err = user('git tag', return_io=True) for pkg in pkgs: # Does the release/pkg branch exist? assert branch_exists('release/' + pkg), \ "no release/" + pkg + " branch" # Does the patches/release/pkg branch exist? assert branch_exists('patches/release/' + pkg), \ "no patches/release/" + pkg + " branch" # Did the release tag get created? assert out.count('release/' + pkg + '/0.1.0') == 1, \ "no release tag created for " + pkg # Is there a package.xml in the top level? with inbranch('release/' + pkg): assert os.path.exists('package.xml'), "release branch invalid" # Is it the correct package.xml for this pkg? package_xml = open('package.xml', 'r').read() assert package_xml.count('<name>' + pkg + '</name>'), \ "incorrect package.xml for " + str(pkg) # Make a patch with inbranch('release/' + pkgs[0]): user('echo "This is a change" >> README.md') user('git add README.md') user('git commit -m "added a readme"') ### ### Release generator, again ### with bloom_answer(bloom_answer.ASSERT_NO_QUESTION): ret = user('git-bloom-generate -y release -s upstream --quiet') # patch import should have reported OK assert ret == code.OK, "actually returned ({0})".format(ret) # Check the environment after the release generator ret, out, err = user('git tag', return_io=True) for pkg in pkgs: # Does the release/pkg branch exist? assert branch_exists('release/' + pkg), \ "no release/" + pkg + " branch" # Does the patches/release/pkg branch exist? assert branch_exists('patches/release/' + pkg), \ "no patches/release/" + pkg + " branch" # Did the release tag get created? assert out.count('release/' + pkg + '/0.1.0') == 1, \ "no release tag created for " + pkg # Is there a package.xml in the top level? with inbranch('release/' + pkg): assert os.path.exists('package.xml'), "release branch invalid" # Is it the correct package.xml for this pkg? package_xml = open('package.xml', 'r').read() assert package_xml.count('<name>' + pkg + '</name>'), \ "incorrect package.xml for " + str(pkg) ### ### ROSDebian Generator ### with bloom_answer(bloom_answer.ASSERT_NO_QUESTION): ret, out, err = user('git-bloom-generate -y rosdebian ' '-p release groovy --quiet', return_io=True) expected = "Debian Distributions: ['oneiric', 'precise', 'quantal']" assert out.count(expected) > 0, "not using expected ubuntu distros" # generator should have reported OK assert ret == code.OK, "actually returned ({0})".format(ret) # Check the environment after the release generator ret, out, err = user('git tag', return_io=True) for pkg in pkgs: for distro in ['oneiric', 'precise', 'quantal']: # Does the debian/distro/pkg branch exist? assert branch_exists('debian/groovy/' + distro + '/' + pkg), \ "no release/" + pkg + " branch" # Does the patches/debian/distro/pkg branch exist? patches_branch = 'patches/debian/groovy/' + distro + '/' + pkg assert branch_exists(patches_branch), \ "no patches/release/" + pkg + " branch" # Did the debian tag get created? tag = 'debian/ros-groovy-' + pkg + '_0.1.0-0_' + distro assert out.count(tag) == 1, \ "no release tag created for '" + pkg + "': `" + out + "`" # Is there a package.xml in the top level? with inbranch('debian/groovy/' + distro + '/' + pkg): assert os.path.exists('package.xml'), "release branch invalid" # Is it the correct package.xml for this pkg? package_xml = open('package.xml', 'r').read() assert package_xml.count('<name>' + pkg + '</name>'), \ "incorrect package.xml for " + str(pkg)