def RefreshManifestCheckout(manifest_dir, manifest_repo): """Checks out manifest-versions into the manifest directory. If a repository is already present, it will be cleansed of any local changes and restored to its pristine state, checking out the origin. """ logging.info('Refreshing %s from %s', manifest_dir, manifest_repo) reinitialize = True if os.path.exists(manifest_dir): result = git.RunGit(manifest_dir, ['config', 'remote.origin.url'], error_code_ok=True) if (result.returncode == 0 and result.output.rstrip() == manifest_repo): logging.info('Updating manifest-versions checkout.') try: git.RunGit(manifest_dir, ['gc', '--auto']) git.CleanAndCheckoutUpstream(manifest_dir) except cros_build_lib.RunCommandError: logging.warning('Could not update manifest-versions checkout.') else: reinitialize = False else: logging.info('No manifest-versions checkout exists at %s', manifest_dir) if reinitialize: logging.info('Cloning fresh manifest-versions checkout.') osutils.RmDir(manifest_dir, ignore_missing=True) git.Clone(manifest_dir, manifest_repo)
def testClone(self): url = 'http://happy/git/repo' git.Clone(self.fake_git_dir, url) # Should have created the git repo directory, if it didn't exist. self.assertExists(self.fake_git_dir) self.assertCommandContains(['git', 'clone', url, self.fake_git_dir])
def testCloneComplex(self): url = 'http://happy/git/repo' ref = 'other/git/repo' git.Clone(self.fake_git_dir, url, reference=ref, branch='feature', single_branch=True) self.assertCommandContains(['git', 'clone', url, self.fake_git_dir, '--reference', ref, '--branch', 'feature', '--single-branch'])
def _PerformStageInTempDir(self): # The plan for the builders is to use master branch to bootstrap other # branches. Now, if we wanted to test patches for both the bootstrap code # (on master) and the branched chromite (say, R20), we need to filter the # patches by branch. filter_branch = self._run.manifest_branch if self._run.options.test_bootstrap: filter_branch = 'master' # Filter all requested patches for the branch. branch_pool = self.patch_pool.FilterBranch(filter_branch) # Checkout the new version of chromite, and patch it. chromite_dir = os.path.join(self.tempdir, 'chromite') reference_repo = os.path.join(constants.CHROMITE_DIR, '.git') git.Clone(chromite_dir, constants.CHROMITE_URL, reference=reference_repo) git.RunGit(chromite_dir, ['checkout', filter_branch]) chromite_pool = branch_pool.Filter(project=constants.CHROMITE_PROJECT) if chromite_pool: patches = patch_series.PatchSeries.WorkOnSingleRepo( chromite_dir, filter_branch) self._ApplyPatchSeries(patches, chromite_pool) # Re-exec into new instance of cbuildbot, with proper command line args. cbuildbot_path = constants.PATH_TO_CBUILDBOT if not os.path.exists(os.path.join(self.tempdir, cbuildbot_path)): cbuildbot_path = 'chromite/cbuildbot/cbuildbot' cmd = self.FilterArgsForTargetCbuildbot(self.tempdir, cbuildbot_path, self._run.options) extra_params = ['--sourceroot', self._run.options.sourceroot] extra_params.extend(self._run.options.bootstrap_args) if self._run.options.test_bootstrap: # We don't want re-executed instance to see this. cmd = [a for a in cmd if a != '--test-bootstrap'] else: # If we've already done the desired number of bootstraps, disable # bootstrapping for the next execution. Also pass in the patched manifest # repository. extra_params.append('--nobootstrap') if self._run.config.internal: manifest_pool = branch_pool.FilterIntManifest() else: manifest_pool = branch_pool.FilterExtManifest() if manifest_pool: manifest_dir = self._ApplyManifestPatches(manifest_pool) extra_params.extend(['--manifest-repo-url', manifest_dir]) cmd += extra_params result_obj = cros_build_lib.run( cmd, cwd=self.tempdir, kill_timeout=30, error_code_ok=True) self.returncode = result_obj.returncode
def _CheckoutLuciProject(self): """Checkout the LUCI project config. Raises: BranchNotFoundException if failed to checkout to the branch. """ self.project_dir = self._MakeWorkDir('luci_config') git.Clone(self.project_dir, self.PROJECT_URL, branch=self.PROJECT_BRANCH) logging.info('Checked out luci config %s:%s in %s', self.PROJECT_URL, self.PROJECT_BRANCH, self.project_dir)
def CloneWorkingRepo(dest, url, reference, branch): """Clone a git repository with an existing local copy as a reference. Also copy the hooks into the new repository. Args: dest: The directory to clone int. url: The URL of the repository to clone. reference: Local checkout to draw objects from. branch: The branch to clone. """ git.Clone(dest, url, reference=reference, single_branch=True, branch=branch) for name in glob.glob(os.path.join(reference, '.git', 'hooks', '*')): newname = os.path.join(dest, '.git', 'hooks', os.path.basename(name)) shutil.copyfile(name, newname) shutil.copystat(name, newname)
def _SetupWorkDirectoryForPatch(work_dir, patch, branch, manifest, email): """Set up local dir for uploading changes to the given patch's project.""" logging.notice('Setting up dir %s for uploading changes to %s', work_dir, patch.project_url) # Clone the git repo from reference if we have a pointer to a # ManifestCheckout object. reference = None if manifest: # Get the path to the first checkout associated with this change. Since # all of the checkouts share git objects, it doesn't matter which checkout # we pick. path = manifest.FindCheckouts(patch.project)[0]['path'] reference = os.path.join(constants.SOURCE_ROOT, path) if not os.path.isdir(reference): logging.error('Unable to locate git checkout: %s', reference) logging.error('Did you mean to use --nomirror?') # This will do an "raise OSError" with the right values. os.open(reference, os.O_DIRECTORY) # Use the email if email wasn't specified. if not email: email = git.GetProjectUserEmail(reference) git.Clone(work_dir, patch.project_url, reference=reference) # Set the git committer. git.RunGit(work_dir, ['config', '--replace-all', 'user.email', email]) mbranch = git.MatchSingleBranchName(work_dir, branch, namespace='refs/remotes/origin/') if branch != mbranch: logging.notice('Auto resolved branch name "%s" to "%s"', branch, mbranch) branch = mbranch # Finally, create a local branch for uploading changes to the given remote # branch. git.CreatePushBranch(constants.PATCH_BRANCH, work_dir, sync=False, remote_push_branch=git.RemoteRef( 'ignore', 'origin/%s' % branch)) return branch
def _VbootCheckout(self): """Clone the vboot reference repo and checkout the vboot stable hash.""" if not os.path.exists(self.directory): raise SecurityConfigDirectoryError('The directory does not exist.') if not self._checked_out: try: git.Clone(self._repo_dir, self._VBOOT_SRC, reference=self._VBOOT_SRC) except cros_build_lib.RunCommandError as e: raise VbootCheckoutError('Failed cloning repo from %s: %s' % (self._VBOOT_SRC, e)) try: cros_build_lib.run(['git', 'checkout', '-q', self.vboot_hash], cwd=self._repo_dir) except cros_build_lib.RunCommandError as e: raise VbootCheckoutError('Failed checking out %s from %s: %s' % (self.vboot_hash, self._VBOOT_SRC, e)) self._checked_out = True
def _ApplyManifestPatches(self, patch_pool): """Apply a pool of manifest patches to a temp manifest checkout. Args: patch_pool: The pool to apply. Returns: The path to the patched manifest checkout. Raises: Exception, if the new patched manifest cannot be parsed. """ checkout_dir = os.path.join(self.tempdir, 'manfest-checkout') git.Clone(checkout_dir, self._run.config.manifest_repo_url) patches = patch_series.PatchSeries.WorkOnSingleRepo( checkout_dir, tracking_branch=self._run.manifest_branch) self._ApplyPatchSeries(patches, patch_pool) # Verify that the patched manifest loads properly. Propagate any errors as # exceptions. manifest = os.path.join(checkout_dir, self._run.config.manifest) git.Manifest.Cached(manifest, manifest_include_dir=checkout_dir) return checkout_dir