diff --git a/gitc_utils.py b/gitc_utils.py index d082c8d7..04307a3c 100644 --- a/gitc_utils.py +++ b/gitc_utils.py @@ -15,6 +15,8 @@ from __future__ import print_function import os +import platform +import re import sys import time @@ -22,6 +24,7 @@ import git_command import git_config import wrapper +from manifest_xml import GitcManifest GITC_FS_ROOT_DIR = '/gitc/manifest-rw/' NUM_BATCH_RETRIEVE_REVISIONID = 300 @@ -65,26 +68,86 @@ def _set_project_revisions(projects): sys.exit(1) proj.revisionExpr = gitcmd.stdout.split('\t')[0] -def generate_gitc_manifest(client_dir, manifest, projects=None): +def _manifest_groups(manifest): + """Returns the manifest group string that should be synced + + This is the same logic used by Command.GetProjects(), which is used during + repo sync + + @param manifest: The XmlManifest object + """ + mp = manifest.manifestProject + groups = mp.config.GetString('manifest.groups') + if not groups: + groups = 'default,platform-' + platform.system().lower() + return groups + +def generate_gitc_manifest(repodir, client_name, gitc_manifest, repo_manifest_file, paths=None): """Generate a manifest for shafsd to use for this GITC client. - @param client_dir: GITC client directory to install the .manifest file in. - @param manifest: XmlManifest object representing the repo manifest. - @param projects: List of projects we want to update, this must be a sublist - of manifest.projects to work properly. If not provided, - manifest.projects is used. + @param repodir: The repo directory + @param client_name: The gitc client name + @param gitc_manifest: Current gitc manifest, or None if there isn't one yet + @param repo_manifest_file: The file used by the main repo manifest + @param paths: List of project paths we want to update. """ + manifest = GitcManifest(repodir, client_name) + manifest.Override(repo_manifest_file) + print('Generating GITC Manifest by fetching revision SHAs for each ' 'project.') - if projects is None: - projects = manifest.projects + if paths is None: + paths = manifest.paths.keys() + + groups = [x for x in re.split(r'[,\s]+', _manifest_groups(manifest)) if x] + + # Convert the paths to projects, and filter them to the matched groups. + projects = [manifest.paths[p] for p in paths] + projects = [p for p in projects if p.MatchesGroups(groups)] + + if gitc_manifest is not None: + for path, proj in manifest.paths.iteritems(): + if not proj.MatchesGroups(groups): + continue + + if not proj.upstream and not git_config.IsId(proj.revisionExpr): + proj.upstream = proj.revisionExpr + + if not path in gitc_manifest.paths: + # Any new projects need their first revision, even if we weren't asked + # for them. + projects.append(proj) + elif not path in paths: + # And copy revisions from the previous manifest if we're not updating + # them now. + gitc_proj = gitc_manifest.paths[path] + if gitc_proj.old_revision: + proj.revisionExpr = None + proj.old_revision = gitc_proj.old_revision + else: + proj.revisionExpr = gitc_proj.revisionExpr + index = 0 while index < len(projects): _set_project_revisions( projects[index:(index+NUM_BATCH_RETRIEVE_REVISIONID)]) index += NUM_BATCH_RETRIEVE_REVISIONID + + if gitc_manifest is not None: + for path, proj in gitc_manifest.paths.iteritems(): + if proj.old_revision and path in paths: + # If we updated a project that has been started, keep the old-revision + # updated. + repo_proj = manifest.paths[path] + repo_proj.old_revision = repo_proj.revisionExpr + repo_proj.revisionExpr = None + + # Convert URLs from relative to absolute. + for name, remote in manifest.remotes.iteritems(): + remote.fetchUrl = remote.resolvedFetchUrl + # Save the manifest. - save_manifest(manifest, client_dir=client_dir) + save_manifest(manifest) def save_manifest(manifest, client_dir=None): """Save the manifest file in the client_dir. @@ -95,7 +158,7 @@ def save_manifest(manifest, client_dir=None): if not client_dir: client_dir = manifest.gitc_client_dir with open(os.path.join(client_dir, '.manifest'), 'w') as f: - manifest.Save(f) + manifest.Save(f, groups=_manifest_groups(manifest)) # TODO(sbasi/jorg): Come up with a solution to remove the sleep below. # Give the GITC filesystem time to register the manifest changes. - time.sleep(3) \ No newline at end of file + time.sleep(3) diff --git a/manifest_xml.py b/manifest_xml.py index a7fe8ddf..3ac607ec 100644 --- a/manifest_xml.py +++ b/manifest_xml.py @@ -167,12 +167,13 @@ class XmlManifest(object): def _ParseGroups(self, groups): return [x for x in re.split(r'[,\s]+', groups) if x] - def Save(self, fd, peg_rev=False, peg_rev_upstream=True): + def Save(self, fd, peg_rev=False, peg_rev_upstream=True, groups=None): """Write the current manifest out to the given file descriptor. """ mp = self.manifestProject - groups = mp.config.GetString('manifest.groups') + if groups is None: + groups = mp.config.GetString('manifest.groups') if groups: groups = self._ParseGroups(groups) diff --git a/subcmds/gitc_init.py b/subcmds/gitc_init.py index e99affa5..c957a9dc 100644 --- a/subcmds/gitc_init.py +++ b/subcmds/gitc_init.py @@ -68,15 +68,13 @@ use for this GITC client. os.mkdir(self.client_dir) super(GitcInit, self).Execute(opt, args) - for name, remote in self.manifest.remotes.iteritems(): - remote.fetchUrl = remote.resolvedFetchUrl - + manifest_file = self.manifest.manifestFile if opt.manifest_file: if not os.path.exists(opt.manifest_file): print('fatal: Specified manifest file %s does not exist.' % opt.manifest_file) sys.exit(1) - self.manifest.Override(opt.manifest_file) - gitc_utils.generate_gitc_manifest(self.client_dir, self.manifest) + manifest_file = opt.manifest_file + gitc_utils.generate_gitc_manifest(self.repodir, opt.gitc_client, None, manifest_file) print('Please run `cd %s` to view your GITC client.' % os.path.join(gitc_utils.GITC_FS_ROOT_DIR, opt.gitc_client)) diff --git a/subcmds/start.py b/subcmds/start.py index 188fd7c6..940c3413 100644 --- a/subcmds/start.py +++ b/subcmds/start.py @@ -57,7 +57,6 @@ revision specified in the manifest. print("error: at least one project must be specified", file=sys.stderr) sys.exit(1) - proj_name_to_gitc_proj_dict = {} if self.gitc_manifest: all_projects = self.GetProjects(projects, manifest=self.gitc_manifest, missing_ok=True) @@ -67,7 +66,6 @@ revision specified in the manifest. else: project.already_synced = False project.old_revision = project.revisionExpr - proj_name_to_gitc_proj_dict[project.name] = project project.revisionExpr = None # Save the GITC manifest. gitc_utils.save_manifest(self.gitc_manifest) @@ -77,9 +75,10 @@ revision specified in the manifest. pm = Progress('Starting %s' % nb, len(all_projects)) for project in all_projects: pm.update() + if self.gitc_manifest: - gitc_project = proj_name_to_gitc_proj_dict[project.name] - # Sync projects that have already been opened. + gitc_project = self.gitc_manifest.paths[project.relpath] + # Sync projects that have not been opened. if not gitc_project.already_synced: proj_localdir = os.path.join(self.gitc_manifest.gitc_client_dir, project.relpath) @@ -89,7 +88,7 @@ revision specified in the manifest. project.Sync_NetworkHalf() sync_buf = SyncBuffer(self.manifest.manifestProject.config) project.Sync_LocalHalf(sync_buf) - project.revisionExpr = gitc_project.old_revision + project.revisionId = gitc_project.old_revision # If the current revision is a specific SHA1 then we can't push back # to it; so substitute with dest_branch if defined, or with manifest @@ -100,6 +99,7 @@ revision specified in the manifest. branch_merge = project.dest_branch else: branch_merge = self.manifest.default.revisionExpr + if not project.StartBranch(nb, branch_merge=branch_merge): err.append(project) pm.end() diff --git a/subcmds/sync.py b/subcmds/sync.py index 7b44dbd8..79cfaaa5 100644 --- a/subcmds/sync.py +++ b/subcmds/sync.py @@ -670,32 +670,36 @@ later is required to fix a server side protocol bug. if opt.jobs is None: self.jobs = self.manifest.default.sync_j - # TODO (sbasi) - Add support for manifest changes, aka projects - # have been added or deleted from the manifest. if self.gitc_manifest: gitc_manifest_projects = self.GetProjects(args, - manifest=self.gitc_manifest, missing_ok=True) gitc_projects = [] opened_projects = [] for project in gitc_manifest_projects: - if not project.old_revision: - gitc_projects.append(project) + if project.relpath in self.gitc_manifest.paths and \ + self.gitc_manifest.paths[project.relpath].old_revision: + opened_projects.append(project.relpath) else: - opened_projects.append(project) + gitc_projects.append(project.relpath) - if gitc_projects and not opt.local_only: + if not args: + gitc_projects = None + + if gitc_projects != [] and not opt.local_only: print('Updating GITC client: %s' % self.gitc_manifest.gitc_client_name) - gitc_utils.generate_gitc_manifest(self.gitc_manifest.gitc_client_dir, + gitc_utils.generate_gitc_manifest(self.repodir, + self.gitc_manifest.gitc_client_name, self.gitc_manifest, + self.manifest.manifestFile, gitc_projects) print('GITC client successfully synced.') # The opened projects need to be synced as normal, therefore we # generate a new args list to represent the opened projects. - args = [] - for proj in opened_projects: - args.append(os.path.relpath(proj.worktree, os.getcwd())) + # TODO: make this more reliable -- if there's a project name/path overlap, + # this may choose the wrong project. + args = [os.path.relpath(self.manifest.paths[p].worktree, os.getcwd()) + for p in opened_projects] if not args: return all_projects = self.GetProjects(args,