def _ProjectBranchName(self, branch, project, original=None): """Determine's the git branch name for the project. Args: branch: The base branch name. project: The repo_manfest.Project in question. original: Original branch name to remove from the branch suffix. Returns: The branch name for the project. """ # If project has only one checkout, the base branch name is fine. checkouts = [p.name for p in self.checkout.manifest.Projects()] if checkouts.count(project.name) == 1: return branch # Otherwise, the project branch name needs a suffix. We append its # upstream or revision to distinguish it from other checkouts. suffix = '-' + git.StripRefs(project.upstream or project.Revision()) # If the revision is itself a branch, we need to strip the old branch name # from the suffix to keep naming consistent. if original: suffix = re.sub('^-%s-' % original, '-', suffix) return branch + suffix
def __init__(self, path, tracking_branch, remote='origin'): tracking_branch = 'refs/remotes/%s/%s' % ( remote, git.StripRefs(tracking_branch), ) attrs = dict(local_path=path, path=path, tracking_branch=tracking_branch) self.checkout = git.ProjectCheckout(attrs)
def _GetBranchSuffix(self, manifest, checkout): """Return the branch suffix for the given checkout. If a given project is checked out to multiple locations, it is necessary to append a branch suffix. To be safe, we append branch suffixes for all repositories that use a non-standard branch name (e.g., if our default revision is "master", then any repository which does not use "master" has a non-standard branch name.) Args: manifest: The associated ManifestCheckout. checkout: The associated ProjectCheckout. """ # Get the default and tracking branch. suffix = '' if len(manifest.FindCheckouts(checkout['name'])) > 1: default_branch = git.StripRefs(manifest.default['revision']) tracking_branch = git.StripRefs(checkout['tracking_branch']) suffix = '-%s' % (tracking_branch,) if default_branch != 'master': suffix = re.sub('^-%s-' % re.escape(default_branch), '-', suffix) return suffix
def _RunPush(self, checkout, src_ref, dest_ref, force=False): """Perform a git push for a checkout. Args: checkout: A dictionary of checkout manifest attributes. src_ref: The source local ref to push to the remote. dest_ref: The local remote ref that correspond to destination ref name. force: Whether to override non-fastforward checks. """ # Convert local tracking ref to refs/heads/* on a remote: # refs/remotes/<remote name>/<branch> to refs/heads/<branch>. # If dest_ref is already refs/heads/<branch> it's a noop. dest_ref = git.NormalizeRef(git.StripRefs(dest_ref)) push_to = git.RemoteRef(checkout['push_remote'], dest_ref) git.GitPush(checkout['local_path'], src_ref, push_to, force=force, skip=self.skip_remote_push)
def Create(self, push=False, force=False): """Creates a new branch from the given version. Branches are always created locally, even when push is true. Args: push: Whether to push the new branch to remote. force: Whether or not to overwrite an existing branch. """ branches = self._ProjectBranches(self.name) if not force: self._ValidateBranches(branches) self._RepairManifestRepositories(branches) self._PushBranchesToRemote(branches, dry_run=not push, force=force) # Must bump version last because of how VersionInfo is implemented. Sigh... which_version = self._WhichVersionShouldBump() self.checkout.BumpVersion(which_version, self.name, 'Bump %s number after creating branch %s.' % (which_version, self.name), dry_run=not push) # Increment branch/build number for source 'master' branch. # manifest_version already does this for release branches. # TODO(@jackneus): Make this less of a hack. # In reality, this whole tool is being deleted pretty soon. if self.__class__.__name__ != 'ReleaseBranch': source_version = 'branch' if which_version == 'patch' else 'build' # Use the default node's revision if it exists. We stopped writing this # for new branches in 2019 though, so this won't be true for newer # branches. source_ref = self.checkout.manifest.Default().revision if not source_ref: # Otherwise, use the source version's upstream, # e.g. refs/heads/release-R77-12371.B source_ref = self.checkout.manifest.GetUniqueProject( 'chromeos/manifest-internal').upstream self.checkout.BumpVersion( source_version, git.StripRefs(source_ref), 'Bump %s number for source branch after creating branch %s' % (source_version, self.name), dry_run=not push)
def _FilterProjectsInManifestByGroup(cls, manifest, groups): """Filters projects in |manifest| by |groups|. Args: manifest: A git.Manifest instance. groups: A list of groups to filter. Returns: A set of (project, branch) tuples where each tuple is asssociated with at least one group in |groups|. """ results = set() for project, checkout_list in manifest.checkouts_by_name.iteritems(): for checkout in checkout_list: if any(x in checkout['groups'] for x in groups): branch = git.StripRefs(checkout['tracking_branch']) results.add((project, branch)) return results