# Copyright (C) 2008 The Android Open Source Project # # Licensed under the Apache License, Version 2.0 (the "License"); # you may not use this file except in compliance with the License. # You may obtain a copy of the License at # # http://www.apache.org/licenses/LICENSE-2.0 # # Unless required by applicable law or agreed to in writing, software # distributed under the License is distributed on an "AS IS" BASIS, # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. # See the License for the specific language governing permissions and # limitations under the License. import os import sys from color import Coloring from command import InteractiveCommand, MirrorSafeCommand from git_command import git_require, MIN_GIT_VERSION_SOFT, MIN_GIT_VERSION_HARD from wrapper import Wrapper class Init(InteractiveCommand, MirrorSafeCommand): COMMON = True MULTI_MANIFEST_SUPPORT = True helpSummary = "Initialize a repo client checkout in the current directory" helpUsage = """ %prog [options] [manifest url] """ helpDescription = """ The '%prog' command is run once to install and initialize repo. The latest repo source code and manifest collection is downloaded from the server and is installed in the .repo/ directory in the current working directory. When creating a new checkout, the manifest URL is the only required setting. It may be specified using the --manifest-url option, or as the first optional argument. The optional -b argument can be used to select the manifest branch to checkout and use. If no branch is specified, the remote's default branch is used. This is equivalent to using -b HEAD. The optional -m argument can be used to specify an alternate manifest to be used. If no manifest is specified, the manifest default.xml will be used. If the --standalone-manifest argument is set, the manifest will be downloaded directly from the specified --manifest-url as a static file (rather than setting up a manifest git checkout). With --standalone-manifest, the manifest will be fully static and will not be re-downloaded during subsesquent `repo init` and `repo sync` calls. The --reference option can be used to point to a directory that has the content of a --mirror sync. This will make the working directory use as much data as possible from the local reference directory when fetching from the server. This will make the sync go a lot faster by reducing data traffic on the network. The --dissociate option can be used to borrow the objects from the directory specified with the --reference option only to reduce network transfer, and stop borrowing from them after a first clone is made by making necessary local copies of borrowed objects. The --no-clone-bundle option disables any attempt to use $URL/clone.bundle to bootstrap a new Git repository from a resumeable bundle file on a content delivery network. This may be necessary if there are problems with the local Python HTTP client or proxy configuration, but the Git binary works. # Switching Manifest Branches To switch to another manifest branch, `repo init -b otherbranch` may be used in an existing client. However, as this only updates the manifest, a subsequent `repo sync` (or `repo sync -d`) is necessary to update the working directory files. """ def _CommonOptions(self, p): """Disable due to re-use of Wrapper().""" def _Options(self, p, gitc_init=False): Wrapper().InitParser(p, gitc_init=gitc_init) m = p.add_option_group('Multi-manifest') m.add_option('--outer-manifest', action='store_true', default=True, help='operate starting at the outermost manifest') m.add_option('--no-outer-manifest', dest='outer_manifest', action='store_false', help='do not operate on outer manifests') m.add_option('--this-manifest-only', action='store_true', default=None, help='only operate on this (sub)manifest') m.add_option('--no-this-manifest-only', '--all-manifests', dest='this_manifest_only', action='store_false', help='operate on this manifest and its submanifests') def _RegisteredEnvironmentOptions(self): return {'REPO_MANIFEST_URL': 'manifest_url', 'REPO_MIRROR_LOCATION': 'reference'} def _SyncManifest(self, opt): """Call manifestProject.Sync with arguments from opt. Args: opt: options from optparse. """ # Normally this value is set when instantiating the project, but the # manifest project is special and is created when instantiating the # manifest which happens before we parse options. self.manifest.manifestProject.clone_depth = opt.manifest_depth if not self.manifest.manifestProject.Sync( manifest_url=opt.manifest_url, manifest_branch=opt.manifest_branch, standalone_manifest=opt.standalone_manifest, groups=opt.groups, platform=opt.platform, mirror=opt.mirror, dissociate=opt.dissociate, reference=opt.reference, worktree=opt.worktree, submodules=opt.submodules, archive=opt.archive, partial_clone=opt.partial_clone, clone_filter=opt.clone_filter, partial_clone_exclude=opt.partial_clone_exclude, clone_bundle=opt.clone_bundle, git_lfs=opt.git_lfs, use_superproject=opt.use_superproject, verbose=opt.verbose, current_branch_only=opt.current_branch_only, tags=opt.tags, depth=opt.depth, git_event_log=self.git_event_log, manifest_name=opt.manifest_name): sys.exit(1) def _Prompt(self, prompt, value): print('%-10s [%s]: ' % (prompt, value), end='', flush=True) a = sys.stdin.readline().strip() if a == '': return value return a def _ShouldConfigureUser(self, opt, existing_checkout): gc = self.client.globalConfig mp = self.manifest.manifestProject # If we don't have local settings, get from global. if not mp.config.Has('user.name') or not mp.config.Has('user.email'): if not gc.Has('user.name') or not gc.Has('user.email'): return True mp.config.SetString('user.name', gc.GetString('user.name')) mp.config.SetString('user.email', gc.GetString('user.email')) if not opt.quiet and not existing_checkout or opt.verbose: print() print('Your identity is: %s <%s>' % (mp.config.GetString('user.name'), mp.config.GetString('user.email'))) print("If you want to change this, please re-run 'repo init' with --config-name") return False def _ConfigureUser(self, opt): mp = self.manifest.manifestProject while True: if not opt.quiet: print() name = self._Prompt('Your Name', mp.UserName) email = self._Prompt('Your Email', mp.UserEmail) if not opt.quiet: print() print('Your identity is: %s <%s>' % (name, email)) print('is this correct [y/N]? ', end='', flush=True) a = sys.stdin.readline().strip().lower() if a in ('yes', 'y', 't', 'true'): break if name != mp.UserName: mp.config.SetString('user.name', name) if email != mp.UserEmail: mp.config.SetString('user.email', email) def _HasColorSet(self, gc): for n in ['ui', 'diff', 'status']: if gc.Has('color.%s' % n): return True return False def _ConfigureColor(self): gc = self.client.globalConfig if self._HasColorSet(gc): return class _Test(Coloring): def __init__(self): Coloring.__init__(self, gc, 'test color display') self._on = True out = _Test() print() print("Testing colorized output (for 'repo diff', 'repo status'):") for c in ['black', 'red', 'green', 'yellow', 'blue', 'magenta', 'cyan']: out.write(' ') out.printer(fg=c)(' %-6s ', c) out.write(' ') out.printer(fg='white', bg='black')(' %s ' % 'white') out.nl() for c in ['bold', 'dim', 'ul', 'reverse']: out.write(' ') out.printer(fg='black', attr=c)(' %-6s ', c) out.nl() print('Enable color display in this user account (y/N)? ', end='', flush=True) a = sys.stdin.readline().strip().lower() if a in ('y', 'yes', 't', 'true', 'on'): gc.SetString('color.ui', 'auto') def _DisplayResult(self): if self.manifest.IsMirror: init_type = 'mirror ' else: init_type = '' print() print('repo %shas been initialized in %s' % (init_type, self.manifest.topdir)) current_dir = os.getcwd() if current_dir != self.manifest.topdir: print('If this is not the directory in which you want to initialize ' 'repo, please run:') print(' rm -r %s' % os.path.join(self.manifest.topdir, '.repo')) print('and try again.') def ValidateOptions(self, opt, args): if opt.reference: opt.reference = os.path.expanduser(opt.reference) # Check this here, else manifest will be tagged "not new" and init won't be # possible anymore without removing the .repo/manifests directory. if opt.mirror: if opt.archive: self.OptionParser.error('--mirror and --archive cannot be used ' 'together.') if opt.use_superproject is not None: self.OptionParser.error('--mirror and --use-superproject cannot be ' 'used together.') if opt.archive and opt.use_superproject is not None: self.OptionParser.error('--archive and --use-superproject cannot be used ' 'together.') if opt.standalone_manifest and (opt.manifest_branch or opt.manifest_name != 'default.xml'): self.OptionParser.error('--manifest-branch and --manifest-name cannot' ' be used with --standalone-manifest.') if args: if opt.manifest_url: self.OptionParser.error( '--manifest-url option and URL argument both specified: only use ' 'one to select the manifest URL.') opt.manifest_url = args.pop(0) if args: self.OptionParser.error('too many arguments to init') def Execute(self, opt, args): git_require(MIN_GIT_VERSION_HARD, fail=True) if not git_require(MIN_GIT_VERSION_SOFT): print('repo: warning: git-%s+ will soon be required; please upgrade your ' 'version of git to maintain support.' % ('.'.join(str(x) for x in MIN_GIT_VERSION_SOFT),), file=sys.stderr) rp = self.manifest.repoProject # Handle new --repo-url requests. if opt.repo_url: remote = rp.GetRemote('origin') remote.url = opt.repo_url remote.Save() # Handle new --repo-rev requests. if opt.repo_rev: wrapper = Wrapper() try: remote_ref, rev = wrapper.check_repo_rev( rp.gitdir, opt.repo_rev, repo_verify=opt.repo_verify, quiet=opt.quiet) except wrapper.CloneFailure: print('fatal: double check your --repo-rev setting.', file=sys.stderr) sys.exit(1) branch = rp.GetBranch('default') branch.merge = remote_ref rp.work_git.reset('--hard', rev) branch.Save() if opt.worktree: # Older versions of git supported worktree, but had dangerous gc bugs. git_require((2, 15, 0), fail=True, msg='git gc worktree corruption') # Provide a short notice that we're reinitializing an existing checkout. # Sometimes developers might not realize that they're in one, or that # repo doesn't do nested checkouts. existing_checkout = self.manifest.manifestProject.Exists if not opt.quiet and existing_checkout: print('repo: reusing existing repo client checkout in', self.manifest.topdir) self._SyncManifest(opt) if os.isatty(0) and os.isatty(1) and not self.manifest.IsMirror: if opt.config_name or self._ShouldConfigureUser(opt, existing_checkout): self._ConfigureUser(opt) self._ConfigureColor() if not opt.quiet: self._DisplayResult()