def main(sysargs=None):
if len(sysargs if sysargs is not None else sys.argv[1:]) == 0:
# This means show me the current config, first check we have an env
ensure_clean_working_env()
if not branch_exists(BLOOM_CONFIG_BRANCH):
sys.exit("No {0} branch found".format(BLOOM_CONFIG_BRANCH))
show_current()
info("See: 'git-bloom-config -h' on how to change the configs")
return 0
parser = get_argument_parser()
add_global_arguments(parser)
args = parser.parse_args(sysargs)
handle_global_arguments(args)
# Also check to see if git has been init'ed
check_git_init()
# Check that the current directory is a serviceable git/bloom repo
try:
ensure_clean_working_env()
ensure_git_root()
except SystemExit:
parser.print_usage()
raise
# Then call the verb
try:
args.func(args)
except (KeyboardInterrupt, EOFError):
error("\nUser sent a Keyboard Interrupt, aborting.", exit=True)
def main(sysargs=None):
parser = get_parser()
parser = add_global_arguments(parser)
# List the generators
generator_names = list_generators()
# Create the generators
generators = create_generators(generator_names)
# Setup a subparser for each generator
create_subparsers(parser, generators.values())
args = parser.parse_args(sysargs)
handle_global_arguments(args)
generator = generators[args.generator]
# Check that the current directory is a serviceable git/bloom repo
try:
ensure_clean_working_env()
ensure_git_root()
except SystemExit:
parser.print_usage()
raise
# Run the generator that was selected in a clone
# The clone protects the release repo state from mid change errors
with log_prefix('[git-bloom-generate {0}]: '.format(generator.title)):
git_clone = GitClone()
with git_clone:
run_generator(generator, args)
git_clone.commit()
def main(sysargs=None):
parser = get_argument_parser()
parser = add_global_arguments(parser)
args = parser.parse_args(sysargs)
handle_global_arguments(args)
# Check that the current directory is a serviceable git/bloom repo
try:
ensure_clean_working_env()
ensure_git_root()
except SystemExit:
parser.print_usage()
raise
git_clone = GitClone()
with git_clone:
import_upstream(
args.archive_path,
args.patches_path,
args.release_version,
args.name,
args.replace)
git_clone.commit()
info("I'm happy. You should be too.")
def rebase_patches(without_git_rebase=True, directory=None):
### Ensure a clean/valid working environment
ensure_clean_working_env(git_status=True, directory=directory)
### Make sure we need to actually call this
# Get the current branch
current_branch = get_current_branch(directory)
if current_branch is None:
error("Could not determine current branch.", exit=True)
# Get the patches branch
patches_branch = 'patches/' + current_branch
# Get the current patches.conf
config = get_patch_config(patches_branch, directory=directory)
### Execute the rebase
if without_git_rebase:
non_git_rebase(config['parent'], directory=directory)
else:
git_rebase(config['parent'], directory=directory)
### Update the patches information
# Get the latest configs
config = get_patch_config(patches_branch, directory)
# Set the base to the current hash (before patches)
current_branch_ = get_current_branch(directory)
debug('Current branch: ' + current_branch_ or 'could not determine branch')
config['base'] = get_commit_hash(current_branch_, directory)
debug('New current commit hash after rebase: ' + config['base'])
# Set the new upstream hash to the previous upstream hash
config['previous'] = get_commit_hash(config['parent'], directory)
debug('New parent commit hash after rebase: ' + config['previous'])
# Clear the trimbase (it needs to be reapplied)
config['trimbase'] = ''
# Write the new configs
set_patch_config(patches_branch, config, directory)
def main(sysargs=None):
if len(sysargs if sysargs is not None else sys.argv[1:]) == 0:
# This means show me the current config, first check we have an env
ensure_clean_working_env()
if not branch_exists('bloom'):
sys.exit("No bloom branch found")
show_current()
info("See: 'git-bloom-config -h' on how to change the configs")
return 0
parser = get_argument_parser()
add_global_arguments(parser)
args = parser.parse_args(sysargs)
handle_global_arguments(args)
# Also check to see if git has been init'ed
check_git_init()
# Check that the current directory is a serviceable git/bloom repo
try:
ensure_clean_working_env()
ensure_git_root()
except SystemExit:
parser.print_usage()
raise
# Then call the verb
try:
args.func(args)
except (KeyboardInterrupt, EOFError):
error("\nUser sent a Keyboard Interrupt, aborting.", exit=True)
def main(sysargs=None):
# Check that the current directory is a serviceable git/bloom repo
ensure_clean_working_env()
ensure_git_root()
# Get tracks
tracks_dict = get_tracks_dict_raw()
if not tracks_dict['tracks']:
error("No tracks configured, first create a track with "
"'git-bloom-config new <track_name>'", exit=True)
# Do argparse stuff
parser = get_argument_parser([str(t) for t in tracks_dict['tracks']])
parser = add_global_arguments(parser)
args = parser.parse_args(sysargs)
handle_global_arguments(args)
verify_track(args.track, tracks_dict['tracks'][args.track])
execute_track(args.track, tracks_dict['tracks'][args.track],
args.release_increment, args.pretend, args.debug, args.unsafe)
# Notify the user of success and next action suggestions
print('\n\n')
warning("Tip: Check to ensure that the debian tags created have the same "
"version as the upstream version you are releasing.")
info(fmt("@{gf}@!Everything went as expected, "
"you should check that the new tags match your expectations, and "
"then push to the release repo with:@|"))
info(fmt(" git push --all && git push --tags "
"@{kf}@!# You might have to add --force to the second command if you "
"are over-writing existing flags"))
def main(sysargs=None):
parser = get_parser()
parser = add_global_arguments(parser)
# List the generators
generator_names = list_generators()
# Create the generators
generators = create_generators(generator_names)
# Setup a subparser for each generator
create_subparsers(parser, generators.values())
args = parser.parse_args(sysargs)
handle_global_arguments(args)
generator = generators[args.generator]
# Check that the current directory is a serviceable git/bloom repo
try:
ensure_clean_working_env()
ensure_git_root()
except SystemExit:
parser.print_usage()
raise
# Run the generator that was selected in a clone
# The clone protects the release repo state from mid change errors
with log_prefix('[git-bloom-generate {0}]: '.format(generator.title)):
git_clone = GitClone()
with git_clone:
run_generator(generator, args)
git_clone.commit()
def rebase_patches(without_git_rebase=True, directory=None):
### Ensure a clean/valid working environment
ensure_clean_working_env(git_status=True, directory=directory)
### Make sure we need to actually call this
# Get the current branch
current_branch = get_current_branch(directory)
if current_branch is None:
error("Could not determine current branch.", exit=True)
# Get the patches branch
patches_branch = 'patches/' + current_branch
# Get the current patches.conf
config = get_patch_config(patches_branch, directory=directory)
### Execute the rebase
if without_git_rebase:
non_git_rebase(config['parent'], directory=directory)
else:
git_rebase(config['parent'], directory=directory)
### Update the patches information
# Get the latest configs
config = get_patch_config(patches_branch, directory)
# Set the base to the current hash (before patches)
current_branch_ = get_current_branch(directory)
debug('Current branch: ' + current_branch_ or 'could not determine branch')
config['base'] = get_commit_hash(current_branch_, directory)
debug('New current commit hash after rebase: ' + config['base'])
# Set the new upstream hash to the previous upstream hash
config['previous'] = get_commit_hash(config['parent'], directory)
debug('New parent commit hash after rebase: ' + config['previous'])
# Clear the trimbase (it needs to be reapplied)
config['trimbase'] = ''
# Write the new configs
set_patch_config(patches_branch, config, directory)
def main(sysargs=None):
from bloom.config import upconvert_bloom_to_config_branch
upconvert_bloom_to_config_branch()
# Check that the current directory is a serviceable git/bloom repo
ensure_clean_working_env()
ensure_git_root()
# Get tracks
tracks_dict = get_tracks_dict_raw()
if not tracks_dict['tracks']:
error(
"No tracks configured, first create a track with "
"'git-bloom-config new <track_name>'",
exit=True)
# Do argparse stuff
parser = get_argument_parser([str(t) for t in tracks_dict['tracks']])
parser = add_global_arguments(parser)
args = parser.parse_args(sysargs)
handle_global_arguments(args)
os.environ['BLOOM_TRACK'] = args.track
verify_track(args.track, tracks_dict['tracks'][args.track])
git_clone = GitClone()
with git_clone:
quiet_git_clone_warning(True)
disable_git_clone(True)
execute_track(args.track,
tracks_dict['tracks'][args.track],
args.release_increment,
args.pretend,
args.debug,
args.unsafe,
interactive=args.interactive)
disable_git_clone(False)
quiet_git_clone_warning(False)
git_clone.commit()
# Notify the user of success and next action suggestions
info('\n\n', use_prefix=False)
warning("Tip: Check to ensure that the debian tags created have the same "
"version as the upstream version you are releasing.")
info(
fmt("@{gf}@!Everything went as expected, "
"you should check that the new tags match your expectations, and "
"then push to the release repo with:@|"))
info(
fmt(" git push --all && git push --tags "
"@{kf}@!# You might have to add --force to the second command if you "
"are over-writing existing tags"))
def main(sysargs=None):
if len(sysargs if sysargs is not None else sys.argv) == 1:
retcode = ensure_clean_working_env()
if retcode != 0:
return retcode
if branch_exists('bloom', False):
show_current()
info("See: 'git-bloom-config -h' on how to change the configs")
return 0
else:
info("No bloom branch found")
parser = get_argument_parser()
parser = add_global_arguments(parser)
args = parser.parse_args(sysargs)
handle_global_arguments(args)
# Check for freshly initialized repo
ret = check_git_init()
if ret != 0:
return ret
retcode = ensure_clean_working_env()
if retcode != 0:
return retcode
# Summarize the requested operation
summarize_arguments(args.upstream_repository, args.upstream_vcs_type,
args.upstream_branch)
# Validate the arguments and repository
if not validate_args(args.upstream_vcs_type):
return 1
# Store the current branch
current_branch = get_current_branch()
try:
set_upstream(args.upstream_repository, args.upstream_vcs_type,
args.upstream_branch)
info("Upstream successively set.")
return 0
finally:
# Try to roll back to the branch the user was on before
# this possibly failed.
if current_branch:
checkout(current_branch)
return 1
def export_patches(directory=None):
### Ensure a clean/valid working environment
ensure_clean_working_env(git_status=True, directory=directory)
# Get current branch
current_branch = get_current_branch(directory)
if current_branch is None:
error("Could not determine current branch.", exit=True)
# Construct the patches branch name
patches_branch = 'patches/' + current_branch
# Ensure the patches branch exists
if not branch_exists(patches_branch, False, directory=directory):
error("The patches branch ({0}) does not ".format(patches_branch) +
"exist, did you use git-bloom-branch?",
exit=True)
try:
# Get parent branch and base commit from patches branch
config = get_patch_config(patches_branch, directory)
if config is None:
error("Failed to get patches information.", exit=True)
# Checkout to the patches branch
checkout(patches_branch, directory=directory)
# Notify the user
debug("Exporting patches from "
"{0}...{1}".format(config['base'], current_branch))
# Remove all the old patches
if len(list_patches(directory)) > 0:
cmd = 'git rm ./*.patch'
execute_command(cmd, cwd=directory)
# Create the patches using git format-patch
cmd = "git format-patch -M -B " \
"{0}...{1}".format(config['base'], current_branch)
execute_command(cmd, cwd=directory)
# Report of the number of patches created
patches_list = list_patches(directory)
debug("Created {0} patches".format(len(patches_list)))
# Clean up and commit
if len(patches_list) > 0:
cmd = 'git add ./*.patch'
execute_command(cmd, cwd=directory)
if has_changes(directory):
cmd = 'git commit -m "Updating patches."'
execute_command(cmd, cwd=directory)
finally:
if current_branch:
checkout(current_branch, directory=directory)
def export_patches(directory=None):
### Ensure a clean/valid working environment
ensure_clean_working_env(git_status=True, directory=directory)
# Get current branch
current_branch = get_current_branch(directory)
if current_branch is None:
error("Could not determine current branch.", exit=True)
# Construct the patches branch name
patches_branch = 'patches/' + current_branch
# Ensure the patches branch exists
if not branch_exists(patches_branch, False, directory=directory):
error("The patches branch ({0}) does not ".format(patches_branch) +
"exist, did you use git-bloom-branch?", exit=True)
try:
# Get parent branch and base commit from patches branch
config = get_patch_config(patches_branch, directory)
if config is None:
error("Failed to get patches information.", exit=True)
# Checkout to the patches branch
checkout(patches_branch, directory=directory)
# Notify the user
debug("Exporting patches from "
"{0}...{1}".format(config['base'], current_branch))
# Remove all the old patches
if len(list_patches(directory)) > 0:
cmd = 'git rm ./*.patch'
execute_command(cmd, cwd=directory)
# Create the patches using git format-patch
cmd = "git format-patch -M -B " \
"{0}...{1}".format(config['base'], current_branch)
execute_command(cmd, cwd=directory)
# Report of the number of patches created
patches_list = list_patches(directory)
debug("Created {0} patches".format(len(patches_list)))
# Clean up and commit
if len(patches_list) > 0:
cmd = 'git add ./*.patch'
execute_command(cmd, cwd=directory)
if has_changes(directory):
cmd = 'git commit -m "Updating patches."'
execute_command(cmd, cwd=directory)
finally:
if current_branch:
checkout(current_branch, directory=directory)
def main(sysargs=None):
parser = get_parser()
parser = add_global_arguments(parser)
args = parser.parse_args(sysargs)
handle_global_arguments(args)
# Check that the current directory is a serviceable git/bloom repo
try:
ensure_clean_working_env()
ensure_git_root()
except SystemExit:
parser.print_usage()
raise
# If the src argument isn't set, use the current branch
if args.src is None:
args.src = get_current_branch()
# Execute the branching
execute_branch(args.src, args.destination_branch, args.interactive)
def main(sysargs=None):
parser = get_parser()
parser = add_global_arguments(parser)
args = parser.parse_args(sysargs)
handle_global_arguments(args)
# Check that the current directory is a serviceable git/bloom repo
try:
ensure_clean_working_env()
ensure_git_root()
except SystemExit:
parser.print_usage()
raise
# If the src argument isn't set, use the current branch
if args.src is None:
args.src = get_current_branch()
# Execute the branching
execute_branch(args.src, args.destination_branch, args.interactive)
def rebase_patches(without_git_rebase=True, directory=None):
### Ensure a clean/valid working environment
ret = ensure_clean_working_env(git_status=True, directory=directory)
if ret != 0:
return ret
### Make sure we need to actually call this
# Get the current branch
current_branch = get_current_branch(directory)
# Get the patches branch
patches_branch = "patches/" + current_branch
# Get the current patches.conf
config = get_patch_config(patches_branch, directory=directory)
# Get the current upstream commit hash
upstream_commit_hash = get_commit_hash(config["parent"], directory)
# If the current upstream commit hash is the same as the stored one, noop
if upstream_commit_hash == config["previous"]:
debug(
"Nothing to do: Current branch (" + current_branch + ")'s "
"base commit hash is the same as the source branch (" + config["parent"] + ")'s commit hash."
)
debug(" Did you forget to update the parent branch first?")
debug(
" Updating the parent branch can be done by calling "
"'git-bloom-patch rebase' on it, or 'git-bloom-import-upsteam'"
" if the parent branch is the upstream branch."
)
return 0
else:
debug(
"rebase_patches: "
+ upstream_commit_hash
+ " == "
+ config["previous"]
+ ": "
+ str(upstream_commit_hash == config["previous"])
)
### Execute the rebase
if without_git_rebase:
non_git_rebase(config["parent"], directory=directory)
else:
git_rebase(config["parent"], directory=directory)
### Update the patches information
# Get the latest configs
config = get_patch_config(patches_branch, directory)
# Set the base to the current hash (before patches)
config["base"] = get_commit_hash(current_branch, directory)
# Set the new upstream hash to the previous upstream hash
config["previous"] = get_commit_hash(config["parent"], directory)
# Clear the trimbase (it needs to be reapplied)
config["trimbase"] = ""
# Write the new configs
set_patch_config(patches_branch, config, directory)
return 0
def main(sysargs=None):
parser = get_argument_parser()
parser = add_global_arguments(parser)
args = parser.parse_args(sysargs)
handle_global_arguments(args)
# Check that the current directory is a serviceable git/bloom repo
ret = ensure_clean_working_env()
if ret != 0:
parser.print_usage()
return ret
# Get the current git branch
current_branch = get_current_branch()
# Create a working temp directory
tmp_dir = create_temporary_directory()
cwd = os.getcwd()
try:
# Get off upstream branch
if current_branch == 'upstream':
checkout(get_commit_hash('upstream'), directory=cwd)
retcode = import_upstream(cwd, tmp_dir, args)
# Done!
retcode = retcode if retcode is not None else 0
if retcode == 0:
info("I'm happy. You should be too.")
return retcode
finally:
# Change back to the original cwd
os.chdir(cwd)
# Clean up
shutil.rmtree(tmp_dir)
if current_branch and branch_exists(current_branch, True, cwd):
checkout(current_branch, directory=cwd)
