The Android Open Source Project | cf31fe9 | 2008-10-21 07:00:00 -0700 | [diff] [blame] | 1 | # |
| 2 | # Copyright (C) 2008 The Android Open Source Project |
| 3 | # |
| 4 | # Licensed under the Apache License, Version 2.0 (the "License"); |
| 5 | # you may not use this file except in compliance with the License. |
| 6 | # You may obtain a copy of the License at |
| 7 | # |
| 8 | # http://www.apache.org/licenses/LICENSE-2.0 |
| 9 | # |
| 10 | # Unless required by applicable law or agreed to in writing, software |
| 11 | # distributed under the License is distributed on an "AS IS" BASIS, |
| 12 | # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |
| 13 | # See the License for the specific language governing permissions and |
| 14 | # limitations under the License. |
| 15 | |
Sarah Owens | cecd1d8 | 2012-11-01 22:59:27 -0700 | [diff] [blame] | 16 | from __future__ import print_function |
David Pursehouse | 86d973d | 2012-08-24 10:21:02 +0900 | [diff] [blame] | 17 | import netrc |
Shawn O. Pearce | 2a1ccb2 | 2009-04-10 16:51:53 -0700 | [diff] [blame] | 18 | from optparse import SUPPRESS_HELP |
The Android Open Source Project | cf31fe9 | 2008-10-21 07:00:00 -0700 | [diff] [blame] | 19 | import os |
Dave Borowitz | 67700e9 | 2012-10-23 15:00:54 -0700 | [diff] [blame] | 20 | import pickle |
The Android Open Source Project | cf31fe9 | 2008-10-21 07:00:00 -0700 | [diff] [blame] | 21 | import re |
Jaikumar Ganesh | 4f2517f | 2009-06-01 21:10:33 -0700 | [diff] [blame] | 22 | import shutil |
Nico Sallembien | a1bfd2c | 2010-04-06 10:40:01 -0700 | [diff] [blame] | 23 | import socket |
The Android Open Source Project | cf31fe9 | 2008-10-21 07:00:00 -0700 | [diff] [blame] | 24 | import subprocess |
| 25 | import sys |
Shawn O. Pearce | f690687 | 2009-04-18 10:49:00 -0700 | [diff] [blame] | 26 | import time |
David Pursehouse | 86d973d | 2012-08-24 10:21:02 +0900 | [diff] [blame] | 27 | import urlparse |
Nico Sallembien | a1bfd2c | 2010-04-06 10:40:01 -0700 | [diff] [blame] | 28 | import xmlrpclib |
The Android Open Source Project | cf31fe9 | 2008-10-21 07:00:00 -0700 | [diff] [blame] | 29 | |
Roy Lee | 18afd7f | 2010-05-09 04:32:08 +0800 | [diff] [blame] | 30 | try: |
| 31 | import threading as _threading |
| 32 | except ImportError: |
| 33 | import dummy_threading as _threading |
| 34 | |
Shawn O. Pearce | 97d2b2f | 2011-09-22 17:23:41 -0700 | [diff] [blame] | 35 | try: |
| 36 | import resource |
| 37 | def _rlimit_nofile(): |
| 38 | return resource.getrlimit(resource.RLIMIT_NOFILE) |
| 39 | except ImportError: |
| 40 | def _rlimit_nofile(): |
| 41 | return (256, 256) |
| 42 | |
Dave Borowitz | 1885721 | 2012-10-23 17:02:59 -0700 | [diff] [blame] | 43 | try: |
| 44 | import multiprocessing |
| 45 | except ImportError: |
| 46 | multiprocessing = None |
| 47 | |
Dave Borowitz | e215267 | 2012-10-31 12:24:38 -0700 | [diff] [blame] | 48 | from git_command import GIT, git_require |
David Pursehouse | d94aaef | 2012-09-07 09:52:04 +0900 | [diff] [blame] | 49 | from git_refs import R_HEADS, HEAD |
Conley Owens | c9129d9 | 2012-10-01 16:12:28 -0700 | [diff] [blame] | 50 | from main import WrapperModule |
Jaikumar Ganesh | 4f2517f | 2009-06-01 21:10:33 -0700 | [diff] [blame] | 51 | from project import Project |
| 52 | from project import RemoteSpec |
Shawn O. Pearce | c95583b | 2009-03-03 17:47:06 -0800 | [diff] [blame] | 53 | from command import Command, MirrorSafeCommand |
Torne (Richard Coles) | 7bdbde7 | 2012-12-05 10:58:06 +0000 | [diff] [blame] | 54 | from error import RepoChangedException, GitError, ManifestParseError |
Shawn O. Pearce | 350cde4 | 2009-04-16 11:21:18 -0700 | [diff] [blame] | 55 | from project import SyncBuffer |
Shawn O. Pearce | 68194f4 | 2009-04-10 16:48:52 -0700 | [diff] [blame] | 56 | from progress import Progress |
The Android Open Source Project | cf31fe9 | 2008-10-21 07:00:00 -0700 | [diff] [blame] | 57 | |
Dave Borowitz | 67700e9 | 2012-10-23 15:00:54 -0700 | [diff] [blame] | 58 | _ONE_DAY_S = 24 * 60 * 60 |
| 59 | |
Doug Anderson | fc06ced | 2011-03-16 15:49:18 -0700 | [diff] [blame] | 60 | class _FetchError(Exception): |
| 61 | """Internal error thrown in _FetchHelper() when we don't want stack trace.""" |
| 62 | pass |
| 63 | |
Shawn O. Pearce | c95583b | 2009-03-03 17:47:06 -0800 | [diff] [blame] | 64 | class Sync(Command, MirrorSafeCommand): |
Roy Lee | 18afd7f | 2010-05-09 04:32:08 +0800 | [diff] [blame] | 65 | jobs = 1 |
The Android Open Source Project | cf31fe9 | 2008-10-21 07:00:00 -0700 | [diff] [blame] | 66 | common = True |
| 67 | helpSummary = "Update working tree to the latest revision" |
| 68 | helpUsage = """ |
| 69 | %prog [<project>...] |
| 70 | """ |
| 71 | helpDescription = """ |
| 72 | The '%prog' command synchronizes local project directories |
| 73 | with the remote repositories specified in the manifest. If a local |
| 74 | project does not yet exist, it will clone a new local directory from |
| 75 | the remote repository and set up tracking branches as specified in |
| 76 | the manifest. If the local project already exists, '%prog' |
| 77 | will update the remote branches and rebase any new local changes |
| 78 | on top of the new remote changes. |
| 79 | |
| 80 | '%prog' will synchronize all projects listed at the command |
| 81 | line. Projects can be specified either by name, or by a relative |
| 82 | or absolute path to the project's local directory. If no projects |
| 83 | are specified, '%prog' will synchronize all projects listed in |
| 84 | the manifest. |
Shawn O. Pearce | 3e768c9 | 2009-04-10 16:59:36 -0700 | [diff] [blame] | 85 | |
| 86 | The -d/--detach option can be used to switch specified projects |
| 87 | back to the manifest revision. This option is especially helpful |
| 88 | if the project is currently on a topic branch, but the manifest |
| 89 | revision is temporarily needed. |
Shawn O. Pearce | eb7af87 | 2009-04-21 08:02:04 -0700 | [diff] [blame] | 90 | |
Nico Sallembien | a1bfd2c | 2010-04-06 10:40:01 -0700 | [diff] [blame] | 91 | The -s/--smart-sync option can be used to sync to a known good |
| 92 | build as specified by the manifest-server element in the current |
Victor Boivie | 08c880d | 2011-04-19 10:32:52 +0200 | [diff] [blame] | 93 | manifest. The -t/--smart-tag option is similar and allows you to |
| 94 | specify a custom tag/label. |
Nico Sallembien | a1bfd2c | 2010-04-06 10:40:01 -0700 | [diff] [blame] | 95 | |
David Pursehouse | cf76b1b | 2012-09-14 10:31:42 +0900 | [diff] [blame] | 96 | The -u/--manifest-server-username and -p/--manifest-server-password |
| 97 | options can be used to specify a username and password to authenticate |
| 98 | with the manifest server when using the -s or -t option. |
| 99 | |
| 100 | If -u and -p are not specified when using the -s or -t option, '%prog' |
| 101 | will attempt to read authentication credentials for the manifest server |
| 102 | from the user's .netrc file. |
| 103 | |
| 104 | '%prog' will not use authentication credentials from -u/-p or .netrc |
| 105 | if the manifest server specified in the manifest file already includes |
| 106 | credentials. |
| 107 | |
Andrei Warkentin | 5df6de0 | 2010-07-02 17:58:31 -0500 | [diff] [blame] | 108 | The -f/--force-broken option can be used to proceed with syncing |
| 109 | other projects if a project sync fails. |
| 110 | |
Shawn O. Pearce | e02ac0a | 2012-03-14 15:36:59 -0700 | [diff] [blame] | 111 | The --no-clone-bundle option disables any attempt to use |
| 112 | $URL/clone.bundle to bootstrap a new Git repository from a |
| 113 | resumeable bundle file on a content delivery network. This |
| 114 | may be necessary if there are problems with the local Python |
| 115 | HTTP client or proxy configuration, but the Git binary works. |
| 116 | |
Che-Liang Chiou | b2bd91c | 2012-01-11 11:28:42 +0800 | [diff] [blame] | 117 | The --fetch-submodules option enables fetching Git submodules |
| 118 | of a project from server. |
| 119 | |
Shawn O. Pearce | eb7af87 | 2009-04-21 08:02:04 -0700 | [diff] [blame] | 120 | SSH Connections |
| 121 | --------------- |
| 122 | |
| 123 | If at least one project remote URL uses an SSH connection (ssh://, |
| 124 | git+ssh://, or user@host:path syntax) repo will automatically |
| 125 | enable the SSH ControlMaster option when connecting to that host. |
| 126 | This feature permits other projects in the same '%prog' session to |
| 127 | reuse the same SSH tunnel, saving connection setup overheads. |
| 128 | |
| 129 | To disable this behavior on UNIX platforms, set the GIT_SSH |
| 130 | environment variable to 'ssh'. For example: |
| 131 | |
| 132 | export GIT_SSH=ssh |
| 133 | %prog |
| 134 | |
| 135 | Compatibility |
| 136 | ~~~~~~~~~~~~~ |
| 137 | |
| 138 | This feature is automatically disabled on Windows, due to the lack |
| 139 | of UNIX domain socket support. |
| 140 | |
| 141 | This feature is not compatible with url.insteadof rewrites in the |
| 142 | user's ~/.gitconfig. '%prog' is currently not able to perform the |
| 143 | rewrite early enough to establish the ControlMaster tunnel. |
| 144 | |
| 145 | If the remote SSH daemon is Gerrit Code Review, version 2.0.10 or |
| 146 | later is required to fix a server side protocol bug. |
| 147 | |
The Android Open Source Project | cf31fe9 | 2008-10-21 07:00:00 -0700 | [diff] [blame] | 148 | """ |
| 149 | |
Nico Sallembien | 6623b21 | 2010-05-11 12:57:01 -0700 | [diff] [blame] | 150 | def _Options(self, p, show_smart=True): |
Torne (Richard Coles) | 7bdbde7 | 2012-12-05 10:58:06 +0000 | [diff] [blame] | 151 | try: |
| 152 | self.jobs = self.manifest.default.sync_j |
| 153 | except ManifestParseError: |
| 154 | self.jobs = 1 |
Shawn O. Pearce | 6392c87 | 2011-09-22 17:44:31 -0700 | [diff] [blame] | 155 | |
Andrei Warkentin | 5df6de0 | 2010-07-02 17:58:31 -0500 | [diff] [blame] | 156 | p.add_option('-f', '--force-broken', |
| 157 | dest='force_broken', action='store_true', |
| 158 | help="continue sync even if a project fails to sync") |
David Pursehouse | 8f62fb7 | 2012-11-14 12:09:38 +0900 | [diff] [blame] | 159 | p.add_option('-l', '--local-only', |
Shawn O. Pearce | b1562fa | 2009-04-10 17:04:08 -0700 | [diff] [blame] | 160 | dest='local_only', action='store_true', |
| 161 | help="only update working tree, don't fetch") |
David Pursehouse | 8f62fb7 | 2012-11-14 12:09:38 +0900 | [diff] [blame] | 162 | p.add_option('-n', '--network-only', |
Shawn O. Pearce | 96fdcef | 2009-04-10 16:29:20 -0700 | [diff] [blame] | 163 | dest='network_only', action='store_true', |
| 164 | help="fetch only, don't update working tree") |
David Pursehouse | 8f62fb7 | 2012-11-14 12:09:38 +0900 | [diff] [blame] | 165 | p.add_option('-d', '--detach', |
Shawn O. Pearce | 3e768c9 | 2009-04-10 16:59:36 -0700 | [diff] [blame] | 166 | dest='detach_head', action='store_true', |
| 167 | help='detach projects back to manifest revision') |
David Pursehouse | 8f62fb7 | 2012-11-14 12:09:38 +0900 | [diff] [blame] | 168 | p.add_option('-c', '--current-branch', |
Anatol Pomazau | 53d6f4d | 2011-08-25 17:21:47 -0700 | [diff] [blame] | 169 | dest='current_branch_only', action='store_true', |
| 170 | help='fetch only current branch from server') |
David Pursehouse | 8f62fb7 | 2012-11-14 12:09:38 +0900 | [diff] [blame] | 171 | p.add_option('-q', '--quiet', |
Shawn O. Pearce | 16614f8 | 2010-10-29 12:05:43 -0700 | [diff] [blame] | 172 | dest='quiet', action='store_true', |
| 173 | help='be more quiet') |
David Pursehouse | 8f62fb7 | 2012-11-14 12:09:38 +0900 | [diff] [blame] | 174 | p.add_option('-j', '--jobs', |
Roy Lee | 18afd7f | 2010-05-09 04:32:08 +0800 | [diff] [blame] | 175 | dest='jobs', action='store', type='int', |
Shawn O. Pearce | 6392c87 | 2011-09-22 17:44:31 -0700 | [diff] [blame] | 176 | help="projects to fetch simultaneously (default %d)" % self.jobs) |
Chris Wolfe | e9dc3b3 | 2012-01-26 11:36:18 -0500 | [diff] [blame] | 177 | p.add_option('-m', '--manifest-name', |
| 178 | dest='manifest_name', |
| 179 | help='temporary manifest to use for this sync', metavar='NAME.xml') |
Shawn O. Pearce | e02ac0a | 2012-03-14 15:36:59 -0700 | [diff] [blame] | 180 | p.add_option('--no-clone-bundle', |
| 181 | dest='no_clone_bundle', action='store_true', |
| 182 | help='disable use of /clone.bundle on HTTP/HTTPS') |
Conley Owens | 8d070cf | 2012-11-06 13:14:31 -0800 | [diff] [blame] | 183 | p.add_option('-u', '--manifest-server-username', action='store', |
| 184 | dest='manifest_server_username', |
| 185 | help='username to authenticate with the manifest server') |
| 186 | p.add_option('-p', '--manifest-server-password', action='store', |
| 187 | dest='manifest_server_password', |
| 188 | help='password to authenticate with the manifest server') |
Che-Liang Chiou | b2bd91c | 2012-01-11 11:28:42 +0800 | [diff] [blame] | 189 | p.add_option('--fetch-submodules', |
| 190 | dest='fetch_submodules', action='store_true', |
| 191 | help='fetch submodules from server') |
Mitchel Humpherys | 597868b | 2012-10-29 10:18:34 -0700 | [diff] [blame] | 192 | p.add_option('--no-tags', |
| 193 | dest='no_tags', action='store_true', |
| 194 | help="don't fetch tags") |
Nico Sallembien | 6623b21 | 2010-05-11 12:57:01 -0700 | [diff] [blame] | 195 | if show_smart: |
| 196 | p.add_option('-s', '--smart-sync', |
| 197 | dest='smart_sync', action='store_true', |
| 198 | help='smart sync using manifest from a known good build') |
Victor Boivie | 08c880d | 2011-04-19 10:32:52 +0200 | [diff] [blame] | 199 | p.add_option('-t', '--smart-tag', |
| 200 | dest='smart_tag', action='store', |
| 201 | help='smart sync using manifest from a known tag') |
Shawn O. Pearce | 3e768c9 | 2009-04-10 16:59:36 -0700 | [diff] [blame] | 202 | |
Shawn O. Pearce | fd89b67 | 2009-04-18 11:28:57 -0700 | [diff] [blame] | 203 | g = p.add_option_group('repo Version options') |
| 204 | g.add_option('--no-repo-verify', |
The Android Open Source Project | cf31fe9 | 2008-10-21 07:00:00 -0700 | [diff] [blame] | 205 | dest='no_repo_verify', action='store_true', |
| 206 | help='do not verify repo source code') |
Shawn O. Pearce | fd89b67 | 2009-04-18 11:28:57 -0700 | [diff] [blame] | 207 | g.add_option('--repo-upgraded', |
Shawn O. Pearce | c9ef744 | 2008-11-03 10:32:09 -0800 | [diff] [blame] | 208 | dest='repo_upgraded', action='store_true', |
Shawn O. Pearce | 2a1ccb2 | 2009-04-10 16:51:53 -0700 | [diff] [blame] | 209 | help=SUPPRESS_HELP) |
The Android Open Source Project | cf31fe9 | 2008-10-21 07:00:00 -0700 | [diff] [blame] | 210 | |
Doug Anderson | fc06ced | 2011-03-16 15:49:18 -0700 | [diff] [blame] | 211 | def _FetchHelper(self, opt, project, lock, fetched, pm, sem, err_event): |
David Pursehouse | c1b86a2 | 2012-11-14 11:36:51 +0900 | [diff] [blame] | 212 | """Main function of the fetch threads when jobs are > 1. |
Roy Lee | 18afd7f | 2010-05-09 04:32:08 +0800 | [diff] [blame] | 213 | |
David Pursehouse | c1b86a2 | 2012-11-14 11:36:51 +0900 | [diff] [blame] | 214 | Args: |
| 215 | opt: Program options returned from optparse. See _Options(). |
| 216 | project: Project object for the project to fetch. |
| 217 | lock: Lock for accessing objects that are shared amongst multiple |
| 218 | _FetchHelper() threads. |
| 219 | fetched: set object that we will add project.gitdir to when we're done |
| 220 | (with our lock held). |
| 221 | pm: Instance of a Project object. We will call pm.update() (with our |
| 222 | lock held). |
| 223 | sem: We'll release() this semaphore when we exit so that another thread |
| 224 | can be started up. |
| 225 | err_event: We'll set this event in the case of an error (after printing |
| 226 | out info about the error). |
| 227 | """ |
| 228 | # We'll set to true once we've locked the lock. |
| 229 | did_lock = False |
Doug Anderson | fc06ced | 2011-03-16 15:49:18 -0700 | [diff] [blame] | 230 | |
Chirayu Desai | fef4ae7 | 2013-04-12 14:54:32 +0530 | [diff] [blame] | 231 | if not opt.quiet: |
| 232 | print('Fetching project %s' % project.name) |
| 233 | |
David Pursehouse | c1b86a2 | 2012-11-14 11:36:51 +0900 | [diff] [blame] | 234 | # Encapsulate everything in a try/except/finally so that: |
| 235 | # - We always set err_event in the case of an exception. |
| 236 | # - We always make sure we call sem.release(). |
| 237 | # - We always make sure we unlock the lock if we locked it. |
| 238 | try: |
Doug Anderson | fc06ced | 2011-03-16 15:49:18 -0700 | [diff] [blame] | 239 | try: |
David Pursehouse | c1b86a2 | 2012-11-14 11:36:51 +0900 | [diff] [blame] | 240 | start = time.time() |
| 241 | success = project.Sync_NetworkHalf( |
| 242 | quiet=opt.quiet, |
| 243 | current_branch_only=opt.current_branch_only, |
Mitchel Humpherys | 597868b | 2012-10-29 10:18:34 -0700 | [diff] [blame] | 244 | clone_bundle=not opt.no_clone_bundle, |
| 245 | no_tags=opt.no_tags) |
David Pursehouse | c1b86a2 | 2012-11-14 11:36:51 +0900 | [diff] [blame] | 246 | self._fetch_times.Set(project, time.time() - start) |
Doug Anderson | fc06ced | 2011-03-16 15:49:18 -0700 | [diff] [blame] | 247 | |
David Pursehouse | c1b86a2 | 2012-11-14 11:36:51 +0900 | [diff] [blame] | 248 | # Lock around all the rest of the code, since printing, updating a set |
| 249 | # and Progress.update() are not thread safe. |
| 250 | lock.acquire() |
| 251 | did_lock = True |
Doug Anderson | fc06ced | 2011-03-16 15:49:18 -0700 | [diff] [blame] | 252 | |
David Pursehouse | c1b86a2 | 2012-11-14 11:36:51 +0900 | [diff] [blame] | 253 | if not success: |
| 254 | print('error: Cannot fetch %s' % project.name, file=sys.stderr) |
| 255 | if opt.force_broken: |
| 256 | print('warn: --force-broken, continuing to sync', |
| 257 | file=sys.stderr) |
| 258 | else: |
| 259 | raise _FetchError() |
Doug Anderson | fc06ced | 2011-03-16 15:49:18 -0700 | [diff] [blame] | 260 | |
David Pursehouse | c1b86a2 | 2012-11-14 11:36:51 +0900 | [diff] [blame] | 261 | fetched.add(project.gitdir) |
| 262 | pm.update() |
| 263 | except _FetchError: |
| 264 | err_event.set() |
| 265 | except: |
| 266 | err_event.set() |
| 267 | raise |
| 268 | finally: |
| 269 | if did_lock: |
| 270 | lock.release() |
| 271 | sem.release() |
Roy Lee | 18afd7f | 2010-05-09 04:32:08 +0800 | [diff] [blame] | 272 | |
Shawn O. Pearce | 16614f8 | 2010-10-29 12:05:43 -0700 | [diff] [blame] | 273 | def _Fetch(self, projects, opt): |
The Android Open Source Project | cf31fe9 | 2008-10-21 07:00:00 -0700 | [diff] [blame] | 274 | fetched = set() |
Shawn O. Pearce | 68194f4 | 2009-04-10 16:48:52 -0700 | [diff] [blame] | 275 | pm = Progress('Fetching projects', len(projects)) |
Roy Lee | 18afd7f | 2010-05-09 04:32:08 +0800 | [diff] [blame] | 276 | |
| 277 | if self.jobs == 1: |
| 278 | for project in projects: |
| 279 | pm.update() |
Chirayu Desai | fef4ae7 | 2013-04-12 14:54:32 +0530 | [diff] [blame] | 280 | if not opt.quiet: |
| 281 | print('Fetching project %s' % project.name) |
Shawn O. Pearce | 5d0efdb | 2012-08-02 12:13:01 -0700 | [diff] [blame] | 282 | if project.Sync_NetworkHalf( |
| 283 | quiet=opt.quiet, |
| 284 | current_branch_only=opt.current_branch_only, |
Mitchel Humpherys | 597868b | 2012-10-29 10:18:34 -0700 | [diff] [blame] | 285 | clone_bundle=not opt.no_clone_bundle, |
| 286 | no_tags=opt.no_tags): |
Roy Lee | 18afd7f | 2010-05-09 04:32:08 +0800 | [diff] [blame] | 287 | fetched.add(project.gitdir) |
| 288 | else: |
Sarah Owens | cecd1d8 | 2012-11-01 22:59:27 -0700 | [diff] [blame] | 289 | print('error: Cannot fetch %s' % project.name, file=sys.stderr) |
Andrei Warkentin | 5df6de0 | 2010-07-02 17:58:31 -0500 | [diff] [blame] | 290 | if opt.force_broken: |
Sarah Owens | cecd1d8 | 2012-11-01 22:59:27 -0700 | [diff] [blame] | 291 | print('warn: --force-broken, continuing to sync', file=sys.stderr) |
Andrei Warkentin | 5df6de0 | 2010-07-02 17:58:31 -0500 | [diff] [blame] | 292 | else: |
| 293 | sys.exit(1) |
Roy Lee | 18afd7f | 2010-05-09 04:32:08 +0800 | [diff] [blame] | 294 | else: |
| 295 | threads = set() |
| 296 | lock = _threading.Lock() |
| 297 | sem = _threading.Semaphore(self.jobs) |
Doug Anderson | fc06ced | 2011-03-16 15:49:18 -0700 | [diff] [blame] | 298 | err_event = _threading.Event() |
Roy Lee | 18afd7f | 2010-05-09 04:32:08 +0800 | [diff] [blame] | 299 | for project in projects: |
Doug Anderson | fc06ced | 2011-03-16 15:49:18 -0700 | [diff] [blame] | 300 | # Check for any errors before starting any new threads. |
| 301 | # ...we'll let existing threads finish, though. |
Daniel Sandler | 723c5dc | 2011-04-04 11:15:17 -0400 | [diff] [blame] | 302 | if err_event.isSet(): |
Doug Anderson | fc06ced | 2011-03-16 15:49:18 -0700 | [diff] [blame] | 303 | break |
| 304 | |
Roy Lee | 18afd7f | 2010-05-09 04:32:08 +0800 | [diff] [blame] | 305 | sem.acquire() |
| 306 | t = _threading.Thread(target = self._FetchHelper, |
Shawn O. Pearce | 16614f8 | 2010-10-29 12:05:43 -0700 | [diff] [blame] | 307 | args = (opt, |
| 308 | project, |
| 309 | lock, |
| 310 | fetched, |
| 311 | pm, |
Doug Anderson | fc06ced | 2011-03-16 15:49:18 -0700 | [diff] [blame] | 312 | sem, |
| 313 | err_event)) |
David 'Digit' Turner | e212665 | 2012-09-05 10:35:06 +0200 | [diff] [blame] | 314 | # Ensure that Ctrl-C will not freeze the repo process. |
| 315 | t.daemon = True |
Roy Lee | 18afd7f | 2010-05-09 04:32:08 +0800 | [diff] [blame] | 316 | threads.add(t) |
| 317 | t.start() |
| 318 | |
| 319 | for t in threads: |
| 320 | t.join() |
| 321 | |
Doug Anderson | fc06ced | 2011-03-16 15:49:18 -0700 | [diff] [blame] | 322 | # If we saw an error, exit with code 1 so that other scripts can check. |
Daniel Sandler | 723c5dc | 2011-04-04 11:15:17 -0400 | [diff] [blame] | 323 | if err_event.isSet(): |
Sarah Owens | cecd1d8 | 2012-11-01 22:59:27 -0700 | [diff] [blame] | 324 | print('\nerror: Exited sync due to fetch errors', file=sys.stderr) |
Doug Anderson | fc06ced | 2011-03-16 15:49:18 -0700 | [diff] [blame] | 325 | sys.exit(1) |
| 326 | |
Shawn O. Pearce | 68194f4 | 2009-04-10 16:48:52 -0700 | [diff] [blame] | 327 | pm.end() |
Dave Borowitz | 67700e9 | 2012-10-23 15:00:54 -0700 | [diff] [blame] | 328 | self._fetch_times.Save() |
Dave Borowitz | 1885721 | 2012-10-23 17:02:59 -0700 | [diff] [blame] | 329 | |
| 330 | self._GCProjects(projects) |
The Android Open Source Project | cf31fe9 | 2008-10-21 07:00:00 -0700 | [diff] [blame] | 331 | return fetched |
| 332 | |
Dave Borowitz | 1885721 | 2012-10-23 17:02:59 -0700 | [diff] [blame] | 333 | def _GCProjects(self, projects): |
Dave Borowitz | e215267 | 2012-10-31 12:24:38 -0700 | [diff] [blame] | 334 | has_dash_c = git_require((1, 7, 2)) |
| 335 | if multiprocessing and has_dash_c: |
Dave Borowitz | 1885721 | 2012-10-23 17:02:59 -0700 | [diff] [blame] | 336 | cpu_count = multiprocessing.cpu_count() |
| 337 | else: |
| 338 | cpu_count = 1 |
| 339 | jobs = min(self.jobs, cpu_count) |
| 340 | |
| 341 | if jobs < 2: |
| 342 | for project in projects: |
| 343 | project.bare_git.gc('--auto') |
| 344 | return |
| 345 | |
| 346 | config = {'pack.threads': cpu_count / jobs if cpu_count > jobs else 1} |
| 347 | |
| 348 | threads = set() |
| 349 | sem = _threading.Semaphore(jobs) |
| 350 | err_event = _threading.Event() |
| 351 | |
| 352 | def GC(project): |
| 353 | try: |
| 354 | try: |
| 355 | project.bare_git.gc('--auto', config=config) |
| 356 | except GitError: |
| 357 | err_event.set() |
| 358 | except: |
| 359 | err_event.set() |
| 360 | raise |
| 361 | finally: |
| 362 | sem.release() |
| 363 | |
| 364 | for project in projects: |
| 365 | if err_event.isSet(): |
| 366 | break |
| 367 | sem.acquire() |
| 368 | t = _threading.Thread(target=GC, args=(project,)) |
| 369 | t.daemon = True |
| 370 | threads.add(t) |
| 371 | t.start() |
| 372 | |
| 373 | for t in threads: |
| 374 | t.join() |
| 375 | |
| 376 | if err_event.isSet(): |
Sarah Owens | cecd1d8 | 2012-11-01 22:59:27 -0700 | [diff] [blame] | 377 | print('\nerror: Exited sync due to gc errors', file=sys.stderr) |
Dave Borowitz | 1885721 | 2012-10-23 17:02:59 -0700 | [diff] [blame] | 378 | sys.exit(1) |
| 379 | |
Tim Kilbourn | 0766900 | 2013-03-08 15:02:49 -0800 | [diff] [blame] | 380 | def _ReloadManifest(self, manifest_name=None): |
| 381 | if manifest_name: |
| 382 | # Override calls _Unload already |
| 383 | self.manifest.Override(manifest_name) |
| 384 | else: |
| 385 | self.manifest._Unload() |
| 386 | |
Jaikumar Ganesh | 4f2517f | 2009-06-01 21:10:33 -0700 | [diff] [blame] | 387 | def UpdateProjectList(self): |
| 388 | new_project_paths = [] |
Colin Cross | 5acde75 | 2012-03-28 20:15:45 -0700 | [diff] [blame] | 389 | for project in self.GetProjects(None, missing_ok=True): |
Shawn O. Pearce | 3a68bb4 | 2009-06-04 16:18:09 -0700 | [diff] [blame] | 390 | if project.relpath: |
| 391 | new_project_paths.append(project.relpath) |
Jaikumar Ganesh | 4f2517f | 2009-06-01 21:10:33 -0700 | [diff] [blame] | 392 | file_name = 'project.list' |
| 393 | file_path = os.path.join(self.manifest.repodir, file_name) |
| 394 | old_project_paths = [] |
| 395 | |
| 396 | if os.path.exists(file_path): |
| 397 | fd = open(file_path, 'r') |
| 398 | try: |
| 399 | old_project_paths = fd.read().split('\n') |
| 400 | finally: |
| 401 | fd.close() |
| 402 | for path in old_project_paths: |
Shawn O. Pearce | 3a68bb4 | 2009-06-04 16:18:09 -0700 | [diff] [blame] | 403 | if not path: |
| 404 | continue |
Jaikumar Ganesh | 4f2517f | 2009-06-01 21:10:33 -0700 | [diff] [blame] | 405 | if path not in new_project_paths: |
David Pursehouse | 8a68ff9 | 2012-09-24 12:15:13 +0900 | [diff] [blame] | 406 | # If the path has already been deleted, we don't need to do it |
Anthony | f3fdf82 | 2009-09-26 13:38:52 -0400 | [diff] [blame] | 407 | if os.path.exists(self.manifest.topdir + '/' + path): |
David Pursehouse | c1b86a2 | 2012-11-14 11:36:51 +0900 | [diff] [blame] | 408 | project = Project( |
| 409 | manifest = self.manifest, |
| 410 | name = path, |
| 411 | remote = RemoteSpec('origin'), |
| 412 | gitdir = os.path.join(self.manifest.topdir, |
| 413 | path, '.git'), |
| 414 | worktree = os.path.join(self.manifest.topdir, path), |
| 415 | relpath = path, |
| 416 | revisionExpr = 'HEAD', |
| 417 | revisionId = None, |
| 418 | groups = None) |
Anthony | f3fdf82 | 2009-09-26 13:38:52 -0400 | [diff] [blame] | 419 | |
David Pursehouse | c1b86a2 | 2012-11-14 11:36:51 +0900 | [diff] [blame] | 420 | if project.IsDirty(): |
David Pursehouse | 2f9e7e4 | 2013-03-05 17:26:46 +0900 | [diff] [blame] | 421 | print('error: Cannot remove project "%s": uncommitted changes ' |
David Pursehouse | c1b86a2 | 2012-11-14 11:36:51 +0900 | [diff] [blame] | 422 | 'are present' % project.relpath, file=sys.stderr) |
| 423 | print(' commit changes, then run sync again', |
| 424 | file=sys.stderr) |
| 425 | return -1 |
| 426 | else: |
| 427 | print('Deleting obsolete path %s' % project.worktree, |
| 428 | file=sys.stderr) |
| 429 | shutil.rmtree(project.worktree) |
| 430 | # Try deleting parent subdirs if they are empty |
| 431 | project_dir = os.path.dirname(project.worktree) |
| 432 | while project_dir != self.manifest.topdir: |
| 433 | try: |
| 434 | os.rmdir(project_dir) |
| 435 | except OSError: |
| 436 | break |
| 437 | project_dir = os.path.dirname(project_dir) |
Jaikumar Ganesh | 4f2517f | 2009-06-01 21:10:33 -0700 | [diff] [blame] | 438 | |
Shawn O. Pearce | 9fb29ce | 2009-06-04 20:41:02 -0700 | [diff] [blame] | 439 | new_project_paths.sort() |
Jaikumar Ganesh | 4f2517f | 2009-06-01 21:10:33 -0700 | [diff] [blame] | 440 | fd = open(file_path, 'w') |
| 441 | try: |
| 442 | fd.write('\n'.join(new_project_paths)) |
Shawn O. Pearce | 3a68bb4 | 2009-06-04 16:18:09 -0700 | [diff] [blame] | 443 | fd.write('\n') |
Jaikumar Ganesh | 4f2517f | 2009-06-01 21:10:33 -0700 | [diff] [blame] | 444 | finally: |
| 445 | fd.close() |
| 446 | return 0 |
| 447 | |
The Android Open Source Project | cf31fe9 | 2008-10-21 07:00:00 -0700 | [diff] [blame] | 448 | def Execute(self, opt, args): |
Roy Lee | 18afd7f | 2010-05-09 04:32:08 +0800 | [diff] [blame] | 449 | if opt.jobs: |
| 450 | self.jobs = opt.jobs |
Shawn O. Pearce | 97d2b2f | 2011-09-22 17:23:41 -0700 | [diff] [blame] | 451 | if self.jobs > 1: |
| 452 | soft_limit, _ = _rlimit_nofile() |
| 453 | self.jobs = min(self.jobs, (soft_limit - 5) / 3) |
| 454 | |
Shawn O. Pearce | 3e768c9 | 2009-04-10 16:59:36 -0700 | [diff] [blame] | 455 | if opt.network_only and opt.detach_head: |
Sarah Owens | cecd1d8 | 2012-11-01 22:59:27 -0700 | [diff] [blame] | 456 | print('error: cannot combine -n and -d', file=sys.stderr) |
Shawn O. Pearce | 3e768c9 | 2009-04-10 16:59:36 -0700 | [diff] [blame] | 457 | sys.exit(1) |
Shawn O. Pearce | b1562fa | 2009-04-10 17:04:08 -0700 | [diff] [blame] | 458 | if opt.network_only and opt.local_only: |
Sarah Owens | cecd1d8 | 2012-11-01 22:59:27 -0700 | [diff] [blame] | 459 | print('error: cannot combine -n and -l', file=sys.stderr) |
Shawn O. Pearce | b1562fa | 2009-04-10 17:04:08 -0700 | [diff] [blame] | 460 | sys.exit(1) |
Chris Wolfe | e9dc3b3 | 2012-01-26 11:36:18 -0500 | [diff] [blame] | 461 | if opt.manifest_name and opt.smart_sync: |
Sarah Owens | cecd1d8 | 2012-11-01 22:59:27 -0700 | [diff] [blame] | 462 | print('error: cannot combine -m and -s', file=sys.stderr) |
Chris Wolfe | e9dc3b3 | 2012-01-26 11:36:18 -0500 | [diff] [blame] | 463 | sys.exit(1) |
| 464 | if opt.manifest_name and opt.smart_tag: |
Sarah Owens | cecd1d8 | 2012-11-01 22:59:27 -0700 | [diff] [blame] | 465 | print('error: cannot combine -m and -t', file=sys.stderr) |
Chris Wolfe | e9dc3b3 | 2012-01-26 11:36:18 -0500 | [diff] [blame] | 466 | sys.exit(1) |
David Pursehouse | cf76b1b | 2012-09-14 10:31:42 +0900 | [diff] [blame] | 467 | if opt.manifest_server_username or opt.manifest_server_password: |
| 468 | if not (opt.smart_sync or opt.smart_tag): |
Sarah Owens | cecd1d8 | 2012-11-01 22:59:27 -0700 | [diff] [blame] | 469 | print('error: -u and -p may only be combined with -s or -t', |
| 470 | file=sys.stderr) |
David Pursehouse | cf76b1b | 2012-09-14 10:31:42 +0900 | [diff] [blame] | 471 | sys.exit(1) |
| 472 | if None in [opt.manifest_server_username, opt.manifest_server_password]: |
Sarah Owens | cecd1d8 | 2012-11-01 22:59:27 -0700 | [diff] [blame] | 473 | print('error: both -u and -p must be given', file=sys.stderr) |
David Pursehouse | cf76b1b | 2012-09-14 10:31:42 +0900 | [diff] [blame] | 474 | sys.exit(1) |
Chris Wolfe | e9dc3b3 | 2012-01-26 11:36:18 -0500 | [diff] [blame] | 475 | |
| 476 | if opt.manifest_name: |
| 477 | self.manifest.Override(opt.manifest_name) |
Shawn O. Pearce | 3e768c9 | 2009-04-10 16:59:36 -0700 | [diff] [blame] | 478 | |
Victor Boivie | 08c880d | 2011-04-19 10:32:52 +0200 | [diff] [blame] | 479 | if opt.smart_sync or opt.smart_tag: |
Nico Sallembien | a1bfd2c | 2010-04-06 10:40:01 -0700 | [diff] [blame] | 480 | if not self.manifest.manifest_server: |
David Pursehouse | 2f9e7e4 | 2013-03-05 17:26:46 +0900 | [diff] [blame] | 481 | print('error: cannot smart sync: no manifest server defined in ' |
Sarah Owens | cecd1d8 | 2012-11-01 22:59:27 -0700 | [diff] [blame] | 482 | 'manifest', file=sys.stderr) |
Nico Sallembien | a1bfd2c | 2010-04-06 10:40:01 -0700 | [diff] [blame] | 483 | sys.exit(1) |
David Pursehouse | 86d973d | 2012-08-24 10:21:02 +0900 | [diff] [blame] | 484 | |
| 485 | manifest_server = self.manifest.manifest_server |
David Pursehouse | cf76b1b | 2012-09-14 10:31:42 +0900 | [diff] [blame] | 486 | |
David Pursehouse | 86d973d | 2012-08-24 10:21:02 +0900 | [diff] [blame] | 487 | if not '@' in manifest_server: |
David Pursehouse | cf76b1b | 2012-09-14 10:31:42 +0900 | [diff] [blame] | 488 | username = None |
| 489 | password = None |
| 490 | if opt.manifest_server_username and opt.manifest_server_password: |
| 491 | username = opt.manifest_server_username |
| 492 | password = opt.manifest_server_password |
David Pursehouse | 86d973d | 2012-08-24 10:21:02 +0900 | [diff] [blame] | 493 | else: |
| 494 | try: |
David Pursehouse | cf76b1b | 2012-09-14 10:31:42 +0900 | [diff] [blame] | 495 | info = netrc.netrc() |
| 496 | except IOError: |
Sarah Owens | cecd1d8 | 2012-11-01 22:59:27 -0700 | [diff] [blame] | 497 | print('.netrc file does not exist or could not be opened', |
| 498 | file=sys.stderr) |
David Pursehouse | 86d973d | 2012-08-24 10:21:02 +0900 | [diff] [blame] | 499 | else: |
David Pursehouse | cf76b1b | 2012-09-14 10:31:42 +0900 | [diff] [blame] | 500 | try: |
| 501 | parse_result = urlparse.urlparse(manifest_server) |
| 502 | if parse_result.hostname: |
| 503 | username, _account, password = \ |
| 504 | info.authenticators(parse_result.hostname) |
| 505 | except TypeError: |
| 506 | # TypeError is raised when the given hostname is not present |
| 507 | # in the .netrc file. |
Sarah Owens | cecd1d8 | 2012-11-01 22:59:27 -0700 | [diff] [blame] | 508 | print('No credentials found for %s in .netrc' |
| 509 | % parse_result.hostname, file=sys.stderr) |
Sarah Owens | a5be53f | 2012-09-09 15:37:57 -0700 | [diff] [blame] | 510 | except netrc.NetrcParseError as e: |
Sarah Owens | cecd1d8 | 2012-11-01 22:59:27 -0700 | [diff] [blame] | 511 | print('Error parsing .netrc file: %s' % e, file=sys.stderr) |
David Pursehouse | cf76b1b | 2012-09-14 10:31:42 +0900 | [diff] [blame] | 512 | |
| 513 | if (username and password): |
| 514 | manifest_server = manifest_server.replace('://', '://%s:%s@' % |
| 515 | (username, password), |
| 516 | 1) |
David Pursehouse | 86d973d | 2012-08-24 10:21:02 +0900 | [diff] [blame] | 517 | |
Nico Sallembien | a1bfd2c | 2010-04-06 10:40:01 -0700 | [diff] [blame] | 518 | try: |
David Pursehouse | 86d973d | 2012-08-24 10:21:02 +0900 | [diff] [blame] | 519 | server = xmlrpclib.Server(manifest_server) |
Victor Boivie | 08c880d | 2011-04-19 10:32:52 +0200 | [diff] [blame] | 520 | if opt.smart_sync: |
| 521 | p = self.manifest.manifestProject |
| 522 | b = p.GetBranch(p.CurrentBranch) |
| 523 | branch = b.merge |
| 524 | if branch.startswith(R_HEADS): |
| 525 | branch = branch[len(R_HEADS):] |
Nico Sallembien | a1bfd2c | 2010-04-06 10:40:01 -0700 | [diff] [blame] | 526 | |
Victor Boivie | 08c880d | 2011-04-19 10:32:52 +0200 | [diff] [blame] | 527 | env = os.environ.copy() |
| 528 | if (env.has_key('TARGET_PRODUCT') and |
| 529 | env.has_key('TARGET_BUILD_VARIANT')): |
| 530 | target = '%s-%s' % (env['TARGET_PRODUCT'], |
| 531 | env['TARGET_BUILD_VARIANT']) |
| 532 | [success, manifest_str] = server.GetApprovedManifest(branch, target) |
| 533 | else: |
| 534 | [success, manifest_str] = server.GetApprovedManifest(branch) |
Nico Sallembien | a1bfd2c | 2010-04-06 10:40:01 -0700 | [diff] [blame] | 535 | else: |
Victor Boivie | 08c880d | 2011-04-19 10:32:52 +0200 | [diff] [blame] | 536 | assert(opt.smart_tag) |
| 537 | [success, manifest_str] = server.GetManifest(opt.smart_tag) |
Nico Sallembien | a1bfd2c | 2010-04-06 10:40:01 -0700 | [diff] [blame] | 538 | |
| 539 | if success: |
| 540 | manifest_name = "smart_sync_override.xml" |
| 541 | manifest_path = os.path.join(self.manifest.manifestProject.worktree, |
| 542 | manifest_name) |
| 543 | try: |
| 544 | f = open(manifest_path, 'w') |
| 545 | try: |
| 546 | f.write(manifest_str) |
Nico Sallembien | a1bfd2c | 2010-04-06 10:40:01 -0700 | [diff] [blame] | 547 | finally: |
| 548 | f.close() |
| 549 | except IOError: |
Sarah Owens | cecd1d8 | 2012-11-01 22:59:27 -0700 | [diff] [blame] | 550 | print('error: cannot write manifest to %s' % manifest_path, |
| 551 | file=sys.stderr) |
Nico Sallembien | a1bfd2c | 2010-04-06 10:40:01 -0700 | [diff] [blame] | 552 | sys.exit(1) |
Nico Sallembien | 719965a | 2010-04-20 15:28:19 -0700 | [diff] [blame] | 553 | self.manifest.Override(manifest_name) |
Nico Sallembien | a1bfd2c | 2010-04-06 10:40:01 -0700 | [diff] [blame] | 554 | else: |
Sarah Owens | cecd1d8 | 2012-11-01 22:59:27 -0700 | [diff] [blame] | 555 | print('error: %s' % manifest_str, file=sys.stderr) |
Nico Sallembien | a1bfd2c | 2010-04-06 10:40:01 -0700 | [diff] [blame] | 556 | sys.exit(1) |
Sarah Owens | a5be53f | 2012-09-09 15:37:57 -0700 | [diff] [blame] | 557 | except (socket.error, IOError, xmlrpclib.Fault) as e: |
Sarah Owens | cecd1d8 | 2012-11-01 22:59:27 -0700 | [diff] [blame] | 558 | print('error: cannot connect to manifest server %s:\n%s' |
| 559 | % (self.manifest.manifest_server, e), file=sys.stderr) |
David Pursehouse | bd489c4 | 2012-08-23 10:21:26 +0900 | [diff] [blame] | 560 | sys.exit(1) |
Sarah Owens | a5be53f | 2012-09-09 15:37:57 -0700 | [diff] [blame] | 561 | except xmlrpclib.ProtocolError as e: |
Sarah Owens | cecd1d8 | 2012-11-01 22:59:27 -0700 | [diff] [blame] | 562 | print('error: cannot connect to manifest server %s:\n%d %s' |
| 563 | % (self.manifest.manifest_server, e.errcode, e.errmsg), |
| 564 | file=sys.stderr) |
Nico Sallembien | a1bfd2c | 2010-04-06 10:40:01 -0700 | [diff] [blame] | 565 | sys.exit(1) |
| 566 | |
The Android Open Source Project | cf31fe9 | 2008-10-21 07:00:00 -0700 | [diff] [blame] | 567 | rp = self.manifest.repoProject |
| 568 | rp.PreSync() |
| 569 | |
| 570 | mp = self.manifest.manifestProject |
| 571 | mp.PreSync() |
| 572 | |
Shawn O. Pearce | c9ef744 | 2008-11-03 10:32:09 -0800 | [diff] [blame] | 573 | if opt.repo_upgraded: |
Shawn O. Pearce | 80d2ceb | 2012-10-26 12:23:05 -0700 | [diff] [blame] | 574 | _PostRepoUpgrade(self.manifest, quiet=opt.quiet) |
Shawn O. Pearce | c9ef744 | 2008-11-03 10:32:09 -0800 | [diff] [blame] | 575 | |
Nico Sallembien | 9bb1816 | 2009-12-07 15:38:01 -0800 | [diff] [blame] | 576 | if not opt.local_only: |
Anatol Pomazau | 53d6f4d | 2011-08-25 17:21:47 -0700 | [diff] [blame] | 577 | mp.Sync_NetworkHalf(quiet=opt.quiet, |
Mitchel Humpherys | 597868b | 2012-10-29 10:18:34 -0700 | [diff] [blame] | 578 | current_branch_only=opt.current_branch_only, |
| 579 | no_tags=opt.no_tags) |
Nico Sallembien | 9bb1816 | 2009-12-07 15:38:01 -0800 | [diff] [blame] | 580 | |
| 581 | if mp.HasChanges: |
| 582 | syncbuf = SyncBuffer(mp.config) |
| 583 | mp.Sync_LocalHalf(syncbuf) |
| 584 | if not syncbuf.Finish(): |
| 585 | sys.exit(1) |
Tim Kilbourn | 0766900 | 2013-03-08 15:02:49 -0800 | [diff] [blame] | 586 | self._ReloadManifest(opt.manifest_name) |
Shawn O. Pearce | c465796 | 2011-09-26 09:08:01 -0700 | [diff] [blame] | 587 | if opt.jobs is None: |
| 588 | self.jobs = self.manifest.default.sync_j |
Che-Liang Chiou | b2bd91c | 2012-01-11 11:28:42 +0800 | [diff] [blame] | 589 | all_projects = self.GetProjects(args, |
| 590 | missing_ok=True, |
| 591 | submodules_ok=opt.fetch_submodules) |
The Android Open Source Project | cf31fe9 | 2008-10-21 07:00:00 -0700 | [diff] [blame] | 592 | |
Dave Borowitz | 67700e9 | 2012-10-23 15:00:54 -0700 | [diff] [blame] | 593 | self._fetch_times = _FetchTimes(self.manifest) |
Shawn O. Pearce | b1562fa | 2009-04-10 17:04:08 -0700 | [diff] [blame] | 594 | if not opt.local_only: |
Shawn O. Pearce | f690687 | 2009-04-18 10:49:00 -0700 | [diff] [blame] | 595 | to_fetch = [] |
| 596 | now = time.time() |
Dave Borowitz | 67700e9 | 2012-10-23 15:00:54 -0700 | [diff] [blame] | 597 | if _ONE_DAY_S <= (now - rp.LastFetch): |
Shawn O. Pearce | f690687 | 2009-04-18 10:49:00 -0700 | [diff] [blame] | 598 | to_fetch.append(rp) |
David Pursehouse | 8a68ff9 | 2012-09-24 12:15:13 +0900 | [diff] [blame] | 599 | to_fetch.extend(all_projects) |
Dave Borowitz | 67700e9 | 2012-10-23 15:00:54 -0700 | [diff] [blame] | 600 | to_fetch.sort(key=self._fetch_times.Get, reverse=True) |
Shawn O. Pearce | f690687 | 2009-04-18 10:49:00 -0700 | [diff] [blame] | 601 | |
Che-Liang Chiou | b2bd91c | 2012-01-11 11:28:42 +0800 | [diff] [blame] | 602 | fetched = self._Fetch(to_fetch, opt) |
Shawn O. Pearce | e756c41 | 2009-04-13 11:51:15 -0700 | [diff] [blame] | 603 | _PostRepoFetch(rp, opt.no_repo_verify) |
Shawn O. Pearce | b1562fa | 2009-04-10 17:04:08 -0700 | [diff] [blame] | 604 | if opt.network_only: |
| 605 | # bail out now; the rest touches the working tree |
| 606 | return |
| 607 | |
Che-Liang Chiou | b2bd91c | 2012-01-11 11:28:42 +0800 | [diff] [blame] | 608 | # Iteratively fetch missing and/or nested unregistered submodules |
| 609 | previously_missing_set = set() |
| 610 | while True: |
Tim Kilbourn | 0766900 | 2013-03-08 15:02:49 -0800 | [diff] [blame] | 611 | self._ReloadManifest(opt.manifest_name) |
Che-Liang Chiou | b2bd91c | 2012-01-11 11:28:42 +0800 | [diff] [blame] | 612 | all_projects = self.GetProjects(args, |
| 613 | missing_ok=True, |
| 614 | submodules_ok=opt.fetch_submodules) |
| 615 | missing = [] |
| 616 | for project in all_projects: |
| 617 | if project.gitdir not in fetched: |
| 618 | missing.append(project) |
| 619 | if not missing: |
| 620 | break |
| 621 | # Stop us from non-stopped fetching actually-missing repos: If set of |
| 622 | # missing repos has not been changed from last fetch, we break. |
| 623 | missing_set = set(p.name for p in missing) |
| 624 | if previously_missing_set == missing_set: |
| 625 | break |
| 626 | previously_missing_set = missing_set |
| 627 | fetched.update(self._Fetch(missing, opt)) |
| 628 | |
Shawn O. Pearce | cd1d7ff | 2009-06-04 16:15:53 -0700 | [diff] [blame] | 629 | if self.manifest.IsMirror: |
| 630 | # bail out now, we have no working tree |
| 631 | return |
| 632 | |
Jaikumar Ganesh | 4f2517f | 2009-06-01 21:10:33 -0700 | [diff] [blame] | 633 | if self.UpdateProjectList(): |
| 634 | sys.exit(1) |
| 635 | |
Shawn O. Pearce | 350cde4 | 2009-04-16 11:21:18 -0700 | [diff] [blame] | 636 | syncbuf = SyncBuffer(mp.config, |
| 637 | detach_head = opt.detach_head) |
David Pursehouse | 8a68ff9 | 2012-09-24 12:15:13 +0900 | [diff] [blame] | 638 | pm = Progress('Syncing work tree', len(all_projects)) |
| 639 | for project in all_projects: |
Shawn O. Pearce | 68194f4 | 2009-04-10 16:48:52 -0700 | [diff] [blame] | 640 | pm.update() |
Shawn O. Pearce | e284ad1 | 2008-11-04 07:37:10 -0800 | [diff] [blame] | 641 | if project.worktree: |
Shawn O. Pearce | 350cde4 | 2009-04-16 11:21:18 -0700 | [diff] [blame] | 642 | project.Sync_LocalHalf(syncbuf) |
Shawn O. Pearce | 68194f4 | 2009-04-10 16:48:52 -0700 | [diff] [blame] | 643 | pm.end() |
Sarah Owens | cecd1d8 | 2012-11-01 22:59:27 -0700 | [diff] [blame] | 644 | print(file=sys.stderr) |
Shawn O. Pearce | 350cde4 | 2009-04-16 11:21:18 -0700 | [diff] [blame] | 645 | if not syncbuf.Finish(): |
| 646 | sys.exit(1) |
The Android Open Source Project | cf31fe9 | 2008-10-21 07:00:00 -0700 | [diff] [blame] | 647 | |
Doug Anderson | 2b8db3c | 2010-11-01 15:08:06 -0700 | [diff] [blame] | 648 | # If there's a notice that's supposed to print at the end of the sync, print |
| 649 | # it now... |
| 650 | if self.manifest.notice: |
Sarah Owens | cecd1d8 | 2012-11-01 22:59:27 -0700 | [diff] [blame] | 651 | print(self.manifest.notice) |
Doug Anderson | 2b8db3c | 2010-11-01 15:08:06 -0700 | [diff] [blame] | 652 | |
Shawn O. Pearce | 80d2ceb | 2012-10-26 12:23:05 -0700 | [diff] [blame] | 653 | def _PostRepoUpgrade(manifest, quiet=False): |
Conley Owens | c9129d9 | 2012-10-01 16:12:28 -0700 | [diff] [blame] | 654 | wrapper = WrapperModule() |
| 655 | if wrapper.NeedSetupGnuPG(): |
Shawn O. Pearce | 80d2ceb | 2012-10-26 12:23:05 -0700 | [diff] [blame] | 656 | wrapper.SetupGnuPG(quiet) |
Shawn O. Pearce | e756c41 | 2009-04-13 11:51:15 -0700 | [diff] [blame] | 657 | for project in manifest.projects.values(): |
| 658 | if project.Exists: |
| 659 | project.PostRepoUpgrade() |
| 660 | |
| 661 | def _PostRepoFetch(rp, no_repo_verify=False, verbose=False): |
| 662 | if rp.HasChanges: |
Sarah Owens | cecd1d8 | 2012-11-01 22:59:27 -0700 | [diff] [blame] | 663 | print('info: A new version of repo is available', file=sys.stderr) |
| 664 | print(file=sys.stderr) |
Shawn O. Pearce | e756c41 | 2009-04-13 11:51:15 -0700 | [diff] [blame] | 665 | if no_repo_verify or _VerifyTag(rp): |
Shawn O. Pearce | 350cde4 | 2009-04-16 11:21:18 -0700 | [diff] [blame] | 666 | syncbuf = SyncBuffer(rp.config) |
| 667 | rp.Sync_LocalHalf(syncbuf) |
| 668 | if not syncbuf.Finish(): |
Shawn O. Pearce | e756c41 | 2009-04-13 11:51:15 -0700 | [diff] [blame] | 669 | sys.exit(1) |
Sarah Owens | cecd1d8 | 2012-11-01 22:59:27 -0700 | [diff] [blame] | 670 | print('info: Restarting repo with latest version', file=sys.stderr) |
Shawn O. Pearce | e756c41 | 2009-04-13 11:51:15 -0700 | [diff] [blame] | 671 | raise RepoChangedException(['--repo-upgraded']) |
| 672 | else: |
Sarah Owens | cecd1d8 | 2012-11-01 22:59:27 -0700 | [diff] [blame] | 673 | print('warning: Skipped upgrade to unverified version', file=sys.stderr) |
Shawn O. Pearce | e756c41 | 2009-04-13 11:51:15 -0700 | [diff] [blame] | 674 | else: |
| 675 | if verbose: |
Sarah Owens | cecd1d8 | 2012-11-01 22:59:27 -0700 | [diff] [blame] | 676 | print('repo version %s is current' % rp.work_git.describe(HEAD), |
| 677 | file=sys.stderr) |
Shawn O. Pearce | e756c41 | 2009-04-13 11:51:15 -0700 | [diff] [blame] | 678 | |
The Android Open Source Project | cf31fe9 | 2008-10-21 07:00:00 -0700 | [diff] [blame] | 679 | def _VerifyTag(project): |
| 680 | gpg_dir = os.path.expanduser('~/.repoconfig/gnupg') |
| 681 | if not os.path.exists(gpg_dir): |
Sarah Owens | cecd1d8 | 2012-11-01 22:59:27 -0700 | [diff] [blame] | 682 | print('warning: GnuPG was not available during last "repo init"\n' |
| 683 | 'warning: Cannot automatically authenticate repo."""', |
| 684 | file=sys.stderr) |
The Android Open Source Project | cf31fe9 | 2008-10-21 07:00:00 -0700 | [diff] [blame] | 685 | return True |
| 686 | |
The Android Open Source Project | cf31fe9 | 2008-10-21 07:00:00 -0700 | [diff] [blame] | 687 | try: |
Shawn O. Pearce | 3c8dea1 | 2009-05-29 18:38:17 -0700 | [diff] [blame] | 688 | cur = project.bare_git.describe(project.GetRevisionId()) |
The Android Open Source Project | cf31fe9 | 2008-10-21 07:00:00 -0700 | [diff] [blame] | 689 | except GitError: |
| 690 | cur = None |
| 691 | |
| 692 | if not cur \ |
| 693 | or re.compile(r'^.*-[0-9]{1,}-g[0-9a-f]{1,}$').match(cur): |
Shawn O. Pearce | 3c8dea1 | 2009-05-29 18:38:17 -0700 | [diff] [blame] | 694 | rev = project.revisionExpr |
The Android Open Source Project | cf31fe9 | 2008-10-21 07:00:00 -0700 | [diff] [blame] | 695 | if rev.startswith(R_HEADS): |
| 696 | rev = rev[len(R_HEADS):] |
| 697 | |
Sarah Owens | cecd1d8 | 2012-11-01 22:59:27 -0700 | [diff] [blame] | 698 | print(file=sys.stderr) |
| 699 | print("warning: project '%s' branch '%s' is not signed" |
| 700 | % (project.name, rev), file=sys.stderr) |
The Android Open Source Project | cf31fe9 | 2008-10-21 07:00:00 -0700 | [diff] [blame] | 701 | return False |
| 702 | |
Shawn O. Pearce | f18cb76 | 2010-12-07 11:41:05 -0800 | [diff] [blame] | 703 | env = os.environ.copy() |
| 704 | env['GIT_DIR'] = project.gitdir.encode() |
| 705 | env['GNUPGHOME'] = gpg_dir.encode() |
The Android Open Source Project | cf31fe9 | 2008-10-21 07:00:00 -0700 | [diff] [blame] | 706 | |
| 707 | cmd = [GIT, 'tag', '-v', cur] |
| 708 | proc = subprocess.Popen(cmd, |
| 709 | stdout = subprocess.PIPE, |
| 710 | stderr = subprocess.PIPE, |
| 711 | env = env) |
| 712 | out = proc.stdout.read() |
| 713 | proc.stdout.close() |
| 714 | |
| 715 | err = proc.stderr.read() |
| 716 | proc.stderr.close() |
| 717 | |
| 718 | if proc.wait() != 0: |
Sarah Owens | cecd1d8 | 2012-11-01 22:59:27 -0700 | [diff] [blame] | 719 | print(file=sys.stderr) |
| 720 | print(out, file=sys.stderr) |
| 721 | print(err, file=sys.stderr) |
| 722 | print(file=sys.stderr) |
The Android Open Source Project | cf31fe9 | 2008-10-21 07:00:00 -0700 | [diff] [blame] | 723 | return False |
| 724 | return True |
Dave Borowitz | 67700e9 | 2012-10-23 15:00:54 -0700 | [diff] [blame] | 725 | |
| 726 | class _FetchTimes(object): |
Dave Borowitz | d947858 | 2012-10-23 16:35:39 -0700 | [diff] [blame] | 727 | _ALPHA = 0.5 |
| 728 | |
Dave Borowitz | 67700e9 | 2012-10-23 15:00:54 -0700 | [diff] [blame] | 729 | def __init__(self, manifest): |
| 730 | self._path = os.path.join(manifest.repodir, '.repopickle_fetchtimes') |
| 731 | self._times = None |
Dave Borowitz | d947858 | 2012-10-23 16:35:39 -0700 | [diff] [blame] | 732 | self._seen = set() |
Dave Borowitz | 67700e9 | 2012-10-23 15:00:54 -0700 | [diff] [blame] | 733 | |
| 734 | def Get(self, project): |
| 735 | self._Load() |
| 736 | return self._times.get(project.name, _ONE_DAY_S) |
| 737 | |
| 738 | def Set(self, project, t): |
Dave Borowitz | d947858 | 2012-10-23 16:35:39 -0700 | [diff] [blame] | 739 | self._Load() |
| 740 | name = project.name |
| 741 | old = self._times.get(name, t) |
| 742 | self._seen.add(name) |
| 743 | a = self._ALPHA |
| 744 | self._times[name] = (a*t) + ((1-a) * old) |
Dave Borowitz | 67700e9 | 2012-10-23 15:00:54 -0700 | [diff] [blame] | 745 | |
| 746 | def _Load(self): |
| 747 | if self._times is None: |
| 748 | try: |
| 749 | f = open(self._path) |
| 750 | except IOError: |
| 751 | self._times = {} |
| 752 | return self._times |
| 753 | try: |
| 754 | try: |
| 755 | self._times = pickle.load(f) |
David Pursehouse | 1d947b3 | 2012-10-25 12:23:11 +0900 | [diff] [blame] | 756 | except IOError: |
Dave Borowitz | 67700e9 | 2012-10-23 15:00:54 -0700 | [diff] [blame] | 757 | try: |
| 758 | os.remove(self._path) |
| 759 | except OSError: |
| 760 | pass |
| 761 | self._times = {} |
| 762 | finally: |
| 763 | f.close() |
| 764 | return self._times |
| 765 | |
| 766 | def Save(self): |
| 767 | if self._times is None: |
| 768 | return |
Dave Borowitz | d947858 | 2012-10-23 16:35:39 -0700 | [diff] [blame] | 769 | |
| 770 | to_delete = [] |
| 771 | for name in self._times: |
| 772 | if name not in self._seen: |
| 773 | to_delete.append(name) |
| 774 | for name in to_delete: |
| 775 | del self._times[name] |
| 776 | |
Dave Borowitz | 67700e9 | 2012-10-23 15:00:54 -0700 | [diff] [blame] | 777 | try: |
| 778 | f = open(self._path, 'wb') |
| 779 | try: |
| 780 | pickle.dump(self._times, f) |
| 781 | except (IOError, OSError, pickle.PickleError): |
| 782 | try: |
| 783 | os.remove(self._path) |
| 784 | except OSError: |
| 785 | pass |
| 786 | finally: |
| 787 | f.close() |