def drop_pq_bb(cfg, repo, options): """Remove pq branch""" current = repo.get_branch() if is_pq_branch(current, options): base = pq_branch_base(current, options) bbfile = parse_bb(cfg, options, repo, base) else: bbfile = parse_bb(cfg, options, repo) drop_pq(repo, current, options, pkg_version(bbfile))
def rebase_pq(cfg, repo, options): """Rebase pq branch on the correct upstream version""" current = repo.get_branch() if is_pq_branch(current, options): base = pq_branch_base(current, options) bbfile = parse_bb(cfg, options, repo, base) else: base = current bbfile = parse_bb(cfg, options, repo) upstream_commit = find_upstream_commit(repo, bbfile, options.upstream_tag) switch_to_pq_branch(cfg, repo, base, options) GitCommand("rebase")([upstream_commit])
def export_patches(cfg, repo, options): """Export patches from the pq branch into a packaging branch""" current = repo.get_branch() if is_pq_branch(current, options): base = pq_branch_base(current, options) gbp.log.info("On branch '%s', switching to '%s'" % (current, base)) repo.set_branch(base) bbfile = parse_bb(cfg, options, repo) pq_branch = current else: bbfile = parse_bb(cfg, options, repo) pq_branch = pq_branch_name(current, options, pkg_version(bbfile)) upstream_commit = find_upstream_commit(repo, bbfile, options.upstream_tag) export_treeish = options.export_rev if options.export_rev else pq_branch update_patch_series(repo, bbfile, upstream_commit, export_treeish, options) bb_dir = os.path.dirname(bbfile.getVar('FILE', True)) GitCommand('status')(['--', bb_dir])
def import_bb_patches(cfg, repo, options): """Apply a series of patches in a recipe to branch onto a pq branch""" current = repo.get_branch() if is_pq_branch(current, options): base = pq_branch_base(current, options) raise GbpError("Already on a patch-queue branch '%s' - doing " "nothing." % current) else: bbfile = parse_bb(cfg, options, repo) base = current upstream_commit = find_upstream_commit(repo, bbfile, options.upstream_tag) pq_branch = pq_branch_name(base, options, pkg_version(bbfile)) # Create pq-branch if repo.has_branch(pq_branch) and not options.force: raise GbpError("Patch-queue branch '%s' already exists. " "Try 'rebase' instead." % pq_branch) try: if repo.get_branch() == pq_branch: repo.force_head(upstream_commit, hard=True) else: repo.create_branch(pq_branch, upstream_commit, force=True) except GitRepositoryError as err: raise GbpError("Cannot create patch-queue branch '%s': %s" % (pq_branch, err)) # Put patches in a safe place in_queue = bb_to_patch_series(bbfile) queue = safe_patches(in_queue, options.tmp_dir) # Do import try: gbp.log.info("Switching to branch '%s'" % pq_branch) repo.set_branch(pq_branch) import_extra_files(repo, base, options.import_files) if not queue: return gbp.log.info("Trying to apply patches from branch '%s' onto '%s'" % (base, upstream_commit)) for patch in queue: gbp.log.debug("Applying %s" % patch.path) apply_and_commit_patch(repo, patch, fallback_author=None) except (GbpError, GitRepositoryError) as err: gbp.log.err('Import failed: %s' % err) repo.force_head('HEAD', hard=True) repo.set_branch(base) repo.delete_branch(pq_branch) raise recipe_fn = os.path.basename(bbfile.getVar('FILE', True)) gbp.log.info("Patches listed in '%s' imported on '%s'" % (recipe_fn, pq_branch))
def switch_to_pq_branch(cfg, repo, branch, options): """ Switch to patch-queue branch if not already there, create it if it doesn't exist yet """ if is_pq_branch(branch, options): return bbfile = parse_bb(cfg, options, repo, branch) pq_branch = pq_branch_name(branch, options, pkg_version(bbfile)) if not repo.has_branch(pq_branch): raise GbpError("Branch '%s' does not exist" % pq_branch) gbp.log.info("Switching to branch '%s'" % pq_branch) repo.set_branch(pq_branch)
def main(argv): """Entry point for git-buildpackage-bb""" retval = 0 prefix = "git-" bbfile = None dump_dir = None if not bb: return 1 options, gbp_args, builder_args = parse_args(argv, prefix) if not options: return 1 try: repo = RpmGitRepository(os.path.curdir) except GitRepositoryError: gbp.log.err("%s is not a git repository" % (os.path.abspath('.'))) return 1 # Determine tree-ish to be exported try: tree = get_tree(repo, options.export) except GbpError as err: gbp.log.err('Failed to determine export treeish: %s' % err) return 1 # Re-parse config options with using the per-tree config file(s) from the # exported tree-ish options, gbp_args, builder_args = parse_args(argv, prefix, tree) branch = get_current_branch(repo) try: tinfoil = init_tinfoil(config_only=True) #bb_cfg_data = bb.data.createCopy(tinfoil.config_data) except GbpError: tinfoil = None # Use naive parsing because repository might only have .bb file gbp.log.info("Using naive standalone parsing of recipes in package repo.") bb_cfg_data = None try: tree = guess_export_params(repo, options) Command(options.cleaner, shell=True)() if not options.ignore_new: (ret, out) = repo.is_clean(options.ignore_untracked) if not ret: gbp.log.err("You have uncommitted changes in your source tree:") gbp.log.err(out) raise GbpError("Use --git-ignore-new or --git-ignore-untracked " "to ignore.") if not options.ignore_new and not options.ignore_branch: if branch != options.packaging_branch: gbp.log.err("You are not on branch '%s' but on '%s'" % (options.packaging_branch, branch)) raise GbpError("Use --git-ignore-branch to ignore or " "--git-packaging-branch to set the branch name.") if not options.tag_only: # Dump/parse meta to export dir if options.export_dir: export_dir = os.path.abspath(options.export_dir) else: export_dir = guess_export_dir(options, tinfoil, repo, tree) gbp.log.info("Dumping meta from tree '%s' to '%s'" % (options.export, export_dir)) bbfile = dump_meta(bb_cfg_data, options, repo, tree, export_dir) # Setup builder opts setup_builder(options, builder_args) if is_native(repo, options) and bbfile.getVar('SRCREV') == 'HEAD': # Update SRCREV for native packages that are exported from # pristine repository BBFile.set_var_val(bbfile.bb_path, 'SRCREV', repo.rev_parse(tree)) # TODO: Re-design the handling of native packages. Updating # SRCREV must probably be more explicit if options.patch_export: # Generate patches, if requested if options.patch_export_rev: patch_tree = get_tree(repo, options.patch_export_rev) else: patch_tree = tree export_patches(repo, bbfile, patch_tree, options) # Run postexport hook if options.postexport: RunAtCommand(options.postexport, shell=True, extra_env={'GBP_GIT_DIR': repo.git_dir, 'GBP_TMP_DIR': export_dir} )(dir=export_dir) # Do actual build if not options.no_build: if options.prebuild: RunAtCommand(options.prebuild, shell=True, extra_env={'GBP_GIT_DIR': repo.git_dir, 'GBP_BUILD_DIR': export_dir} )(dir=export_dir) # Unlock cooker so that we are able to run external bitbake if options.builder == 'bitbake' and tinfoil: bb.utils.unlockfile(tinfoil.cooker.lock) # Finally build the package: bb_path = bbfile.getVar('FILE', True) builder_args.extend(['-b', bb_path]) RunAtCommand(options.builder, builder_args, shell=True, extra_env={'GBP_BUILD_DIR': export_dir})() if options.postbuild: Command(options.postbuild, shell=True, extra_env={'GBP_BUILD_DIR': export_dir})() else: # Tag-only: we just need to parse the meta bbfile = parse_bb(bb_cfg_data, options, repo, tree) # Tag (note: tags the exported version) if options.tag or options.tag_only: version = pkg_version(bbfile) gbp.log.info("Tagging %s" % RpmPkgPolicy.compose_full_version(version)) commit_info = repo.get_commit_info(tree) tag = packaging_tag_name(repo, version, commit_info, options) if options.retag and repo.has_tag(tag): repo.delete_tag(tag) create_packaging_tag(repo, tag, commit=tree, version=version, options=options) vcs_info = get_vcs_info(repo, tag) if options.posttag: sha = repo.rev_parse("%s^{}" % tag) Command(options.posttag, shell=True, extra_env={'GBP_TAG': tag, 'GBP_BRANCH': branch, 'GBP_SHA1': sha})() else: vcs_info = get_vcs_info(repo, tree) # TODO: Put VCS information to recipe if options.bb_vcs_info: raise GbpError("Injecting VCS info into recipe not yet supported") except CommandExecFailed: retval = 1 except GitRepositoryError as err: gbp.log.err("Git command failed: %s" % err) retval = 1 except GbpAutoGenerateError as err: if len(err.__str__()): gbp.log.err(err) retval = 2 except GbpError, err: if len(err.__str__()): gbp.log.err(err) retval = 1