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 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 Commit(self, file_paths, commit_msg):
"""Commits files listed in |file_paths|.
Args:
file_paths: List of files to commit.
commit_msg: Message to use in commit.
"""
assert file_paths and isinstance(file_paths, list)
# Make paths absolute and ensure they exist.
for i, file_path in enumerate(file_paths):
if not os.path.isabs(file_path):
file_paths[i] = self.FullPath(file_path)
if not os.path.exists(file_paths[i]):
raise CommitError('Invalid path: %s' % file_paths[i])
self._commit_msg = 'Automated Commit: ' + commit_msg
try:
for file_path in file_paths:
git.AddPath(file_path)
commit_args = ['commit', '-m', self._commit_msg]
git.RunGit(self._checkout_dir,
self._git_committer_args + commit_args,
print_cmd=True,
stderr=True,
capture_output=False)
except cros_build_lib.RunCommandError as e:
raise CommitError('Could not create git commit: %r' % e)
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 MaskNewerPackages(overlay, ebuilds):
"""Mask ebuild versions newer than the ones passed in.
This creates a new mask file called chromepin which masks ebuilds newer than
the ones passed in. To undo the masking, just delete that file. The
mask file is added with git.
Args:
overlay: The overlay that will hold the mask file.
ebuilds: List of ebuilds to set up masks for.
"""
content = '# Pin chrome by masking more recent versions.\n'
for ebuild in ebuilds:
parts = portage_util.SplitEbuildPath(ebuild)
content += '>%s\n' % os.path.join(parts[0], parts[2])
mask_file = os.path.join(overlay, MASK_FILE)
osutils.WriteFile(mask_file, content)
git.AddPath(mask_file)
def RevertStableEBuild(dirname, rev):
"""Revert the stable ebuilds for a package back to a particular revision.
Also add/remove the files in git.
Args:
dirname: Path to the ebuild directory.
rev: Revision to revert back to.
Returns:
The name of the ebuild reverted to.
"""
package = os.path.basename(dirname.rstrip(os.sep))
pattern = '%s-*.ebuild' % package
# Get rid of existing stable ebuilds.
ebuilds = glob.glob(os.path.join(dirname, pattern))
for ebuild in ebuilds:
parts = SplitPVPath(ebuild)
if parts.version != '9999':
git.RmPath(ebuild)
# Bring back the old stable ebuild.
names = git.GetObjectAtRev(dirname, './', rev).split()
names = fnmatch.filter(names, pattern)
names = [
name for name in names
if SplitPVPath(os.path.join(dirname, name)).version != '9999'
]
if not names:
return None
assert len(names) == 1
name = names[0]
git.RevertPath(dirname, name, rev)
# Update the manifest.
UpdateManifest(os.path.join(dirname, name))
manifest_path = os.path.join(dirname, 'Manifest')
if os.path.exists(manifest_path):
git.AddPath(manifest_path)
return os.path.join(dirname, name)
def testAddPath(self):
git.AddPath(self.fake_path)
self.assertCommandContains(['add'])
self.assertCommandContains([self.fake_file])
