##// END OF EJS Templates
configitems: register the 'format.usestore' config
marmoute -
r33244:4d5d493e default
parent child Browse files
Show More
@@ -1,198 +1,201 b''
1 1 # configitems.py - centralized declaration of configuration option
2 2 #
3 3 # Copyright 2017 Pierre-Yves David <pierre-yves.david@octobus.net>
4 4 #
5 5 # This software may be used and distributed according to the terms of the
6 6 # GNU General Public License version 2 or any later version.
7 7
8 8 from __future__ import absolute_import
9 9
10 10 import functools
11 11
12 12 from . import (
13 13 error,
14 14 )
15 15
16 16 def loadconfigtable(ui, extname, configtable):
17 17 """update config item known to the ui with the extension ones"""
18 18 for section, items in configtable.items():
19 19 knownitems = ui._knownconfig.setdefault(section, {})
20 20 knownkeys = set(knownitems)
21 21 newkeys = set(items)
22 22 for key in sorted(knownkeys & newkeys):
23 23 msg = "extension '%s' overwrite config item '%s.%s'"
24 24 msg %= (extname, section, key)
25 25 ui.develwarn(msg, config='warn-config')
26 26
27 27 knownitems.update(items)
28 28
29 29 class configitem(object):
30 30 """represent a known config item
31 31
32 32 :section: the official config section where to find this item,
33 33 :name: the official name within the section,
34 34 :default: default value for this item,
35 35 """
36 36
37 37 def __init__(self, section, name, default=None):
38 38 self.section = section
39 39 self.name = name
40 40 self.default = default
41 41
42 42 coreitems = {}
43 43
44 44 def _register(configtable, *args, **kwargs):
45 45 item = configitem(*args, **kwargs)
46 46 section = configtable.setdefault(item.section, {})
47 47 if item.name in section:
48 48 msg = "duplicated config item registration for '%s.%s'"
49 49 raise error.ProgrammingError(msg % (item.section, item.name))
50 50 section[item.name] = item
51 51
52 52 # Registering actual config items
53 53
54 54 def getitemregister(configtable):
55 55 return functools.partial(_register, configtable)
56 56
57 57 coreconfigitem = getitemregister(coreitems)
58 58
59 59 coreconfigitem('auth', 'cookiefile',
60 60 default=None,
61 61 )
62 62 # bookmarks.pushing: internal hack for discovery
63 63 coreconfigitem('bookmarks', 'pushing',
64 64 default=list,
65 65 )
66 66 # bundle.mainreporoot: internal hack for bundlerepo
67 67 coreconfigitem('bundle', 'mainreporoot',
68 68 default='',
69 69 )
70 70 # bundle.reorder: experimental config
71 71 coreconfigitem('bundle', 'reorder',
72 72 default='auto',
73 73 )
74 74 coreconfigitem('color', 'mode',
75 75 default='auto',
76 76 )
77 77 coreconfigitem('devel', 'all-warnings',
78 78 default=False,
79 79 )
80 80 coreconfigitem('devel', 'bundle2.debug',
81 81 default=False,
82 82 )
83 83 coreconfigitem('devel', 'check-locks',
84 84 default=False,
85 85 )
86 86 coreconfigitem('devel', 'check-relroot',
87 87 default=False,
88 88 )
89 89 coreconfigitem('devel', 'disableloaddefaultcerts',
90 90 default=False,
91 91 )
92 92 coreconfigitem('devel', 'legacy.exchange',
93 93 default=list,
94 94 )
95 95 coreconfigitem('devel', 'servercafile',
96 96 default='',
97 97 )
98 98 coreconfigitem('devel', 'serverexactprotocol',
99 99 default='',
100 100 )
101 101 coreconfigitem('devel', 'serverrequirecert',
102 102 default=False,
103 103 )
104 104 coreconfigitem('devel', 'strip-obsmarkers',
105 105 default=True,
106 106 )
107 107 coreconfigitem('format', 'aggressivemergedeltas',
108 108 default=False,
109 109 )
110 110 coreconfigitem('format', 'chunkcachesize',
111 111 default=None,
112 112 )
113 113 coreconfigitem('format', 'dotencode',
114 114 default=True,
115 115 )
116 116 coreconfigitem('format', 'generaldelta',
117 117 default=False,
118 118 )
119 119 coreconfigitem('format', 'manifestcachesize',
120 120 default=None,
121 121 )
122 122 coreconfigitem('format', 'maxchainlen',
123 123 default=None,
124 124 )
125 125 coreconfigitem('format', 'obsstore-version',
126 126 default=None,
127 127 )
128 128 coreconfigitem('format', 'usefncache',
129 129 default=True,
130 130 )
131 131 coreconfigitem('format', 'usegeneraldelta',
132 132 default=True,
133 133 )
134 coreconfigitem('format', 'usestore',
135 default=True,
136 )
134 137 coreconfigitem('hostsecurity', 'ciphers',
135 138 default=None,
136 139 )
137 140 coreconfigitem('hostsecurity', 'disabletls10warning',
138 141 default=False,
139 142 )
140 143 coreconfigitem('patch', 'eol',
141 144 default='strict',
142 145 )
143 146 coreconfigitem('patch', 'fuzz',
144 147 default=2,
145 148 )
146 149 coreconfigitem('server', 'bundle1',
147 150 default=True,
148 151 )
149 152 coreconfigitem('server', 'bundle1gd',
150 153 default=None,
151 154 )
152 155 coreconfigitem('server', 'compressionengines',
153 156 default=list,
154 157 )
155 158 coreconfigitem('server', 'concurrent-push-mode',
156 159 default='strict',
157 160 )
158 161 coreconfigitem('server', 'disablefullbundle',
159 162 default=False,
160 163 )
161 164 coreconfigitem('server', 'maxhttpheaderlen',
162 165 default=1024,
163 166 )
164 167 coreconfigitem('server', 'preferuncompressed',
165 168 default=False,
166 169 )
167 170 coreconfigitem('server', 'uncompressedallowsecret',
168 171 default=False,
169 172 )
170 173 coreconfigitem('server', 'validate',
171 174 default=False,
172 175 )
173 176 coreconfigitem('server', 'zliblevel',
174 177 default=-1,
175 178 )
176 179 coreconfigitem('ui', 'clonebundleprefers',
177 180 default=list,
178 181 )
179 182 coreconfigitem('ui', 'interactive',
180 183 default=None,
181 184 )
182 185 coreconfigitem('ui', 'quiet',
183 186 default=False,
184 187 )
185 188 # Windows defaults to a limit of 512 open files. A buffer of 128
186 189 # should give us enough headway.
187 190 coreconfigitem('worker', 'backgroundclosemaxqueue',
188 191 default=384,
189 192 )
190 193 coreconfigitem('worker', 'backgroundcloseminfilecount',
191 194 default=2048,
192 195 )
193 196 coreconfigitem('worker', 'backgroundclosethreadcount',
194 197 default=4,
195 198 )
196 199 coreconfigitem('worker', 'numcpus',
197 200 default=None,
198 201 )
@@ -1,2110 +1,2110 b''
1 1 # localrepo.py - read/write repository class for mercurial
2 2 #
3 3 # Copyright 2005-2007 Matt Mackall <mpm@selenic.com>
4 4 #
5 5 # This software may be used and distributed according to the terms of the
6 6 # GNU General Public License version 2 or any later version.
7 7
8 8 from __future__ import absolute_import
9 9
10 10 import errno
11 11 import hashlib
12 12 import inspect
13 13 import os
14 14 import random
15 15 import time
16 16 import weakref
17 17
18 18 from .i18n import _
19 19 from .node import (
20 20 hex,
21 21 nullid,
22 22 short,
23 23 )
24 24 from . import (
25 25 bookmarks,
26 26 branchmap,
27 27 bundle2,
28 28 changegroup,
29 29 changelog,
30 30 color,
31 31 context,
32 32 dirstate,
33 33 dirstateguard,
34 34 encoding,
35 35 error,
36 36 exchange,
37 37 extensions,
38 38 filelog,
39 39 hook,
40 40 lock as lockmod,
41 41 manifest,
42 42 match as matchmod,
43 43 merge as mergemod,
44 44 mergeutil,
45 45 namespaces,
46 46 obsolete,
47 47 pathutil,
48 48 peer,
49 49 phases,
50 50 pushkey,
51 51 pycompat,
52 52 repoview,
53 53 revset,
54 54 revsetlang,
55 55 scmutil,
56 56 store,
57 57 subrepo,
58 58 tags as tagsmod,
59 59 transaction,
60 60 txnutil,
61 61 util,
62 62 vfs as vfsmod,
63 63 )
64 64
65 65 release = lockmod.release
66 66 urlerr = util.urlerr
67 67 urlreq = util.urlreq
68 68
69 69 class _basefilecache(scmutil.filecache):
70 70 """All filecache usage on repo are done for logic that should be unfiltered
71 71 """
72 72 def __get__(self, repo, type=None):
73 73 if repo is None:
74 74 return self
75 75 return super(_basefilecache, self).__get__(repo.unfiltered(), type)
76 76 def __set__(self, repo, value):
77 77 return super(_basefilecache, self).__set__(repo.unfiltered(), value)
78 78 def __delete__(self, repo):
79 79 return super(_basefilecache, self).__delete__(repo.unfiltered())
80 80
81 81 class repofilecache(_basefilecache):
82 82 """filecache for files in .hg but outside of .hg/store"""
83 83 def join(self, obj, fname):
84 84 return obj.vfs.join(fname)
85 85
86 86 class storecache(_basefilecache):
87 87 """filecache for files in the store"""
88 88 def join(self, obj, fname):
89 89 return obj.sjoin(fname)
90 90
91 91 class unfilteredpropertycache(util.propertycache):
92 92 """propertycache that apply to unfiltered repo only"""
93 93
94 94 def __get__(self, repo, type=None):
95 95 unfi = repo.unfiltered()
96 96 if unfi is repo:
97 97 return super(unfilteredpropertycache, self).__get__(unfi)
98 98 return getattr(unfi, self.name)
99 99
100 100 class filteredpropertycache(util.propertycache):
101 101 """propertycache that must take filtering in account"""
102 102
103 103 def cachevalue(self, obj, value):
104 104 object.__setattr__(obj, self.name, value)
105 105
106 106
107 107 def hasunfilteredcache(repo, name):
108 108 """check if a repo has an unfilteredpropertycache value for <name>"""
109 109 return name in vars(repo.unfiltered())
110 110
111 111 def unfilteredmethod(orig):
112 112 """decorate method that always need to be run on unfiltered version"""
113 113 def wrapper(repo, *args, **kwargs):
114 114 return orig(repo.unfiltered(), *args, **kwargs)
115 115 return wrapper
116 116
117 117 moderncaps = {'lookup', 'branchmap', 'pushkey', 'known', 'getbundle',
118 118 'unbundle'}
119 119 legacycaps = moderncaps.union({'changegroupsubset'})
120 120
121 121 class localpeer(peer.peerrepository):
122 122 '''peer for a local repo; reflects only the most recent API'''
123 123
124 124 def __init__(self, repo, caps=None):
125 125 if caps is None:
126 126 caps = moderncaps.copy()
127 127 peer.peerrepository.__init__(self)
128 128 self._repo = repo.filtered('served')
129 129 self.ui = repo.ui
130 130 self._caps = repo._restrictcapabilities(caps)
131 131 self.requirements = repo.requirements
132 132 self.supportedformats = repo.supportedformats
133 133
134 134 def close(self):
135 135 self._repo.close()
136 136
137 137 def _capabilities(self):
138 138 return self._caps
139 139
140 140 def local(self):
141 141 return self._repo
142 142
143 143 def canpush(self):
144 144 return True
145 145
146 146 def url(self):
147 147 return self._repo.url()
148 148
149 149 def lookup(self, key):
150 150 return self._repo.lookup(key)
151 151
152 152 def branchmap(self):
153 153 return self._repo.branchmap()
154 154
155 155 def heads(self):
156 156 return self._repo.heads()
157 157
158 158 def known(self, nodes):
159 159 return self._repo.known(nodes)
160 160
161 161 def getbundle(self, source, heads=None, common=None, bundlecaps=None,
162 162 **kwargs):
163 163 chunks = exchange.getbundlechunks(self._repo, source, heads=heads,
164 164 common=common, bundlecaps=bundlecaps,
165 165 **kwargs)
166 166 cb = util.chunkbuffer(chunks)
167 167
168 168 if exchange.bundle2requested(bundlecaps):
169 169 # When requesting a bundle2, getbundle returns a stream to make the
170 170 # wire level function happier. We need to build a proper object
171 171 # from it in local peer.
172 172 return bundle2.getunbundler(self.ui, cb)
173 173 else:
174 174 return changegroup.getunbundler('01', cb, None)
175 175
176 176 # TODO We might want to move the next two calls into legacypeer and add
177 177 # unbundle instead.
178 178
179 179 def unbundle(self, cg, heads, url):
180 180 """apply a bundle on a repo
181 181
182 182 This function handles the repo locking itself."""
183 183 try:
184 184 try:
185 185 cg = exchange.readbundle(self.ui, cg, None)
186 186 ret = exchange.unbundle(self._repo, cg, heads, 'push', url)
187 187 if util.safehasattr(ret, 'getchunks'):
188 188 # This is a bundle20 object, turn it into an unbundler.
189 189 # This little dance should be dropped eventually when the
190 190 # API is finally improved.
191 191 stream = util.chunkbuffer(ret.getchunks())
192 192 ret = bundle2.getunbundler(self.ui, stream)
193 193 return ret
194 194 except Exception as exc:
195 195 # If the exception contains output salvaged from a bundle2
196 196 # reply, we need to make sure it is printed before continuing
197 197 # to fail. So we build a bundle2 with such output and consume
198 198 # it directly.
199 199 #
200 200 # This is not very elegant but allows a "simple" solution for
201 201 # issue4594
202 202 output = getattr(exc, '_bundle2salvagedoutput', ())
203 203 if output:
204 204 bundler = bundle2.bundle20(self._repo.ui)
205 205 for out in output:
206 206 bundler.addpart(out)
207 207 stream = util.chunkbuffer(bundler.getchunks())
208 208 b = bundle2.getunbundler(self.ui, stream)
209 209 bundle2.processbundle(self._repo, b)
210 210 raise
211 211 except error.PushRaced as exc:
212 212 raise error.ResponseError(_('push failed:'), str(exc))
213 213
214 214 def lock(self):
215 215 return self._repo.lock()
216 216
217 217 def pushkey(self, namespace, key, old, new):
218 218 return self._repo.pushkey(namespace, key, old, new)
219 219
220 220 def listkeys(self, namespace):
221 221 return self._repo.listkeys(namespace)
222 222
223 223 def debugwireargs(self, one, two, three=None, four=None, five=None):
224 224 '''used to test argument passing over the wire'''
225 225 return "%s %s %s %s %s" % (one, two, three, four, five)
226 226
227 227 class locallegacypeer(localpeer):
228 228 '''peer extension which implements legacy methods too; used for tests with
229 229 restricted capabilities'''
230 230
231 231 def __init__(self, repo):
232 232 localpeer.__init__(self, repo, caps=legacycaps)
233 233
234 234 def branches(self, nodes):
235 235 return self._repo.branches(nodes)
236 236
237 237 def between(self, pairs):
238 238 return self._repo.between(pairs)
239 239
240 240 def changegroup(self, basenodes, source):
241 241 return changegroup.changegroup(self._repo, basenodes, source)
242 242
243 243 def changegroupsubset(self, bases, heads, source):
244 244 return changegroup.changegroupsubset(self._repo, bases, heads, source)
245 245
246 246 # Increment the sub-version when the revlog v2 format changes to lock out old
247 247 # clients.
248 248 REVLOGV2_REQUIREMENT = 'exp-revlogv2.0'
249 249
250 250 class localrepository(object):
251 251
252 252 supportedformats = {
253 253 'revlogv1',
254 254 'generaldelta',
255 255 'treemanifest',
256 256 'manifestv2',
257 257 REVLOGV2_REQUIREMENT,
258 258 }
259 259 _basesupported = supportedformats | {
260 260 'store',
261 261 'fncache',
262 262 'shared',
263 263 'relshared',
264 264 'dotencode',
265 265 }
266 266 openerreqs = {
267 267 'revlogv1',
268 268 'generaldelta',
269 269 'treemanifest',
270 270 'manifestv2',
271 271 }
272 272
273 273 # a list of (ui, featureset) functions.
274 274 # only functions defined in module of enabled extensions are invoked
275 275 featuresetupfuncs = set()
276 276
277 277 def __init__(self, baseui, path, create=False):
278 278 self.requirements = set()
279 279 self.filtername = None
280 280 # wvfs: rooted at the repository root, used to access the working copy
281 281 self.wvfs = vfsmod.vfs(path, expandpath=True, realpath=True)
282 282 # vfs: rooted at .hg, used to access repo files outside of .hg/store
283 283 self.vfs = None
284 284 # svfs: usually rooted at .hg/store, used to access repository history
285 285 # If this is a shared repository, this vfs may point to another
286 286 # repository's .hg/store directory.
287 287 self.svfs = None
288 288 self.root = self.wvfs.base
289 289 self.path = self.wvfs.join(".hg")
290 290 self.origroot = path
291 291 self.auditor = pathutil.pathauditor(self.root, self._checknested)
292 292 self.nofsauditor = pathutil.pathauditor(self.root, self._checknested,
293 293 realfs=False)
294 294 self.vfs = vfsmod.vfs(self.path)
295 295 self.baseui = baseui
296 296 self.ui = baseui.copy()
297 297 self.ui.copy = baseui.copy # prevent copying repo configuration
298 298 # A list of callback to shape the phase if no data were found.
299 299 # Callback are in the form: func(repo, roots) --> processed root.
300 300 # This list it to be filled by extension during repo setup
301 301 self._phasedefaults = []
302 302 try:
303 303 self.ui.readconfig(self.vfs.join("hgrc"), self.root)
304 304 self._loadextensions()
305 305 except IOError:
306 306 pass
307 307
308 308 if self.featuresetupfuncs:
309 309 self.supported = set(self._basesupported) # use private copy
310 310 extmods = set(m.__name__ for n, m
311 311 in extensions.extensions(self.ui))
312 312 for setupfunc in self.featuresetupfuncs:
313 313 if setupfunc.__module__ in extmods:
314 314 setupfunc(self.ui, self.supported)
315 315 else:
316 316 self.supported = self._basesupported
317 317 color.setup(self.ui)
318 318
319 319 # Add compression engines.
320 320 for name in util.compengines:
321 321 engine = util.compengines[name]
322 322 if engine.revlogheader():
323 323 self.supported.add('exp-compression-%s' % name)
324 324
325 325 if not self.vfs.isdir():
326 326 if create:
327 327 self.requirements = newreporequirements(self)
328 328
329 329 if not self.wvfs.exists():
330 330 self.wvfs.makedirs()
331 331 self.vfs.makedir(notindexed=True)
332 332
333 333 if 'store' in self.requirements:
334 334 self.vfs.mkdir("store")
335 335
336 336 # create an invalid changelog
337 337 self.vfs.append(
338 338 "00changelog.i",
339 339 '\0\0\0\2' # represents revlogv2
340 340 ' dummy changelog to prevent using the old repo layout'
341 341 )
342 342 else:
343 343 raise error.RepoError(_("repository %s not found") % path)
344 344 elif create:
345 345 raise error.RepoError(_("repository %s already exists") % path)
346 346 else:
347 347 try:
348 348 self.requirements = scmutil.readrequires(
349 349 self.vfs, self.supported)
350 350 except IOError as inst:
351 351 if inst.errno != errno.ENOENT:
352 352 raise
353 353
354 354 self.sharedpath = self.path
355 355 try:
356 356 sharedpath = self.vfs.read("sharedpath").rstrip('\n')
357 357 if 'relshared' in self.requirements:
358 358 sharedpath = self.vfs.join(sharedpath)
359 359 vfs = vfsmod.vfs(sharedpath, realpath=True)
360 360 s = vfs.base
361 361 if not vfs.exists():
362 362 raise error.RepoError(
363 363 _('.hg/sharedpath points to nonexistent directory %s') % s)
364 364 self.sharedpath = s
365 365 except IOError as inst:
366 366 if inst.errno != errno.ENOENT:
367 367 raise
368 368
369 369 self.store = store.store(
370 370 self.requirements, self.sharedpath, vfsmod.vfs)
371 371 self.spath = self.store.path
372 372 self.svfs = self.store.vfs
373 373 self.sjoin = self.store.join
374 374 self.vfs.createmode = self.store.createmode
375 375 self._applyopenerreqs()
376 376 if create:
377 377 self._writerequirements()
378 378
379 379 self._dirstatevalidatewarned = False
380 380
381 381 self._branchcaches = {}
382 382 self._revbranchcache = None
383 383 self.filterpats = {}
384 384 self._datafilters = {}
385 385 self._transref = self._lockref = self._wlockref = None
386 386
387 387 # A cache for various files under .hg/ that tracks file changes,
388 388 # (used by the filecache decorator)
389 389 #
390 390 # Maps a property name to its util.filecacheentry
391 391 self._filecache = {}
392 392
393 393 # hold sets of revision to be filtered
394 394 # should be cleared when something might have changed the filter value:
395 395 # - new changesets,
396 396 # - phase change,
397 397 # - new obsolescence marker,
398 398 # - working directory parent change,
399 399 # - bookmark changes
400 400 self.filteredrevcache = {}
401 401
402 402 # post-dirstate-status hooks
403 403 self._postdsstatus = []
404 404
405 405 # generic mapping between names and nodes
406 406 self.names = namespaces.namespaces()
407 407
408 408 def close(self):
409 409 self._writecaches()
410 410
411 411 def _loadextensions(self):
412 412 extensions.loadall(self.ui)
413 413
414 414 def _writecaches(self):
415 415 if self._revbranchcache:
416 416 self._revbranchcache.write()
417 417
418 418 def _restrictcapabilities(self, caps):
419 419 if self.ui.configbool('experimental', 'bundle2-advertise', True):
420 420 caps = set(caps)
421 421 capsblob = bundle2.encodecaps(bundle2.getrepocaps(self))
422 422 caps.add('bundle2=' + urlreq.quote(capsblob))
423 423 return caps
424 424
425 425 def _applyopenerreqs(self):
426 426 self.svfs.options = dict((r, 1) for r in self.requirements
427 427 if r in self.openerreqs)
428 428 # experimental config: format.chunkcachesize
429 429 chunkcachesize = self.ui.configint('format', 'chunkcachesize')
430 430 if chunkcachesize is not None:
431 431 self.svfs.options['chunkcachesize'] = chunkcachesize
432 432 # experimental config: format.maxchainlen
433 433 maxchainlen = self.ui.configint('format', 'maxchainlen')
434 434 if maxchainlen is not None:
435 435 self.svfs.options['maxchainlen'] = maxchainlen
436 436 # experimental config: format.manifestcachesize
437 437 manifestcachesize = self.ui.configint('format', 'manifestcachesize')
438 438 if manifestcachesize is not None:
439 439 self.svfs.options['manifestcachesize'] = manifestcachesize
440 440 # experimental config: format.aggressivemergedeltas
441 441 aggressivemergedeltas = self.ui.configbool('format',
442 442 'aggressivemergedeltas')
443 443 self.svfs.options['aggressivemergedeltas'] = aggressivemergedeltas
444 444 self.svfs.options['lazydeltabase'] = not scmutil.gddeltaconfig(self.ui)
445 445 chainspan = self.ui.configbytes('experimental', 'maxdeltachainspan', -1)
446 446 if 0 <= chainspan:
447 447 self.svfs.options['maxdeltachainspan'] = chainspan
448 448
449 449 for r in self.requirements:
450 450 if r.startswith('exp-compression-'):
451 451 self.svfs.options['compengine'] = r[len('exp-compression-'):]
452 452
453 453 # TODO move "revlogv2" to openerreqs once finalized.
454 454 if REVLOGV2_REQUIREMENT in self.requirements:
455 455 self.svfs.options['revlogv2'] = True
456 456
457 457 def _writerequirements(self):
458 458 scmutil.writerequires(self.vfs, self.requirements)
459 459
460 460 def _checknested(self, path):
461 461 """Determine if path is a legal nested repository."""
462 462 if not path.startswith(self.root):
463 463 return False
464 464 subpath = path[len(self.root) + 1:]
465 465 normsubpath = util.pconvert(subpath)
466 466
467 467 # XXX: Checking against the current working copy is wrong in
468 468 # the sense that it can reject things like
469 469 #
470 470 # $ hg cat -r 10 sub/x.txt
471 471 #
472 472 # if sub/ is no longer a subrepository in the working copy
473 473 # parent revision.
474 474 #
475 475 # However, it can of course also allow things that would have
476 476 # been rejected before, such as the above cat command if sub/
477 477 # is a subrepository now, but was a normal directory before.
478 478 # The old path auditor would have rejected by mistake since it
479 479 # panics when it sees sub/.hg/.
480 480 #
481 481 # All in all, checking against the working copy seems sensible
482 482 # since we want to prevent access to nested repositories on
483 483 # the filesystem *now*.
484 484 ctx = self[None]
485 485 parts = util.splitpath(subpath)
486 486 while parts:
487 487 prefix = '/'.join(parts)
488 488 if prefix in ctx.substate:
489 489 if prefix == normsubpath:
490 490 return True
491 491 else:
492 492 sub = ctx.sub(prefix)
493 493 return sub.checknested(subpath[len(prefix) + 1:])
494 494 else:
495 495 parts.pop()
496 496 return False
497 497
498 498 def peer(self):
499 499 return localpeer(self) # not cached to avoid reference cycle
500 500
501 501 def unfiltered(self):
502 502 """Return unfiltered version of the repository
503 503
504 504 Intended to be overwritten by filtered repo."""
505 505 return self
506 506
507 507 def filtered(self, name):
508 508 """Return a filtered version of a repository"""
509 509 # build a new class with the mixin and the current class
510 510 # (possibly subclass of the repo)
511 511 class filteredrepo(repoview.repoview, self.unfiltered().__class__):
512 512 pass
513 513 return filteredrepo(self, name)
514 514
515 515 @repofilecache('bookmarks', 'bookmarks.current')
516 516 def _bookmarks(self):
517 517 return bookmarks.bmstore(self)
518 518
519 519 @property
520 520 def _activebookmark(self):
521 521 return self._bookmarks.active
522 522
523 523 # _phaserevs and _phasesets depend on changelog. what we need is to
524 524 # call _phasecache.invalidate() if '00changelog.i' was changed, but it
525 525 # can't be easily expressed in filecache mechanism.
526 526 @storecache('phaseroots', '00changelog.i')
527 527 def _phasecache(self):
528 528 return phases.phasecache(self, self._phasedefaults)
529 529
530 530 @storecache('obsstore')
531 531 def obsstore(self):
532 532 return obsolete.makestore(self.ui, self)
533 533
534 534 @storecache('00changelog.i')
535 535 def changelog(self):
536 536 return changelog.changelog(self.svfs,
537 537 trypending=txnutil.mayhavepending(self.root))
538 538
539 539 def _constructmanifest(self):
540 540 # This is a temporary function while we migrate from manifest to
541 541 # manifestlog. It allows bundlerepo and unionrepo to intercept the
542 542 # manifest creation.
543 543 return manifest.manifestrevlog(self.svfs)
544 544
545 545 @storecache('00manifest.i')
546 546 def manifestlog(self):
547 547 return manifest.manifestlog(self.svfs, self)
548 548
549 549 @repofilecache('dirstate')
550 550 def dirstate(self):
551 551 return dirstate.dirstate(self.vfs, self.ui, self.root,
552 552 self._dirstatevalidate)
553 553
554 554 def _dirstatevalidate(self, node):
555 555 try:
556 556 self.changelog.rev(node)
557 557 return node
558 558 except error.LookupError:
559 559 if not self._dirstatevalidatewarned:
560 560 self._dirstatevalidatewarned = True
561 561 self.ui.warn(_("warning: ignoring unknown"
562 562 " working parent %s!\n") % short(node))
563 563 return nullid
564 564
565 565 def __getitem__(self, changeid):
566 566 if changeid is None:
567 567 return context.workingctx(self)
568 568 if isinstance(changeid, slice):
569 569 # wdirrev isn't contiguous so the slice shouldn't include it
570 570 return [context.changectx(self, i)
571 571 for i in xrange(*changeid.indices(len(self)))
572 572 if i not in self.changelog.filteredrevs]
573 573 try:
574 574 return context.changectx(self, changeid)
575 575 except error.WdirUnsupported:
576 576 return context.workingctx(self)
577 577
578 578 def __contains__(self, changeid):
579 579 """True if the given changeid exists
580 580
581 581 error.LookupError is raised if an ambiguous node specified.
582 582 """
583 583 try:
584 584 self[changeid]
585 585 return True
586 586 except error.RepoLookupError:
587 587 return False
588 588
589 589 def __nonzero__(self):
590 590 return True
591 591
592 592 __bool__ = __nonzero__
593 593
594 594 def __len__(self):
595 595 return len(self.changelog)
596 596
597 597 def __iter__(self):
598 598 return iter(self.changelog)
599 599
600 600 def revs(self, expr, *args):
601 601 '''Find revisions matching a revset.
602 602
603 603 The revset is specified as a string ``expr`` that may contain
604 604 %-formatting to escape certain types. See ``revsetlang.formatspec``.
605 605
606 606 Revset aliases from the configuration are not expanded. To expand
607 607 user aliases, consider calling ``scmutil.revrange()`` or
608 608 ``repo.anyrevs([expr], user=True)``.
609 609
610 610 Returns a revset.abstractsmartset, which is a list-like interface
611 611 that contains integer revisions.
612 612 '''
613 613 expr = revsetlang.formatspec(expr, *args)
614 614 m = revset.match(None, expr)
615 615 return m(self)
616 616
617 617 def set(self, expr, *args):
618 618 '''Find revisions matching a revset and emit changectx instances.
619 619
620 620 This is a convenience wrapper around ``revs()`` that iterates the
621 621 result and is a generator of changectx instances.
622 622
623 623 Revset aliases from the configuration are not expanded. To expand
624 624 user aliases, consider calling ``scmutil.revrange()``.
625 625 '''
626 626 for r in self.revs(expr, *args):
627 627 yield self[r]
628 628
629 629 def anyrevs(self, specs, user=False):
630 630 '''Find revisions matching one of the given revsets.
631 631
632 632 Revset aliases from the configuration are not expanded by default. To
633 633 expand user aliases, specify ``user=True``.
634 634 '''
635 635 if user:
636 636 m = revset.matchany(self.ui, specs, repo=self)
637 637 else:
638 638 m = revset.matchany(None, specs)
639 639 return m(self)
640 640
641 641 def url(self):
642 642 return 'file:' + self.root
643 643
644 644 def hook(self, name, throw=False, **args):
645 645 """Call a hook, passing this repo instance.
646 646
647 647 This a convenience method to aid invoking hooks. Extensions likely
648 648 won't call this unless they have registered a custom hook or are
649 649 replacing code that is expected to call a hook.
650 650 """
651 651 return hook.hook(self.ui, self, name, throw, **args)
652 652
653 653 @filteredpropertycache
654 654 def _tagscache(self):
655 655 '''Returns a tagscache object that contains various tags related
656 656 caches.'''
657 657
658 658 # This simplifies its cache management by having one decorated
659 659 # function (this one) and the rest simply fetch things from it.
660 660 class tagscache(object):
661 661 def __init__(self):
662 662 # These two define the set of tags for this repository. tags
663 663 # maps tag name to node; tagtypes maps tag name to 'global' or
664 664 # 'local'. (Global tags are defined by .hgtags across all
665 665 # heads, and local tags are defined in .hg/localtags.)
666 666 # They constitute the in-memory cache of tags.
667 667 self.tags = self.tagtypes = None
668 668
669 669 self.nodetagscache = self.tagslist = None
670 670
671 671 cache = tagscache()
672 672 cache.tags, cache.tagtypes = self._findtags()
673 673
674 674 return cache
675 675
676 676 def tags(self):
677 677 '''return a mapping of tag to node'''
678 678 t = {}
679 679 if self.changelog.filteredrevs:
680 680 tags, tt = self._findtags()
681 681 else:
682 682 tags = self._tagscache.tags
683 683 for k, v in tags.iteritems():
684 684 try:
685 685 # ignore tags to unknown nodes
686 686 self.changelog.rev(v)
687 687 t[k] = v
688 688 except (error.LookupError, ValueError):
689 689 pass
690 690 return t
691 691
692 692 def _findtags(self):
693 693 '''Do the hard work of finding tags. Return a pair of dicts
694 694 (tags, tagtypes) where tags maps tag name to node, and tagtypes
695 695 maps tag name to a string like \'global\' or \'local\'.
696 696 Subclasses or extensions are free to add their own tags, but
697 697 should be aware that the returned dicts will be retained for the
698 698 duration of the localrepo object.'''
699 699
700 700 # XXX what tagtype should subclasses/extensions use? Currently
701 701 # mq and bookmarks add tags, but do not set the tagtype at all.
702 702 # Should each extension invent its own tag type? Should there
703 703 # be one tagtype for all such "virtual" tags? Or is the status
704 704 # quo fine?
705 705
706 706
707 707 # map tag name to (node, hist)
708 708 alltags = tagsmod.findglobaltags(self.ui, self)
709 709 # map tag name to tag type
710 710 tagtypes = dict((tag, 'global') for tag in alltags)
711 711
712 712 tagsmod.readlocaltags(self.ui, self, alltags, tagtypes)
713 713
714 714 # Build the return dicts. Have to re-encode tag names because
715 715 # the tags module always uses UTF-8 (in order not to lose info
716 716 # writing to the cache), but the rest of Mercurial wants them in
717 717 # local encoding.
718 718 tags = {}
719 719 for (name, (node, hist)) in alltags.iteritems():
720 720 if node != nullid:
721 721 tags[encoding.tolocal(name)] = node
722 722 tags['tip'] = self.changelog.tip()
723 723 tagtypes = dict([(encoding.tolocal(name), value)
724 724 for (name, value) in tagtypes.iteritems()])
725 725 return (tags, tagtypes)
726 726
727 727 def tagtype(self, tagname):
728 728 '''
729 729 return the type of the given tag. result can be:
730 730
731 731 'local' : a local tag
732 732 'global' : a global tag
733 733 None : tag does not exist
734 734 '''
735 735
736 736 return self._tagscache.tagtypes.get(tagname)
737 737
738 738 def tagslist(self):
739 739 '''return a list of tags ordered by revision'''
740 740 if not self._tagscache.tagslist:
741 741 l = []
742 742 for t, n in self.tags().iteritems():
743 743 l.append((self.changelog.rev(n), t, n))
744 744 self._tagscache.tagslist = [(t, n) for r, t, n in sorted(l)]
745 745
746 746 return self._tagscache.tagslist
747 747
748 748 def nodetags(self, node):
749 749 '''return the tags associated with a node'''
750 750 if not self._tagscache.nodetagscache:
751 751 nodetagscache = {}
752 752 for t, n in self._tagscache.tags.iteritems():
753 753 nodetagscache.setdefault(n, []).append(t)
754 754 for tags in nodetagscache.itervalues():
755 755 tags.sort()
756 756 self._tagscache.nodetagscache = nodetagscache
757 757 return self._tagscache.nodetagscache.get(node, [])
758 758
759 759 def nodebookmarks(self, node):
760 760 """return the list of bookmarks pointing to the specified node"""
761 761 marks = []
762 762 for bookmark, n in self._bookmarks.iteritems():
763 763 if n == node:
764 764 marks.append(bookmark)
765 765 return sorted(marks)
766 766
767 767 def branchmap(self):
768 768 '''returns a dictionary {branch: [branchheads]} with branchheads
769 769 ordered by increasing revision number'''
770 770 branchmap.updatecache(self)
771 771 return self._branchcaches[self.filtername]
772 772
773 773 @unfilteredmethod
774 774 def revbranchcache(self):
775 775 if not self._revbranchcache:
776 776 self._revbranchcache = branchmap.revbranchcache(self.unfiltered())
777 777 return self._revbranchcache
778 778
779 779 def branchtip(self, branch, ignoremissing=False):
780 780 '''return the tip node for a given branch
781 781
782 782 If ignoremissing is True, then this method will not raise an error.
783 783 This is helpful for callers that only expect None for a missing branch
784 784 (e.g. namespace).
785 785
786 786 '''
787 787 try:
788 788 return self.branchmap().branchtip(branch)
789 789 except KeyError:
790 790 if not ignoremissing:
791 791 raise error.RepoLookupError(_("unknown branch '%s'") % branch)
792 792 else:
793 793 pass
794 794
795 795 def lookup(self, key):
796 796 return self[key].node()
797 797
798 798 def lookupbranch(self, key, remote=None):
799 799 repo = remote or self
800 800 if key in repo.branchmap():
801 801 return key
802 802
803 803 repo = (remote and remote.local()) and remote or self
804 804 return repo[key].branch()
805 805
806 806 def known(self, nodes):
807 807 cl = self.changelog
808 808 nm = cl.nodemap
809 809 filtered = cl.filteredrevs
810 810 result = []
811 811 for n in nodes:
812 812 r = nm.get(n)
813 813 resp = not (r is None or r in filtered)
814 814 result.append(resp)
815 815 return result
816 816
817 817 def local(self):
818 818 return self
819 819
820 820 def publishing(self):
821 821 # it's safe (and desirable) to trust the publish flag unconditionally
822 822 # so that we don't finalize changes shared between users via ssh or nfs
823 823 return self.ui.configbool('phases', 'publish', True, untrusted=True)
824 824
825 825 def cancopy(self):
826 826 # so statichttprepo's override of local() works
827 827 if not self.local():
828 828 return False
829 829 if not self.publishing():
830 830 return True
831 831 # if publishing we can't copy if there is filtered content
832 832 return not self.filtered('visible').changelog.filteredrevs
833 833
834 834 def shared(self):
835 835 '''the type of shared repository (None if not shared)'''
836 836 if self.sharedpath != self.path:
837 837 return 'store'
838 838 return None
839 839
840 840 def wjoin(self, f, *insidef):
841 841 return self.vfs.reljoin(self.root, f, *insidef)
842 842
843 843 def file(self, f):
844 844 if f[0] == '/':
845 845 f = f[1:]
846 846 return filelog.filelog(self.svfs, f)
847 847
848 848 def changectx(self, changeid):
849 849 return self[changeid]
850 850
851 851 def setparents(self, p1, p2=nullid):
852 852 with self.dirstate.parentchange():
853 853 copies = self.dirstate.setparents(p1, p2)
854 854 pctx = self[p1]
855 855 if copies:
856 856 # Adjust copy records, the dirstate cannot do it, it
857 857 # requires access to parents manifests. Preserve them
858 858 # only for entries added to first parent.
859 859 for f in copies:
860 860 if f not in pctx and copies[f] in pctx:
861 861 self.dirstate.copy(copies[f], f)
862 862 if p2 == nullid:
863 863 for f, s in sorted(self.dirstate.copies().items()):
864 864 if f not in pctx and s not in pctx:
865 865 self.dirstate.copy(None, f)
866 866
867 867 def filectx(self, path, changeid=None, fileid=None):
868 868 """changeid can be a changeset revision, node, or tag.
869 869 fileid can be a file revision or node."""
870 870 return context.filectx(self, path, changeid, fileid)
871 871
872 872 def getcwd(self):
873 873 return self.dirstate.getcwd()
874 874
875 875 def pathto(self, f, cwd=None):
876 876 return self.dirstate.pathto(f, cwd)
877 877
878 878 def _loadfilter(self, filter):
879 879 if filter not in self.filterpats:
880 880 l = []
881 881 for pat, cmd in self.ui.configitems(filter):
882 882 if cmd == '!':
883 883 continue
884 884 mf = matchmod.match(self.root, '', [pat])
885 885 fn = None
886 886 params = cmd
887 887 for name, filterfn in self._datafilters.iteritems():
888 888 if cmd.startswith(name):
889 889 fn = filterfn
890 890 params = cmd[len(name):].lstrip()
891 891 break
892 892 if not fn:
893 893 fn = lambda s, c, **kwargs: util.filter(s, c)
894 894 # Wrap old filters not supporting keyword arguments
895 895 if not inspect.getargspec(fn)[2]:
896 896 oldfn = fn
897 897 fn = lambda s, c, **kwargs: oldfn(s, c)
898 898 l.append((mf, fn, params))
899 899 self.filterpats[filter] = l
900 900 return self.filterpats[filter]
901 901
902 902 def _filter(self, filterpats, filename, data):
903 903 for mf, fn, cmd in filterpats:
904 904 if mf(filename):
905 905 self.ui.debug("filtering %s through %s\n" % (filename, cmd))
906 906 data = fn(data, cmd, ui=self.ui, repo=self, filename=filename)
907 907 break
908 908
909 909 return data
910 910
911 911 @unfilteredpropertycache
912 912 def _encodefilterpats(self):
913 913 return self._loadfilter('encode')
914 914
915 915 @unfilteredpropertycache
916 916 def _decodefilterpats(self):
917 917 return self._loadfilter('decode')
918 918
919 919 def adddatafilter(self, name, filter):
920 920 self._datafilters[name] = filter
921 921
922 922 def wread(self, filename):
923 923 if self.wvfs.islink(filename):
924 924 data = self.wvfs.readlink(filename)
925 925 else:
926 926 data = self.wvfs.read(filename)
927 927 return self._filter(self._encodefilterpats, filename, data)
928 928
929 929 def wwrite(self, filename, data, flags, backgroundclose=False):
930 930 """write ``data`` into ``filename`` in the working directory
931 931
932 932 This returns length of written (maybe decoded) data.
933 933 """
934 934 data = self._filter(self._decodefilterpats, filename, data)
935 935 if 'l' in flags:
936 936 self.wvfs.symlink(data, filename)
937 937 else:
938 938 self.wvfs.write(filename, data, backgroundclose=backgroundclose)
939 939 if 'x' in flags:
940 940 self.wvfs.setflags(filename, False, True)
941 941 return len(data)
942 942
943 943 def wwritedata(self, filename, data):
944 944 return self._filter(self._decodefilterpats, filename, data)
945 945
946 946 def currenttransaction(self):
947 947 """return the current transaction or None if non exists"""
948 948 if self._transref:
949 949 tr = self._transref()
950 950 else:
951 951 tr = None
952 952
953 953 if tr and tr.running():
954 954 return tr
955 955 return None
956 956
957 957 def transaction(self, desc, report=None):
958 958 if (self.ui.configbool('devel', 'all-warnings')
959 959 or self.ui.configbool('devel', 'check-locks')):
960 960 if self._currentlock(self._lockref) is None:
961 961 raise error.ProgrammingError('transaction requires locking')
962 962 tr = self.currenttransaction()
963 963 if tr is not None:
964 964 return tr.nest()
965 965
966 966 # abort here if the journal already exists
967 967 if self.svfs.exists("journal"):
968 968 raise error.RepoError(
969 969 _("abandoned transaction found"),
970 970 hint=_("run 'hg recover' to clean up transaction"))
971 971
972 972 idbase = "%.40f#%f" % (random.random(), time.time())
973 973 ha = hex(hashlib.sha1(idbase).digest())
974 974 txnid = 'TXN:' + ha
975 975 self.hook('pretxnopen', throw=True, txnname=desc, txnid=txnid)
976 976
977 977 self._writejournal(desc)
978 978 renames = [(vfs, x, undoname(x)) for vfs, x in self._journalfiles()]
979 979 if report:
980 980 rp = report
981 981 else:
982 982 rp = self.ui.warn
983 983 vfsmap = {'plain': self.vfs} # root of .hg/
984 984 # we must avoid cyclic reference between repo and transaction.
985 985 reporef = weakref.ref(self)
986 986 # Code to track tag movement
987 987 #
988 988 # Since tags are all handled as file content, it is actually quite hard
989 989 # to track these movement from a code perspective. So we fallback to a
990 990 # tracking at the repository level. One could envision to track changes
991 991 # to the '.hgtags' file through changegroup apply but that fails to
992 992 # cope with case where transaction expose new heads without changegroup
993 993 # being involved (eg: phase movement).
994 994 #
995 995 # For now, We gate the feature behind a flag since this likely comes
996 996 # with performance impacts. The current code run more often than needed
997 997 # and do not use caches as much as it could. The current focus is on
998 998 # the behavior of the feature so we disable it by default. The flag
999 999 # will be removed when we are happy with the performance impact.
1000 1000 #
1001 1001 # Once this feature is no longer experimental move the following
1002 1002 # documentation to the appropriate help section:
1003 1003 #
1004 1004 # The ``HG_TAG_MOVED`` variable will be set if the transaction touched
1005 1005 # tags (new or changed or deleted tags). In addition the details of
1006 1006 # these changes are made available in a file at:
1007 1007 # ``REPOROOT/.hg/changes/tags.changes``.
1008 1008 # Make sure you check for HG_TAG_MOVED before reading that file as it
1009 1009 # might exist from a previous transaction even if no tag were touched
1010 1010 # in this one. Changes are recorded in a line base format::
1011 1011 #
1012 1012 # <action> <hex-node> <tag-name>\n
1013 1013 #
1014 1014 # Actions are defined as follow:
1015 1015 # "-R": tag is removed,
1016 1016 # "+A": tag is added,
1017 1017 # "-M": tag is moved (old value),
1018 1018 # "+M": tag is moved (new value),
1019 1019 tracktags = lambda x: None
1020 1020 # experimental config: experimental.hook-track-tags
1021 1021 shouldtracktags = self.ui.configbool('experimental', 'hook-track-tags',
1022 1022 False)
1023 1023 if desc != 'strip' and shouldtracktags:
1024 1024 oldheads = self.changelog.headrevs()
1025 1025 def tracktags(tr2):
1026 1026 repo = reporef()
1027 1027 oldfnodes = tagsmod.fnoderevs(repo.ui, repo, oldheads)
1028 1028 newheads = repo.changelog.headrevs()
1029 1029 newfnodes = tagsmod.fnoderevs(repo.ui, repo, newheads)
1030 1030 # notes: we compare lists here.
1031 1031 # As we do it only once buiding set would not be cheaper
1032 1032 changes = tagsmod.difftags(repo.ui, repo, oldfnodes, newfnodes)
1033 1033 if changes:
1034 1034 tr2.hookargs['tag_moved'] = '1'
1035 1035 with repo.vfs('changes/tags.changes', 'w',
1036 1036 atomictemp=True) as changesfile:
1037 1037 # note: we do not register the file to the transaction
1038 1038 # because we needs it to still exist on the transaction
1039 1039 # is close (for txnclose hooks)
1040 1040 tagsmod.writediff(changesfile, changes)
1041 1041 def validate(tr2):
1042 1042 """will run pre-closing hooks"""
1043 1043 # XXX the transaction API is a bit lacking here so we take a hacky
1044 1044 # path for now
1045 1045 #
1046 1046 # We cannot add this as a "pending" hooks since the 'tr.hookargs'
1047 1047 # dict is copied before these run. In addition we needs the data
1048 1048 # available to in memory hooks too.
1049 1049 #
1050 1050 # Moreover, we also need to make sure this runs before txnclose
1051 1051 # hooks and there is no "pending" mechanism that would execute
1052 1052 # logic only if hooks are about to run.
1053 1053 #
1054 1054 # Fixing this limitation of the transaction is also needed to track
1055 1055 # other families of changes (bookmarks, phases, obsolescence).
1056 1056 #
1057 1057 # This will have to be fixed before we remove the experimental
1058 1058 # gating.
1059 1059 tracktags(tr2)
1060 1060 reporef().hook('pretxnclose', throw=True,
1061 1061 txnname=desc, **pycompat.strkwargs(tr.hookargs))
1062 1062 def releasefn(tr, success):
1063 1063 repo = reporef()
1064 1064 if success:
1065 1065 # this should be explicitly invoked here, because
1066 1066 # in-memory changes aren't written out at closing
1067 1067 # transaction, if tr.addfilegenerator (via
1068 1068 # dirstate.write or so) isn't invoked while
1069 1069 # transaction running
1070 1070 repo.dirstate.write(None)
1071 1071 else:
1072 1072 # discard all changes (including ones already written
1073 1073 # out) in this transaction
1074 1074 repo.dirstate.restorebackup(None, prefix='journal.')
1075 1075
1076 1076 repo.invalidate(clearfilecache=True)
1077 1077
1078 1078 tr = transaction.transaction(rp, self.svfs, vfsmap,
1079 1079 "journal",
1080 1080 "undo",
1081 1081 aftertrans(renames),
1082 1082 self.store.createmode,
1083 1083 validator=validate,
1084 1084 releasefn=releasefn)
1085 1085 tr.changes['revs'] = set()
1086 1086
1087 1087 tr.hookargs['txnid'] = txnid
1088 1088 # note: writing the fncache only during finalize mean that the file is
1089 1089 # outdated when running hooks. As fncache is used for streaming clone,
1090 1090 # this is not expected to break anything that happen during the hooks.
1091 1091 tr.addfinalize('flush-fncache', self.store.write)
1092 1092 def txnclosehook(tr2):
1093 1093 """To be run if transaction is successful, will schedule a hook run
1094 1094 """
1095 1095 # Don't reference tr2 in hook() so we don't hold a reference.
1096 1096 # This reduces memory consumption when there are multiple
1097 1097 # transactions per lock. This can likely go away if issue5045
1098 1098 # fixes the function accumulation.
1099 1099 hookargs = tr2.hookargs
1100 1100
1101 1101 def hook():
1102 1102 reporef().hook('txnclose', throw=False, txnname=desc,
1103 1103 **pycompat.strkwargs(hookargs))
1104 1104 reporef()._afterlock(hook)
1105 1105 tr.addfinalize('txnclose-hook', txnclosehook)
1106 1106 tr.addpostclose('warms-cache', self._buildcacheupdater(tr))
1107 1107 def txnaborthook(tr2):
1108 1108 """To be run if transaction is aborted
1109 1109 """
1110 1110 reporef().hook('txnabort', throw=False, txnname=desc,
1111 1111 **tr2.hookargs)
1112 1112 tr.addabort('txnabort-hook', txnaborthook)
1113 1113 # avoid eager cache invalidation. in-memory data should be identical
1114 1114 # to stored data if transaction has no error.
1115 1115 tr.addpostclose('refresh-filecachestats', self._refreshfilecachestats)
1116 1116 self._transref = weakref.ref(tr)
1117 1117 return tr
1118 1118
1119 1119 def _journalfiles(self):
1120 1120 return ((self.svfs, 'journal'),
1121 1121 (self.vfs, 'journal.dirstate'),
1122 1122 (self.vfs, 'journal.branch'),
1123 1123 (self.vfs, 'journal.desc'),
1124 1124 (self.vfs, 'journal.bookmarks'),
1125 1125 (self.svfs, 'journal.phaseroots'))
1126 1126
1127 1127 def undofiles(self):
1128 1128 return [(vfs, undoname(x)) for vfs, x in self._journalfiles()]
1129 1129
1130 1130 @unfilteredmethod
1131 1131 def _writejournal(self, desc):
1132 1132 self.dirstate.savebackup(None, prefix='journal.')
1133 1133 self.vfs.write("journal.branch",
1134 1134 encoding.fromlocal(self.dirstate.branch()))
1135 1135 self.vfs.write("journal.desc",
1136 1136 "%d\n%s\n" % (len(self), desc))
1137 1137 self.vfs.write("journal.bookmarks",
1138 1138 self.vfs.tryread("bookmarks"))
1139 1139 self.svfs.write("journal.phaseroots",
1140 1140 self.svfs.tryread("phaseroots"))
1141 1141
1142 1142 def recover(self):
1143 1143 with self.lock():
1144 1144 if self.svfs.exists("journal"):
1145 1145 self.ui.status(_("rolling back interrupted transaction\n"))
1146 1146 vfsmap = {'': self.svfs,
1147 1147 'plain': self.vfs,}
1148 1148 transaction.rollback(self.svfs, vfsmap, "journal",
1149 1149 self.ui.warn)
1150 1150 self.invalidate()
1151 1151 return True
1152 1152 else:
1153 1153 self.ui.warn(_("no interrupted transaction available\n"))
1154 1154 return False
1155 1155
1156 1156 def rollback(self, dryrun=False, force=False):
1157 1157 wlock = lock = dsguard = None
1158 1158 try:
1159 1159 wlock = self.wlock()
1160 1160 lock = self.lock()
1161 1161 if self.svfs.exists("undo"):
1162 1162 dsguard = dirstateguard.dirstateguard(self, 'rollback')
1163 1163
1164 1164 return self._rollback(dryrun, force, dsguard)
1165 1165 else:
1166 1166 self.ui.warn(_("no rollback information available\n"))
1167 1167 return 1
1168 1168 finally:
1169 1169 release(dsguard, lock, wlock)
1170 1170
1171 1171 @unfilteredmethod # Until we get smarter cache management
1172 1172 def _rollback(self, dryrun, force, dsguard):
1173 1173 ui = self.ui
1174 1174 try:
1175 1175 args = self.vfs.read('undo.desc').splitlines()
1176 1176 (oldlen, desc, detail) = (int(args[0]), args[1], None)
1177 1177 if len(args) >= 3:
1178 1178 detail = args[2]
1179 1179 oldtip = oldlen - 1
1180 1180
1181 1181 if detail and ui.verbose:
1182 1182 msg = (_('repository tip rolled back to revision %d'
1183 1183 ' (undo %s: %s)\n')
1184 1184 % (oldtip, desc, detail))
1185 1185 else:
1186 1186 msg = (_('repository tip rolled back to revision %d'
1187 1187 ' (undo %s)\n')
1188 1188 % (oldtip, desc))
1189 1189 except IOError:
1190 1190 msg = _('rolling back unknown transaction\n')
1191 1191 desc = None
1192 1192
1193 1193 if not force and self['.'] != self['tip'] and desc == 'commit':
1194 1194 raise error.Abort(
1195 1195 _('rollback of last commit while not checked out '
1196 1196 'may lose data'), hint=_('use -f to force'))
1197 1197
1198 1198 ui.status(msg)
1199 1199 if dryrun:
1200 1200 return 0
1201 1201
1202 1202 parents = self.dirstate.parents()
1203 1203 self.destroying()
1204 1204 vfsmap = {'plain': self.vfs, '': self.svfs}
1205 1205 transaction.rollback(self.svfs, vfsmap, 'undo', ui.warn)
1206 1206 if self.vfs.exists('undo.bookmarks'):
1207 1207 self.vfs.rename('undo.bookmarks', 'bookmarks', checkambig=True)
1208 1208 if self.svfs.exists('undo.phaseroots'):
1209 1209 self.svfs.rename('undo.phaseroots', 'phaseroots', checkambig=True)
1210 1210 self.invalidate()
1211 1211
1212 1212 parentgone = (parents[0] not in self.changelog.nodemap or
1213 1213 parents[1] not in self.changelog.nodemap)
1214 1214 if parentgone:
1215 1215 # prevent dirstateguard from overwriting already restored one
1216 1216 dsguard.close()
1217 1217
1218 1218 self.dirstate.restorebackup(None, prefix='undo.')
1219 1219 try:
1220 1220 branch = self.vfs.read('undo.branch')
1221 1221 self.dirstate.setbranch(encoding.tolocal(branch))
1222 1222 except IOError:
1223 1223 ui.warn(_('named branch could not be reset: '
1224 1224 'current branch is still \'%s\'\n')
1225 1225 % self.dirstate.branch())
1226 1226
1227 1227 parents = tuple([p.rev() for p in self[None].parents()])
1228 1228 if len(parents) > 1:
1229 1229 ui.status(_('working directory now based on '
1230 1230 'revisions %d and %d\n') % parents)
1231 1231 else:
1232 1232 ui.status(_('working directory now based on '
1233 1233 'revision %d\n') % parents)
1234 1234 mergemod.mergestate.clean(self, self['.'].node())
1235 1235
1236 1236 # TODO: if we know which new heads may result from this rollback, pass
1237 1237 # them to destroy(), which will prevent the branchhead cache from being
1238 1238 # invalidated.
1239 1239 self.destroyed()
1240 1240 return 0
1241 1241
1242 1242 def _buildcacheupdater(self, newtransaction):
1243 1243 """called during transaction to build the callback updating cache
1244 1244
1245 1245 Lives on the repository to help extension who might want to augment
1246 1246 this logic. For this purpose, the created transaction is passed to the
1247 1247 method.
1248 1248 """
1249 1249 # we must avoid cyclic reference between repo and transaction.
1250 1250 reporef = weakref.ref(self)
1251 1251 def updater(tr):
1252 1252 repo = reporef()
1253 1253 repo.updatecaches(tr)
1254 1254 return updater
1255 1255
1256 1256 @unfilteredmethod
1257 1257 def updatecaches(self, tr=None):
1258 1258 """warm appropriate caches
1259 1259
1260 1260 If this function is called after a transaction closed. The transaction
1261 1261 will be available in the 'tr' argument. This can be used to selectively
1262 1262 update caches relevant to the changes in that transaction.
1263 1263 """
1264 1264 if tr is not None and tr.hookargs.get('source') == 'strip':
1265 1265 # During strip, many caches are invalid but
1266 1266 # later call to `destroyed` will refresh them.
1267 1267 return
1268 1268
1269 1269 if tr is None or tr.changes['revs']:
1270 1270 # updating the unfiltered branchmap should refresh all the others,
1271 1271 self.ui.debug('updating the branch cache\n')
1272 1272 branchmap.updatecache(self.filtered('served'))
1273 1273
1274 1274 def invalidatecaches(self):
1275 1275
1276 1276 if '_tagscache' in vars(self):
1277 1277 # can't use delattr on proxy
1278 1278 del self.__dict__['_tagscache']
1279 1279
1280 1280 self.unfiltered()._branchcaches.clear()
1281 1281 self.invalidatevolatilesets()
1282 1282
1283 1283 def invalidatevolatilesets(self):
1284 1284 self.filteredrevcache.clear()
1285 1285 obsolete.clearobscaches(self)
1286 1286
1287 1287 def invalidatedirstate(self):
1288 1288 '''Invalidates the dirstate, causing the next call to dirstate
1289 1289 to check if it was modified since the last time it was read,
1290 1290 rereading it if it has.
1291 1291
1292 1292 This is different to dirstate.invalidate() that it doesn't always
1293 1293 rereads the dirstate. Use dirstate.invalidate() if you want to
1294 1294 explicitly read the dirstate again (i.e. restoring it to a previous
1295 1295 known good state).'''
1296 1296 if hasunfilteredcache(self, 'dirstate'):
1297 1297 for k in self.dirstate._filecache:
1298 1298 try:
1299 1299 delattr(self.dirstate, k)
1300 1300 except AttributeError:
1301 1301 pass
1302 1302 delattr(self.unfiltered(), 'dirstate')
1303 1303
1304 1304 def invalidate(self, clearfilecache=False):
1305 1305 '''Invalidates both store and non-store parts other than dirstate
1306 1306
1307 1307 If a transaction is running, invalidation of store is omitted,
1308 1308 because discarding in-memory changes might cause inconsistency
1309 1309 (e.g. incomplete fncache causes unintentional failure, but
1310 1310 redundant one doesn't).
1311 1311 '''
1312 1312 unfiltered = self.unfiltered() # all file caches are stored unfiltered
1313 1313 for k in list(self._filecache.keys()):
1314 1314 # dirstate is invalidated separately in invalidatedirstate()
1315 1315 if k == 'dirstate':
1316 1316 continue
1317 1317
1318 1318 if clearfilecache:
1319 1319 del self._filecache[k]
1320 1320 try:
1321 1321 delattr(unfiltered, k)
1322 1322 except AttributeError:
1323 1323 pass
1324 1324 self.invalidatecaches()
1325 1325 if not self.currenttransaction():
1326 1326 # TODO: Changing contents of store outside transaction
1327 1327 # causes inconsistency. We should make in-memory store
1328 1328 # changes detectable, and abort if changed.
1329 1329 self.store.invalidatecaches()
1330 1330
1331 1331 def invalidateall(self):
1332 1332 '''Fully invalidates both store and non-store parts, causing the
1333 1333 subsequent operation to reread any outside changes.'''
1334 1334 # extension should hook this to invalidate its caches
1335 1335 self.invalidate()
1336 1336 self.invalidatedirstate()
1337 1337
1338 1338 @unfilteredmethod
1339 1339 def _refreshfilecachestats(self, tr):
1340 1340 """Reload stats of cached files so that they are flagged as valid"""
1341 1341 for k, ce in self._filecache.items():
1342 1342 if k == 'dirstate' or k not in self.__dict__:
1343 1343 continue
1344 1344 ce.refresh()
1345 1345
1346 1346 def _lock(self, vfs, lockname, wait, releasefn, acquirefn, desc,
1347 1347 inheritchecker=None, parentenvvar=None):
1348 1348 parentlock = None
1349 1349 # the contents of parentenvvar are used by the underlying lock to
1350 1350 # determine whether it can be inherited
1351 1351 if parentenvvar is not None:
1352 1352 parentlock = encoding.environ.get(parentenvvar)
1353 1353 try:
1354 1354 l = lockmod.lock(vfs, lockname, 0, releasefn=releasefn,
1355 1355 acquirefn=acquirefn, desc=desc,
1356 1356 inheritchecker=inheritchecker,
1357 1357 parentlock=parentlock)
1358 1358 except error.LockHeld as inst:
1359 1359 if not wait:
1360 1360 raise
1361 1361 # show more details for new-style locks
1362 1362 if ':' in inst.locker:
1363 1363 host, pid = inst.locker.split(":", 1)
1364 1364 self.ui.warn(
1365 1365 _("waiting for lock on %s held by process %r "
1366 1366 "on host %r\n") % (desc, pid, host))
1367 1367 else:
1368 1368 self.ui.warn(_("waiting for lock on %s held by %r\n") %
1369 1369 (desc, inst.locker))
1370 1370 # default to 600 seconds timeout
1371 1371 l = lockmod.lock(vfs, lockname,
1372 1372 int(self.ui.config("ui", "timeout", "600")),
1373 1373 releasefn=releasefn, acquirefn=acquirefn,
1374 1374 desc=desc)
1375 1375 self.ui.warn(_("got lock after %s seconds\n") % l.delay)
1376 1376 return l
1377 1377
1378 1378 def _afterlock(self, callback):
1379 1379 """add a callback to be run when the repository is fully unlocked
1380 1380
1381 1381 The callback will be executed when the outermost lock is released
1382 1382 (with wlock being higher level than 'lock')."""
1383 1383 for ref in (self._wlockref, self._lockref):
1384 1384 l = ref and ref()
1385 1385 if l and l.held:
1386 1386 l.postrelease.append(callback)
1387 1387 break
1388 1388 else: # no lock have been found.
1389 1389 callback()
1390 1390
1391 1391 def lock(self, wait=True):
1392 1392 '''Lock the repository store (.hg/store) and return a weak reference
1393 1393 to the lock. Use this before modifying the store (e.g. committing or
1394 1394 stripping). If you are opening a transaction, get a lock as well.)
1395 1395
1396 1396 If both 'lock' and 'wlock' must be acquired, ensure you always acquires
1397 1397 'wlock' first to avoid a dead-lock hazard.'''
1398 1398 l = self._currentlock(self._lockref)
1399 1399 if l is not None:
1400 1400 l.lock()
1401 1401 return l
1402 1402
1403 1403 l = self._lock(self.svfs, "lock", wait, None,
1404 1404 self.invalidate, _('repository %s') % self.origroot)
1405 1405 self._lockref = weakref.ref(l)
1406 1406 return l
1407 1407
1408 1408 def _wlockchecktransaction(self):
1409 1409 if self.currenttransaction() is not None:
1410 1410 raise error.LockInheritanceContractViolation(
1411 1411 'wlock cannot be inherited in the middle of a transaction')
1412 1412
1413 1413 def wlock(self, wait=True):
1414 1414 '''Lock the non-store parts of the repository (everything under
1415 1415 .hg except .hg/store) and return a weak reference to the lock.
1416 1416
1417 1417 Use this before modifying files in .hg.
1418 1418
1419 1419 If both 'lock' and 'wlock' must be acquired, ensure you always acquires
1420 1420 'wlock' first to avoid a dead-lock hazard.'''
1421 1421 l = self._wlockref and self._wlockref()
1422 1422 if l is not None and l.held:
1423 1423 l.lock()
1424 1424 return l
1425 1425
1426 1426 # We do not need to check for non-waiting lock acquisition. Such
1427 1427 # acquisition would not cause dead-lock as they would just fail.
1428 1428 if wait and (self.ui.configbool('devel', 'all-warnings')
1429 1429 or self.ui.configbool('devel', 'check-locks')):
1430 1430 if self._currentlock(self._lockref) is not None:
1431 1431 self.ui.develwarn('"wlock" acquired after "lock"')
1432 1432
1433 1433 def unlock():
1434 1434 if self.dirstate.pendingparentchange():
1435 1435 self.dirstate.invalidate()
1436 1436 else:
1437 1437 self.dirstate.write(None)
1438 1438
1439 1439 self._filecache['dirstate'].refresh()
1440 1440
1441 1441 l = self._lock(self.vfs, "wlock", wait, unlock,
1442 1442 self.invalidatedirstate, _('working directory of %s') %
1443 1443 self.origroot,
1444 1444 inheritchecker=self._wlockchecktransaction,
1445 1445 parentenvvar='HG_WLOCK_LOCKER')
1446 1446 self._wlockref = weakref.ref(l)
1447 1447 return l
1448 1448
1449 1449 def _currentlock(self, lockref):
1450 1450 """Returns the lock if it's held, or None if it's not."""
1451 1451 if lockref is None:
1452 1452 return None
1453 1453 l = lockref()
1454 1454 if l is None or not l.held:
1455 1455 return None
1456 1456 return l
1457 1457
1458 1458 def currentwlock(self):
1459 1459 """Returns the wlock if it's held, or None if it's not."""
1460 1460 return self._currentlock(self._wlockref)
1461 1461
1462 1462 def _filecommit(self, fctx, manifest1, manifest2, linkrev, tr, changelist):
1463 1463 """
1464 1464 commit an individual file as part of a larger transaction
1465 1465 """
1466 1466
1467 1467 fname = fctx.path()
1468 1468 fparent1 = manifest1.get(fname, nullid)
1469 1469 fparent2 = manifest2.get(fname, nullid)
1470 1470 if isinstance(fctx, context.filectx):
1471 1471 node = fctx.filenode()
1472 1472 if node in [fparent1, fparent2]:
1473 1473 self.ui.debug('reusing %s filelog entry\n' % fname)
1474 1474 if manifest1.flags(fname) != fctx.flags():
1475 1475 changelist.append(fname)
1476 1476 return node
1477 1477
1478 1478 flog = self.file(fname)
1479 1479 meta = {}
1480 1480 copy = fctx.renamed()
1481 1481 if copy and copy[0] != fname:
1482 1482 # Mark the new revision of this file as a copy of another
1483 1483 # file. This copy data will effectively act as a parent
1484 1484 # of this new revision. If this is a merge, the first
1485 1485 # parent will be the nullid (meaning "look up the copy data")
1486 1486 # and the second one will be the other parent. For example:
1487 1487 #
1488 1488 # 0 --- 1 --- 3 rev1 changes file foo
1489 1489 # \ / rev2 renames foo to bar and changes it
1490 1490 # \- 2 -/ rev3 should have bar with all changes and
1491 1491 # should record that bar descends from
1492 1492 # bar in rev2 and foo in rev1
1493 1493 #
1494 1494 # this allows this merge to succeed:
1495 1495 #
1496 1496 # 0 --- 1 --- 3 rev4 reverts the content change from rev2
1497 1497 # \ / merging rev3 and rev4 should use bar@rev2
1498 1498 # \- 2 --- 4 as the merge base
1499 1499 #
1500 1500
1501 1501 cfname = copy[0]
1502 1502 crev = manifest1.get(cfname)
1503 1503 newfparent = fparent2
1504 1504
1505 1505 if manifest2: # branch merge
1506 1506 if fparent2 == nullid or crev is None: # copied on remote side
1507 1507 if cfname in manifest2:
1508 1508 crev = manifest2[cfname]
1509 1509 newfparent = fparent1
1510 1510
1511 1511 # Here, we used to search backwards through history to try to find
1512 1512 # where the file copy came from if the source of a copy was not in
1513 1513 # the parent directory. However, this doesn't actually make sense to
1514 1514 # do (what does a copy from something not in your working copy even
1515 1515 # mean?) and it causes bugs (eg, issue4476). Instead, we will warn
1516 1516 # the user that copy information was dropped, so if they didn't
1517 1517 # expect this outcome it can be fixed, but this is the correct
1518 1518 # behavior in this circumstance.
1519 1519
1520 1520 if crev:
1521 1521 self.ui.debug(" %s: copy %s:%s\n" % (fname, cfname, hex(crev)))
1522 1522 meta["copy"] = cfname
1523 1523 meta["copyrev"] = hex(crev)
1524 1524 fparent1, fparent2 = nullid, newfparent
1525 1525 else:
1526 1526 self.ui.warn(_("warning: can't find ancestor for '%s' "
1527 1527 "copied from '%s'!\n") % (fname, cfname))
1528 1528
1529 1529 elif fparent1 == nullid:
1530 1530 fparent1, fparent2 = fparent2, nullid
1531 1531 elif fparent2 != nullid:
1532 1532 # is one parent an ancestor of the other?
1533 1533 fparentancestors = flog.commonancestorsheads(fparent1, fparent2)
1534 1534 if fparent1 in fparentancestors:
1535 1535 fparent1, fparent2 = fparent2, nullid
1536 1536 elif fparent2 in fparentancestors:
1537 1537 fparent2 = nullid
1538 1538
1539 1539 # is the file changed?
1540 1540 text = fctx.data()
1541 1541 if fparent2 != nullid or flog.cmp(fparent1, text) or meta:
1542 1542 changelist.append(fname)
1543 1543 return flog.add(text, meta, tr, linkrev, fparent1, fparent2)
1544 1544 # are just the flags changed during merge?
1545 1545 elif fname in manifest1 and manifest1.flags(fname) != fctx.flags():
1546 1546 changelist.append(fname)
1547 1547
1548 1548 return fparent1
1549 1549
1550 1550 def checkcommitpatterns(self, wctx, vdirs, match, status, fail):
1551 1551 """check for commit arguments that aren't committable"""
1552 1552 if match.isexact() or match.prefix():
1553 1553 matched = set(status.modified + status.added + status.removed)
1554 1554
1555 1555 for f in match.files():
1556 1556 f = self.dirstate.normalize(f)
1557 1557 if f == '.' or f in matched or f in wctx.substate:
1558 1558 continue
1559 1559 if f in status.deleted:
1560 1560 fail(f, _('file not found!'))
1561 1561 if f in vdirs: # visited directory
1562 1562 d = f + '/'
1563 1563 for mf in matched:
1564 1564 if mf.startswith(d):
1565 1565 break
1566 1566 else:
1567 1567 fail(f, _("no match under directory!"))
1568 1568 elif f not in self.dirstate:
1569 1569 fail(f, _("file not tracked!"))
1570 1570
1571 1571 @unfilteredmethod
1572 1572 def commit(self, text="", user=None, date=None, match=None, force=False,
1573 1573 editor=False, extra=None):
1574 1574 """Add a new revision to current repository.
1575 1575
1576 1576 Revision information is gathered from the working directory,
1577 1577 match can be used to filter the committed files. If editor is
1578 1578 supplied, it is called to get a commit message.
1579 1579 """
1580 1580 if extra is None:
1581 1581 extra = {}
1582 1582
1583 1583 def fail(f, msg):
1584 1584 raise error.Abort('%s: %s' % (f, msg))
1585 1585
1586 1586 if not match:
1587 1587 match = matchmod.always(self.root, '')
1588 1588
1589 1589 if not force:
1590 1590 vdirs = []
1591 1591 match.explicitdir = vdirs.append
1592 1592 match.bad = fail
1593 1593
1594 1594 wlock = lock = tr = None
1595 1595 try:
1596 1596 wlock = self.wlock()
1597 1597 lock = self.lock() # for recent changelog (see issue4368)
1598 1598
1599 1599 wctx = self[None]
1600 1600 merge = len(wctx.parents()) > 1
1601 1601
1602 1602 if not force and merge and not match.always():
1603 1603 raise error.Abort(_('cannot partially commit a merge '
1604 1604 '(do not specify files or patterns)'))
1605 1605
1606 1606 status = self.status(match=match, clean=force)
1607 1607 if force:
1608 1608 status.modified.extend(status.clean) # mq may commit clean files
1609 1609
1610 1610 # check subrepos
1611 1611 subs = []
1612 1612 commitsubs = set()
1613 1613 newstate = wctx.substate.copy()
1614 1614 # only manage subrepos and .hgsubstate if .hgsub is present
1615 1615 if '.hgsub' in wctx:
1616 1616 # we'll decide whether to track this ourselves, thanks
1617 1617 for c in status.modified, status.added, status.removed:
1618 1618 if '.hgsubstate' in c:
1619 1619 c.remove('.hgsubstate')
1620 1620
1621 1621 # compare current state to last committed state
1622 1622 # build new substate based on last committed state
1623 1623 oldstate = wctx.p1().substate
1624 1624 for s in sorted(newstate.keys()):
1625 1625 if not match(s):
1626 1626 # ignore working copy, use old state if present
1627 1627 if s in oldstate:
1628 1628 newstate[s] = oldstate[s]
1629 1629 continue
1630 1630 if not force:
1631 1631 raise error.Abort(
1632 1632 _("commit with new subrepo %s excluded") % s)
1633 1633 dirtyreason = wctx.sub(s).dirtyreason(True)
1634 1634 if dirtyreason:
1635 1635 if not self.ui.configbool('ui', 'commitsubrepos'):
1636 1636 raise error.Abort(dirtyreason,
1637 1637 hint=_("use --subrepos for recursive commit"))
1638 1638 subs.append(s)
1639 1639 commitsubs.add(s)
1640 1640 else:
1641 1641 bs = wctx.sub(s).basestate()
1642 1642 newstate[s] = (newstate[s][0], bs, newstate[s][2])
1643 1643 if oldstate.get(s, (None, None, None))[1] != bs:
1644 1644 subs.append(s)
1645 1645
1646 1646 # check for removed subrepos
1647 1647 for p in wctx.parents():
1648 1648 r = [s for s in p.substate if s not in newstate]
1649 1649 subs += [s for s in r if match(s)]
1650 1650 if subs:
1651 1651 if (not match('.hgsub') and
1652 1652 '.hgsub' in (wctx.modified() + wctx.added())):
1653 1653 raise error.Abort(
1654 1654 _("can't commit subrepos without .hgsub"))
1655 1655 status.modified.insert(0, '.hgsubstate')
1656 1656
1657 1657 elif '.hgsub' in status.removed:
1658 1658 # clean up .hgsubstate when .hgsub is removed
1659 1659 if ('.hgsubstate' in wctx and
1660 1660 '.hgsubstate' not in (status.modified + status.added +
1661 1661 status.removed)):
1662 1662 status.removed.insert(0, '.hgsubstate')
1663 1663
1664 1664 # make sure all explicit patterns are matched
1665 1665 if not force:
1666 1666 self.checkcommitpatterns(wctx, vdirs, match, status, fail)
1667 1667
1668 1668 cctx = context.workingcommitctx(self, status,
1669 1669 text, user, date, extra)
1670 1670
1671 1671 # internal config: ui.allowemptycommit
1672 1672 allowemptycommit = (wctx.branch() != wctx.p1().branch()
1673 1673 or extra.get('close') or merge or cctx.files()
1674 1674 or self.ui.configbool('ui', 'allowemptycommit'))
1675 1675 if not allowemptycommit:
1676 1676 return None
1677 1677
1678 1678 if merge and cctx.deleted():
1679 1679 raise error.Abort(_("cannot commit merge with missing files"))
1680 1680
1681 1681 ms = mergemod.mergestate.read(self)
1682 1682 mergeutil.checkunresolved(ms)
1683 1683
1684 1684 if editor:
1685 1685 cctx._text = editor(self, cctx, subs)
1686 1686 edited = (text != cctx._text)
1687 1687
1688 1688 # Save commit message in case this transaction gets rolled back
1689 1689 # (e.g. by a pretxncommit hook). Leave the content alone on
1690 1690 # the assumption that the user will use the same editor again.
1691 1691 msgfn = self.savecommitmessage(cctx._text)
1692 1692
1693 1693 # commit subs and write new state
1694 1694 if subs:
1695 1695 for s in sorted(commitsubs):
1696 1696 sub = wctx.sub(s)
1697 1697 self.ui.status(_('committing subrepository %s\n') %
1698 1698 subrepo.subrelpath(sub))
1699 1699 sr = sub.commit(cctx._text, user, date)
1700 1700 newstate[s] = (newstate[s][0], sr)
1701 1701 subrepo.writestate(self, newstate)
1702 1702
1703 1703 p1, p2 = self.dirstate.parents()
1704 1704 hookp1, hookp2 = hex(p1), (p2 != nullid and hex(p2) or '')
1705 1705 try:
1706 1706 self.hook("precommit", throw=True, parent1=hookp1,
1707 1707 parent2=hookp2)
1708 1708 tr = self.transaction('commit')
1709 1709 ret = self.commitctx(cctx, True)
1710 1710 except: # re-raises
1711 1711 if edited:
1712 1712 self.ui.write(
1713 1713 _('note: commit message saved in %s\n') % msgfn)
1714 1714 raise
1715 1715 # update bookmarks, dirstate and mergestate
1716 1716 bookmarks.update(self, [p1, p2], ret)
1717 1717 cctx.markcommitted(ret)
1718 1718 ms.reset()
1719 1719 tr.close()
1720 1720
1721 1721 finally:
1722 1722 lockmod.release(tr, lock, wlock)
1723 1723
1724 1724 def commithook(node=hex(ret), parent1=hookp1, parent2=hookp2):
1725 1725 # hack for command that use a temporary commit (eg: histedit)
1726 1726 # temporary commit got stripped before hook release
1727 1727 if self.changelog.hasnode(ret):
1728 1728 self.hook("commit", node=node, parent1=parent1,
1729 1729 parent2=parent2)
1730 1730 self._afterlock(commithook)
1731 1731 return ret
1732 1732
1733 1733 @unfilteredmethod
1734 1734 def commitctx(self, ctx, error=False):
1735 1735 """Add a new revision to current repository.
1736 1736 Revision information is passed via the context argument.
1737 1737 """
1738 1738
1739 1739 tr = None
1740 1740 p1, p2 = ctx.p1(), ctx.p2()
1741 1741 user = ctx.user()
1742 1742
1743 1743 lock = self.lock()
1744 1744 try:
1745 1745 tr = self.transaction("commit")
1746 1746 trp = weakref.proxy(tr)
1747 1747
1748 1748 if ctx.manifestnode():
1749 1749 # reuse an existing manifest revision
1750 1750 mn = ctx.manifestnode()
1751 1751 files = ctx.files()
1752 1752 elif ctx.files():
1753 1753 m1ctx = p1.manifestctx()
1754 1754 m2ctx = p2.manifestctx()
1755 1755 mctx = m1ctx.copy()
1756 1756
1757 1757 m = mctx.read()
1758 1758 m1 = m1ctx.read()
1759 1759 m2 = m2ctx.read()
1760 1760
1761 1761 # check in files
1762 1762 added = []
1763 1763 changed = []
1764 1764 removed = list(ctx.removed())
1765 1765 linkrev = len(self)
1766 1766 self.ui.note(_("committing files:\n"))
1767 1767 for f in sorted(ctx.modified() + ctx.added()):
1768 1768 self.ui.note(f + "\n")
1769 1769 try:
1770 1770 fctx = ctx[f]
1771 1771 if fctx is None:
1772 1772 removed.append(f)
1773 1773 else:
1774 1774 added.append(f)
1775 1775 m[f] = self._filecommit(fctx, m1, m2, linkrev,
1776 1776 trp, changed)
1777 1777 m.setflag(f, fctx.flags())
1778 1778 except OSError as inst:
1779 1779 self.ui.warn(_("trouble committing %s!\n") % f)
1780 1780 raise
1781 1781 except IOError as inst:
1782 1782 errcode = getattr(inst, 'errno', errno.ENOENT)
1783 1783 if error or errcode and errcode != errno.ENOENT:
1784 1784 self.ui.warn(_("trouble committing %s!\n") % f)
1785 1785 raise
1786 1786
1787 1787 # update manifest
1788 1788 self.ui.note(_("committing manifest\n"))
1789 1789 removed = [f for f in sorted(removed) if f in m1 or f in m2]
1790 1790 drop = [f for f in removed if f in m]
1791 1791 for f in drop:
1792 1792 del m[f]
1793 1793 mn = mctx.write(trp, linkrev,
1794 1794 p1.manifestnode(), p2.manifestnode(),
1795 1795 added, drop)
1796 1796 files = changed + removed
1797 1797 else:
1798 1798 mn = p1.manifestnode()
1799 1799 files = []
1800 1800
1801 1801 # update changelog
1802 1802 self.ui.note(_("committing changelog\n"))
1803 1803 self.changelog.delayupdate(tr)
1804 1804 n = self.changelog.add(mn, files, ctx.description(),
1805 1805 trp, p1.node(), p2.node(),
1806 1806 user, ctx.date(), ctx.extra().copy())
1807 1807 xp1, xp2 = p1.hex(), p2 and p2.hex() or ''
1808 1808 self.hook('pretxncommit', throw=True, node=hex(n), parent1=xp1,
1809 1809 parent2=xp2)
1810 1810 # set the new commit is proper phase
1811 1811 targetphase = subrepo.newcommitphase(self.ui, ctx)
1812 1812 if targetphase:
1813 1813 # retract boundary do not alter parent changeset.
1814 1814 # if a parent have higher the resulting phase will
1815 1815 # be compliant anyway
1816 1816 #
1817 1817 # if minimal phase was 0 we don't need to retract anything
1818 1818 phases.retractboundary(self, tr, targetphase, [n])
1819 1819 tr.close()
1820 1820 return n
1821 1821 finally:
1822 1822 if tr:
1823 1823 tr.release()
1824 1824 lock.release()
1825 1825
1826 1826 @unfilteredmethod
1827 1827 def destroying(self):
1828 1828 '''Inform the repository that nodes are about to be destroyed.
1829 1829 Intended for use by strip and rollback, so there's a common
1830 1830 place for anything that has to be done before destroying history.
1831 1831
1832 1832 This is mostly useful for saving state that is in memory and waiting
1833 1833 to be flushed when the current lock is released. Because a call to
1834 1834 destroyed is imminent, the repo will be invalidated causing those
1835 1835 changes to stay in memory (waiting for the next unlock), or vanish
1836 1836 completely.
1837 1837 '''
1838 1838 # When using the same lock to commit and strip, the phasecache is left
1839 1839 # dirty after committing. Then when we strip, the repo is invalidated,
1840 1840 # causing those changes to disappear.
1841 1841 if '_phasecache' in vars(self):
1842 1842 self._phasecache.write()
1843 1843
1844 1844 @unfilteredmethod
1845 1845 def destroyed(self):
1846 1846 '''Inform the repository that nodes have been destroyed.
1847 1847 Intended for use by strip and rollback, so there's a common
1848 1848 place for anything that has to be done after destroying history.
1849 1849 '''
1850 1850 # When one tries to:
1851 1851 # 1) destroy nodes thus calling this method (e.g. strip)
1852 1852 # 2) use phasecache somewhere (e.g. commit)
1853 1853 #
1854 1854 # then 2) will fail because the phasecache contains nodes that were
1855 1855 # removed. We can either remove phasecache from the filecache,
1856 1856 # causing it to reload next time it is accessed, or simply filter
1857 1857 # the removed nodes now and write the updated cache.
1858 1858 self._phasecache.filterunknown(self)
1859 1859 self._phasecache.write()
1860 1860
1861 1861 # refresh all repository caches
1862 1862 self.updatecaches()
1863 1863
1864 1864 # Ensure the persistent tag cache is updated. Doing it now
1865 1865 # means that the tag cache only has to worry about destroyed
1866 1866 # heads immediately after a strip/rollback. That in turn
1867 1867 # guarantees that "cachetip == currenttip" (comparing both rev
1868 1868 # and node) always means no nodes have been added or destroyed.
1869 1869
1870 1870 # XXX this is suboptimal when qrefresh'ing: we strip the current
1871 1871 # head, refresh the tag cache, then immediately add a new head.
1872 1872 # But I think doing it this way is necessary for the "instant
1873 1873 # tag cache retrieval" case to work.
1874 1874 self.invalidate()
1875 1875
1876 1876 def walk(self, match, node=None):
1877 1877 '''
1878 1878 walk recursively through the directory tree or a given
1879 1879 changeset, finding all files matched by the match
1880 1880 function
1881 1881 '''
1882 1882 self.ui.deprecwarn('use repo[node].walk instead of repo.walk', '4.3')
1883 1883 return self[node].walk(match)
1884 1884
1885 1885 def status(self, node1='.', node2=None, match=None,
1886 1886 ignored=False, clean=False, unknown=False,
1887 1887 listsubrepos=False):
1888 1888 '''a convenience method that calls node1.status(node2)'''
1889 1889 return self[node1].status(node2, match, ignored, clean, unknown,
1890 1890 listsubrepos)
1891 1891
1892 1892 def addpostdsstatus(self, ps):
1893 1893 """Add a callback to run within the wlock, at the point at which status
1894 1894 fixups happen.
1895 1895
1896 1896 On status completion, callback(wctx, status) will be called with the
1897 1897 wlock held, unless the dirstate has changed from underneath or the wlock
1898 1898 couldn't be grabbed.
1899 1899
1900 1900 Callbacks should not capture and use a cached copy of the dirstate --
1901 1901 it might change in the meanwhile. Instead, they should access the
1902 1902 dirstate via wctx.repo().dirstate.
1903 1903
1904 1904 This list is emptied out after each status run -- extensions should
1905 1905 make sure it adds to this list each time dirstate.status is called.
1906 1906 Extensions should also make sure they don't call this for statuses
1907 1907 that don't involve the dirstate.
1908 1908 """
1909 1909
1910 1910 # The list is located here for uniqueness reasons -- it is actually
1911 1911 # managed by the workingctx, but that isn't unique per-repo.
1912 1912 self._postdsstatus.append(ps)
1913 1913
1914 1914 def postdsstatus(self):
1915 1915 """Used by workingctx to get the list of post-dirstate-status hooks."""
1916 1916 return self._postdsstatus
1917 1917
1918 1918 def clearpostdsstatus(self):
1919 1919 """Used by workingctx to clear post-dirstate-status hooks."""
1920 1920 del self._postdsstatus[:]
1921 1921
1922 1922 def heads(self, start=None):
1923 1923 if start is None:
1924 1924 cl = self.changelog
1925 1925 headrevs = reversed(cl.headrevs())
1926 1926 return [cl.node(rev) for rev in headrevs]
1927 1927
1928 1928 heads = self.changelog.heads(start)
1929 1929 # sort the output in rev descending order
1930 1930 return sorted(heads, key=self.changelog.rev, reverse=True)
1931 1931
1932 1932 def branchheads(self, branch=None, start=None, closed=False):
1933 1933 '''return a (possibly filtered) list of heads for the given branch
1934 1934
1935 1935 Heads are returned in topological order, from newest to oldest.
1936 1936 If branch is None, use the dirstate branch.
1937 1937 If start is not None, return only heads reachable from start.
1938 1938 If closed is True, return heads that are marked as closed as well.
1939 1939 '''
1940 1940 if branch is None:
1941 1941 branch = self[None].branch()
1942 1942 branches = self.branchmap()
1943 1943 if branch not in branches:
1944 1944 return []
1945 1945 # the cache returns heads ordered lowest to highest
1946 1946 bheads = list(reversed(branches.branchheads(branch, closed=closed)))
1947 1947 if start is not None:
1948 1948 # filter out the heads that cannot be reached from startrev
1949 1949 fbheads = set(self.changelog.nodesbetween([start], bheads)[2])
1950 1950 bheads = [h for h in bheads if h in fbheads]
1951 1951 return bheads
1952 1952
1953 1953 def branches(self, nodes):
1954 1954 if not nodes:
1955 1955 nodes = [self.changelog.tip()]
1956 1956 b = []
1957 1957 for n in nodes:
1958 1958 t = n
1959 1959 while True:
1960 1960 p = self.changelog.parents(n)
1961 1961 if p[1] != nullid or p[0] == nullid:
1962 1962 b.append((t, n, p[0], p[1]))
1963 1963 break
1964 1964 n = p[0]
1965 1965 return b
1966 1966
1967 1967 def between(self, pairs):
1968 1968 r = []
1969 1969
1970 1970 for top, bottom in pairs:
1971 1971 n, l, i = top, [], 0
1972 1972 f = 1
1973 1973
1974 1974 while n != bottom and n != nullid:
1975 1975 p = self.changelog.parents(n)[0]
1976 1976 if i == f:
1977 1977 l.append(n)
1978 1978 f = f * 2
1979 1979 n = p
1980 1980 i += 1
1981 1981
1982 1982 r.append(l)
1983 1983
1984 1984 return r
1985 1985
1986 1986 def checkpush(self, pushop):
1987 1987 """Extensions can override this function if additional checks have
1988 1988 to be performed before pushing, or call it if they override push
1989 1989 command.
1990 1990 """
1991 1991 pass
1992 1992
1993 1993 @unfilteredpropertycache
1994 1994 def prepushoutgoinghooks(self):
1995 1995 """Return util.hooks consists of a pushop with repo, remote, outgoing
1996 1996 methods, which are called before pushing changesets.
1997 1997 """
1998 1998 return util.hooks()
1999 1999
2000 2000 def pushkey(self, namespace, key, old, new):
2001 2001 try:
2002 2002 tr = self.currenttransaction()
2003 2003 hookargs = {}
2004 2004 if tr is not None:
2005 2005 hookargs.update(tr.hookargs)
2006 2006 hookargs['namespace'] = namespace
2007 2007 hookargs['key'] = key
2008 2008 hookargs['old'] = old
2009 2009 hookargs['new'] = new
2010 2010 self.hook('prepushkey', throw=True, **hookargs)
2011 2011 except error.HookAbort as exc:
2012 2012 self.ui.write_err(_("pushkey-abort: %s\n") % exc)
2013 2013 if exc.hint:
2014 2014 self.ui.write_err(_("(%s)\n") % exc.hint)
2015 2015 return False
2016 2016 self.ui.debug('pushing key for "%s:%s"\n' % (namespace, key))
2017 2017 ret = pushkey.push(self, namespace, key, old, new)
2018 2018 def runhook():
2019 2019 self.hook('pushkey', namespace=namespace, key=key, old=old, new=new,
2020 2020 ret=ret)
2021 2021 self._afterlock(runhook)
2022 2022 return ret
2023 2023
2024 2024 def listkeys(self, namespace):
2025 2025 self.hook('prelistkeys', throw=True, namespace=namespace)
2026 2026 self.ui.debug('listing keys for "%s"\n' % namespace)
2027 2027 values = pushkey.list(self, namespace)
2028 2028 self.hook('listkeys', namespace=namespace, values=values)
2029 2029 return values
2030 2030
2031 2031 def debugwireargs(self, one, two, three=None, four=None, five=None):
2032 2032 '''used to test argument passing over the wire'''
2033 2033 return "%s %s %s %s %s" % (one, two, three, four, five)
2034 2034
2035 2035 def savecommitmessage(self, text):
2036 2036 fp = self.vfs('last-message.txt', 'wb')
2037 2037 try:
2038 2038 fp.write(text)
2039 2039 finally:
2040 2040 fp.close()
2041 2041 return self.pathto(fp.name[len(self.root) + 1:])
2042 2042
2043 2043 # used to avoid circular references so destructors work
2044 2044 def aftertrans(files):
2045 2045 renamefiles = [tuple(t) for t in files]
2046 2046 def a():
2047 2047 for vfs, src, dest in renamefiles:
2048 2048 # if src and dest refer to a same file, vfs.rename is a no-op,
2049 2049 # leaving both src and dest on disk. delete dest to make sure
2050 2050 # the rename couldn't be such a no-op.
2051 2051 vfs.tryunlink(dest)
2052 2052 try:
2053 2053 vfs.rename(src, dest)
2054 2054 except OSError: # journal file does not yet exist
2055 2055 pass
2056 2056 return a
2057 2057
2058 2058 def undoname(fn):
2059 2059 base, name = os.path.split(fn)
2060 2060 assert name.startswith('journal')
2061 2061 return os.path.join(base, name.replace('journal', 'undo', 1))
2062 2062
2063 2063 def instance(ui, path, create):
2064 2064 return localrepository(ui, util.urllocalpath(path), create)
2065 2065
2066 2066 def islocal(path):
2067 2067 return True
2068 2068
2069 2069 def newreporequirements(repo):
2070 2070 """Determine the set of requirements for a new local repository.
2071 2071
2072 2072 Extensions can wrap this function to specify custom requirements for
2073 2073 new repositories.
2074 2074 """
2075 2075 ui = repo.ui
2076 2076 requirements = {'revlogv1'}
2077 if ui.configbool('format', 'usestore', True):
2077 if ui.configbool('format', 'usestore'):
2078 2078 requirements.add('store')
2079 2079 if ui.configbool('format', 'usefncache'):
2080 2080 requirements.add('fncache')
2081 2081 if ui.configbool('format', 'dotencode'):
2082 2082 requirements.add('dotencode')
2083 2083
2084 2084 compengine = ui.config('experimental', 'format.compression', 'zlib')
2085 2085 if compengine not in util.compengines:
2086 2086 raise error.Abort(_('compression engine %s defined by '
2087 2087 'experimental.format.compression not available') %
2088 2088 compengine,
2089 2089 hint=_('run "hg debuginstall" to list available '
2090 2090 'compression engines'))
2091 2091
2092 2092 # zlib is the historical default and doesn't need an explicit requirement.
2093 2093 if compengine != 'zlib':
2094 2094 requirements.add('exp-compression-%s' % compengine)
2095 2095
2096 2096 if scmutil.gdinitconfig(ui):
2097 2097 requirements.add('generaldelta')
2098 2098 if ui.configbool('experimental', 'treemanifest', False):
2099 2099 requirements.add('treemanifest')
2100 2100 if ui.configbool('experimental', 'manifestv2', False):
2101 2101 requirements.add('manifestv2')
2102 2102
2103 2103 revlogv2 = ui.config('experimental', 'revlogv2')
2104 2104 if revlogv2 == 'enable-unstable-format-and-corrupt-my-data':
2105 2105 requirements.remove('revlogv1')
2106 2106 # generaldelta is implied by revlogv2.
2107 2107 requirements.discard('generaldelta')
2108 2108 requirements.add(REVLOGV2_REQUIREMENT)
2109 2109
2110 2110 return requirements
General Comments 0
You need to be logged in to leave comments. Login now