def main(argv): cros_build_lib.AssertInsideChroot() opts = _ParseArguments(argv) site_config = config_lib.GetConfig() logging.info('Generating board configs. This takes about 2m...') for key in sorted(binhost.GetChromePrebuiltConfigs(site_config)): binhost.GenConfigsForBoard(key.board, regen=opts.regen, error_code_ok=True) # Fetch all compat IDs. fetcher = binhost.CompatIdFetcher() keys = binhost.GetChromePrebuiltConfigs(site_config).keys() compat_ids = fetcher.FetchCompatIds(keys) # Save the PFQ configs. pfq_configs = binhost.PrebuiltMapping.Get(keys, compat_ids) filename_internal = binhost.PrebuiltMapping.GetFilename( opts.buildroot, 'chrome') pfq_configs.Dump(filename_internal) git.AddPath(filename_internal) git.Commit(os.path.dirname(filename_internal), 'Update PFQ config dump', allow_empty=True) filename_external = binhost.PrebuiltMapping.GetFilename(opts.buildroot, 'chromium', internal=False) pfq_configs.Dump(filename_external, internal=False) git.AddPath(filename_external) git.Commit(os.path.dirname(filename_external), 'Update PFQ config dump', allow_empty=True)
def testCommit(self): self.rc.AddCmdResult(partial_mock.In('log'), output=self.COMMIT_LOG) git.Commit(self.fake_git_dir, 'bar') self.assertCommandContains(['--amend'], expected=False) cid = git.Commit(self.fake_git_dir, 'bar', amend=True) self.assertCommandContains(['--amend']) self.assertCommandContains(['--allow-empty'], expected=False) self.assertEqual(cid, self.CHANGE_ID) cid = git.Commit(self.fake_git_dir, 'new', allow_empty=True) self.assertCommandContains(['--allow-empty'])
def PrepManifestForRepo(git_repo, manifest): """Use this to store a local manifest in a git repo suitable for repo. The repo tool can only fetch manifests from git repositories. So, to use a local manifest file as the basis for a checkout, it must be checked into a local git repository. Common Usage: manifest = CreateOrFetchWondrousManifest() with osutils.TempDir() as manifest_git_dir: PrepManifestForRepo(manifest_git_dir, manifest) repo = RepoRepository(manifest_git_dir, repo_dir) repo.Sync() Args: git_repo: Path at which to create the git repository (directory created, if needed). If a tempdir, then cleanup is owned by the caller. manifest: Path to existing manifest file to copy into the new git repository. """ if not git.IsGitRepo(git_repo): git.Init(git_repo) new_manifest = os.path.join(git_repo, constants.DEFAULT_MANIFEST) shutil.copyfile(manifest, new_manifest) git.AddPath(new_manifest) message = 'Local repository holding: %s' % manifest # Commit new manifest. allow_empty in case it's the same as last manifest. git.Commit(git_repo, message, allow_empty=True)
def setUp(self): self.manifest_dir = os.path.join(self.tempdir, '.repo', 'manifests') # Initialize a repo instance here. local_repo = os.path.join(constants.SOURCE_ROOT, '.repo/repo/.git') # TODO(evanhernandez): This is a hack. Find a way to simplify this test. # We used to use the current checkout's manifests.git, but that caused # problems in production environemnts. remote_manifests = os.path.join(self.tempdir, 'remote', 'manifests.git') osutils.SafeMakedirs(remote_manifests) git.Init(remote_manifests) default_manifest = os.path.join(remote_manifests, 'default.xml') osutils.WriteFile( default_manifest, '<?xml version="1.0" encoding="UTF-8"?><manifest></manifest>') git.AddPath(default_manifest) git.Commit(remote_manifests, 'dummy commit', allow_empty=True) git.CreateBranch(remote_manifests, 'default') git.CreateBranch(remote_manifests, 'release-R23-2913.B') git.CreateBranch(remote_manifests, 'release-R23-2913.B-suffix') git.CreateBranch(remote_manifests, 'firmware-link-') # Create a copy of our existing manifests.git, but rewrite it so it # looks like a remote manifests.git. This is to avoid hitting the # network, and speeds things up in general. local_manifests = 'file://%s' % remote_manifests temp_manifests = os.path.join(self.tempdir, 'manifests.git') git.RunGit(self.tempdir, ['clone', '-n', '--bare', local_manifests]) git.RunGit(temp_manifests, [ 'fetch', '-f', '-u', local_manifests, 'refs/remotes/origin/*:refs/heads/*' ]) git.RunGit(temp_manifests, ['branch', '-D', 'default']) cros_build_lib.run([ 'repo', 'init', '-u', temp_manifests, '--repo-branch', 'default', '--repo-url', 'file://%s' % local_repo, ], cwd=self.tempdir) self.active_manifest = os.path.realpath( os.path.join(self.tempdir, '.repo', 'manifest.xml'))
def UpdateBinhostConfFile(path, key, value): """Update binhost config file file with key=value. Args: path: Filename to update. key: Key to update. value: New value for key. """ cwd, filename = os.path.split(os.path.abspath(path)) osutils.SafeMakedirs(cwd) if not git.GetCurrentBranch(cwd): git.CreatePushBranch(constants.STABLE_EBUILD_BRANCH, cwd, sync=False) osutils.WriteFile(path, '', mode='a') if UpdateLocalFile(path, value, key): desc = '%s: %s %s' % (filename, 'updating' if value else 'clearing', key) git.AddPath(path) git.Commit(cwd, desc)
def unpin(self, work_dir): """Unpin chrome.""" overlay = os.path.join(work_dir, 'overlay') print('Setting up working directory...') CloneWorkingRepo(overlay, OVERLAY_URL, OVERLAY, self.options.branch) print('Done') mask_file = os.path.join(overlay, MASK_FILE) if not os.path.exists(mask_file): raise Exception('Mask file not found. Is Chrome pinned?') git.CreateBranch(overlay, self.branch_name, track=True, branch_point='origin/%s' % self.options.branch) git.RmPath(mask_file) git.Commit(overlay, self.CommitMessage('Chrome: Unpin chrome')) git.UploadCL(overlay, OVERLAY_URL, self.options.branch, skip=self.options.dryrun)
def pin(self, work_dir): """Pin chrome.""" overlay = os.path.join(work_dir, 'overlay') priv_overlay = os.path.join(work_dir, 'priv_overlay') print('Setting up working directory...') CloneWorkingRepo(overlay, OVERLAY_URL, OVERLAY, self.options.branch) CloneWorkingRepo(priv_overlay, PRIV_OVERLAY_URL, PRIV_OVERLAY, self.options.branch) print('Done') # Interesting paths. chrome_dir = os.path.join(overlay, constants.CHROME_CP) other_dirs = [ os.path.join(overlay, pkg) for pkg in constants.OTHER_CHROME_PACKAGES ] # Let the user pick what version to pin chrome to. uprev_list = UprevList(chrome_dir) choice = cros_build_lib.GetChoice('Versions of chrome to pin to:', uprev_list, group_size=5) pin_version = uprev_list.uprevs[choice] commit_subject = ('Chrome: Pin to version %s' % pin_version.from_parts.version) # Public branch. git.CreateBranch(overlay, self.branch_name, track=True, branch_point='origin/%s' % self.options.branch) target_sha = pin_version.sha + '~' ebs = [RevertStableEBuild(chrome_dir, target_sha)] for pkg_dir in other_dirs: ebs.append(RevertStableEBuild(pkg_dir, target_sha)) RevertBinhostConf(overlay, pin_version.conf_files, target_sha) git.RevertPath(os.path.join(overlay, 'chromeos', 'binhost'), 'chromium.json', target_sha) MaskNewerPackages(overlay, (eb for eb in ebs if eb)) pub_cid = git.Commit(overlay, 'Public overlay commit') if not pub_cid: raise Exception( "Don't know the commit ID of the public overlay CL.") # Find out what package directory the binhost configs should point to. binhost_dir = os.path.join(overlay, 'chromeos', 'binhost') target_file = os.path.join(binhost_dir, 'target', pin_version.conf_files[0]) host_file = os.path.join(binhost_dir, 'host', pin_version.conf_files[0]) conf_file = target_file if os.path.exists(target_file) else host_file conf_content = osutils.ReadFile(conf_file) match = re.search('/(?P<package_dir>[^/\n]*)/packages', conf_content) if not match: raise Exception('Failed to parse binhost conf %s' % conf_content.strip()) pkg_dir = match.group('package_dir') # Private branch. git.CreateBranch(priv_overlay, self.branch_name, track=True, branch_point='origin/%s' % self.options.branch) binhost_uprev = FindPrivateConfCL(priv_overlay, pkg_dir) if not binhost_uprev: raise Exception('Failed to find private binhost uprev.') target_sha = binhost_uprev.sha RevertBinhostConf(priv_overlay, binhost_uprev.conf_files, target_sha) git.RevertPath(os.path.join(priv_overlay, 'chromeos', 'binhost'), 'chrome.json', target_sha) commit_message = self.CommitMessage(commit_subject, pub_cid) priv_cid = git.Commit(priv_overlay, commit_message) if not priv_cid: raise Exception( "Don't know the commit ID of the private overlay CL.") # Update the commit message on the public overlay CL. commit_message = self.CommitMessage(commit_subject, '*' + priv_cid, pub_cid) git.Commit(overlay, commit_message, amend=True) # Upload the CLs. external_push = git.UploadCL(overlay, OVERLAY_URL, self.options.branch, skip=self.options.dryrun) print(external_push.output) internal_push = git.UploadCL(priv_overlay, PRIV_OVERLAY_URL, self.options.branch, skip=self.options.dryrun) print(internal_push.output) print('\n** Both of the changes above need to be submitted for chrome ' 'to be pinned. **\n')
def UprevChrome(self, work_dir, pfq_build, build_number): """Uprev Chrome. Args: work_dir: directory to clone repository and update uprev. pfq_build: pfq build_id to uprev chrome. build_number: corresponding build number showed on waterfall. Raises: Exception when no commit ID is found in the public overlay CL. Exception when no commit ID is found in the private overlay CL. """ # Verify the format of reviewers reviewers = self.options.reviewers self.ValidateReviewers(reviewers) pub_overlay = os.path.join(work_dir, 'pub_overlay') priv_overlay = os.path.join(work_dir, 'priv_overlay') print('Setting up working directory...') # TODO(nxia): move cros_pinchrome.CloneWorkingRepo to a util class? cros_pinchrome.CloneWorkingRepo(pub_overlay, PUB_OVERLAY_URL, PUB_OVERLAY, MASTER_BRANCH) cros_pinchrome.CloneWorkingRepo(priv_overlay, PRIV_OVERLAY_URL, PRIV_OVERLAY, MASTER_BRANCH) print('Preparing CLs...') remote = 'origin' branch_name = constants.STAGING_PFQ_BRANCH_PREFIX + pfq_build remote_ref = ('refs/' + constants.PFQ_REF + '/' + branch_name) local_branch = '%s_%s' % (branch_name, cros_build_lib.GetRandomString()) logging.info('Checking remote refs.') self.CheckRemoteBranch(pub_overlay, remote, remote_ref) self.CheckRemoteBranch(priv_overlay, remote, remote_ref) # Fetch the remote refspec for the public overlay logging.info('git fetch %s %s:%s', remote, remote_ref, local_branch) git.RunGit(pub_overlay, ['fetch', remote, '%s:%s' % (remote_ref, local_branch)]) logging.info('git checkout %s', local_branch) git.RunGit(pub_overlay, ['checkout', local_branch]) pub_commit_body = self.ParseGitLog(pub_overlay) commit_message = self.CommitMessage(pub_commit_body, pfq_build, build_number) # Update the commit message and reset author. pub_cid = git.Commit(pub_overlay, commit_message, amend=True, reset_author=True) if not pub_cid: raise Exception( "Don't know the commit ID of the public overlay CL.") # Fetch the remote refspec for the private overlay. logging.info('git fetch %s %s:%s', remote, remote_ref, local_branch) git.RunGit(priv_overlay, ['fetch', remote, '%s:%s' % (remote_ref, local_branch)]) git.RunGit(priv_overlay, ['checkout', local_branch]) logging.info('git checkout %s', local_branch) priv_commit_body = self.ParseGitLog(priv_overlay) # Add CQ-DEPEND commit_message = self.CommitMessage(priv_commit_body, pfq_build, build_number, pub_cid) # Update the commit message and reset author priv_cid = git.Commit(priv_overlay, commit_message, amend=True, reset_author=True) if not priv_cid: raise Exception( "Don't know the commit ID of the private overlay CL.") # Add CQ-DEPEND commit_message = self.CommitMessage(pub_commit_body, pfq_build, build_number, '*' + priv_cid, pub_cid) git.Commit(pub_overlay, commit_message, amend=True) overlays = [(pub_overlay, PUB_OVERLAY_URL), (priv_overlay, PRIV_OVERLAY_URL)] for (_overlay, _overlay_url) in overlays: logging.info('git pull --rebase %s %s', remote, MASTER_BRANCH) git.RunGit(_overlay, ['pull', '--rebase', remote, MASTER_BRANCH]) logging.info('Upload CLs to Gerrit.') git.UploadCL(_overlay, _overlay_url, MASTER_BRANCH, skip=self.options.dry_run, draft=self.options.draft, debug_level=logging.NOTICE, reviewers=reviewers) print('Please review and submit the CLs together from Gerrit.') print('Successfully run cros uprevchrome!')