##// END OF EJS Templates
localrepo: introduce a `_refreshchangelog` method...
marmoute -
r42710:3472a3f9 stable
parent child Browse files
Show More
@@ -1,660 +1,665 b''
1 # bundlerepo.py - repository class for viewing uncompressed bundles
1 # bundlerepo.py - repository class for viewing uncompressed bundles
2 #
2 #
3 # Copyright 2006, 2007 Benoit Boissinot <bboissin@gmail.com>
3 # Copyright 2006, 2007 Benoit Boissinot <bboissin@gmail.com>
4 #
4 #
5 # This software may be used and distributed according to the terms of the
5 # This software may be used and distributed according to the terms of the
6 # GNU General Public License version 2 or any later version.
6 # GNU General Public License version 2 or any later version.
7
7
8 """Repository class for viewing uncompressed bundles.
8 """Repository class for viewing uncompressed bundles.
9
9
10 This provides a read-only repository interface to bundles as if they
10 This provides a read-only repository interface to bundles as if they
11 were part of the actual repository.
11 were part of the actual repository.
12 """
12 """
13
13
14 from __future__ import absolute_import
14 from __future__ import absolute_import
15
15
16 import os
16 import os
17 import shutil
17 import shutil
18
18
19 from .i18n import _
19 from .i18n import _
20 from .node import nullid
20 from .node import nullid
21
21
22 from . import (
22 from . import (
23 bundle2,
23 bundle2,
24 changegroup,
24 changegroup,
25 changelog,
25 changelog,
26 cmdutil,
26 cmdutil,
27 discovery,
27 discovery,
28 encoding,
28 encoding,
29 error,
29 error,
30 exchange,
30 exchange,
31 filelog,
31 filelog,
32 localrepo,
32 localrepo,
33 manifest,
33 manifest,
34 mdiff,
34 mdiff,
35 node as nodemod,
35 node as nodemod,
36 pathutil,
36 pathutil,
37 phases,
37 phases,
38 pycompat,
38 pycompat,
39 revlog,
39 revlog,
40 util,
40 util,
41 vfs as vfsmod,
41 vfs as vfsmod,
42 )
42 )
43
43
44 class bundlerevlog(revlog.revlog):
44 class bundlerevlog(revlog.revlog):
45 def __init__(self, opener, indexfile, cgunpacker, linkmapper):
45 def __init__(self, opener, indexfile, cgunpacker, linkmapper):
46 # How it works:
46 # How it works:
47 # To retrieve a revision, we need to know the offset of the revision in
47 # To retrieve a revision, we need to know the offset of the revision in
48 # the bundle (an unbundle object). We store this offset in the index
48 # the bundle (an unbundle object). We store this offset in the index
49 # (start). The base of the delta is stored in the base field.
49 # (start). The base of the delta is stored in the base field.
50 #
50 #
51 # To differentiate a rev in the bundle from a rev in the revlog, we
51 # To differentiate a rev in the bundle from a rev in the revlog, we
52 # check revision against repotiprev.
52 # check revision against repotiprev.
53 opener = vfsmod.readonlyvfs(opener)
53 opener = vfsmod.readonlyvfs(opener)
54 revlog.revlog.__init__(self, opener, indexfile)
54 revlog.revlog.__init__(self, opener, indexfile)
55 self.bundle = cgunpacker
55 self.bundle = cgunpacker
56 n = len(self)
56 n = len(self)
57 self.repotiprev = n - 1
57 self.repotiprev = n - 1
58 self.bundlerevs = set() # used by 'bundle()' revset expression
58 self.bundlerevs = set() # used by 'bundle()' revset expression
59 for deltadata in cgunpacker.deltaiter():
59 for deltadata in cgunpacker.deltaiter():
60 node, p1, p2, cs, deltabase, delta, flags = deltadata
60 node, p1, p2, cs, deltabase, delta, flags = deltadata
61
61
62 size = len(delta)
62 size = len(delta)
63 start = cgunpacker.tell() - size
63 start = cgunpacker.tell() - size
64
64
65 link = linkmapper(cs)
65 link = linkmapper(cs)
66 if node in self.nodemap:
66 if node in self.nodemap:
67 # this can happen if two branches make the same change
67 # this can happen if two branches make the same change
68 self.bundlerevs.add(self.nodemap[node])
68 self.bundlerevs.add(self.nodemap[node])
69 continue
69 continue
70
70
71 for p in (p1, p2):
71 for p in (p1, p2):
72 if p not in self.nodemap:
72 if p not in self.nodemap:
73 raise error.LookupError(p, self.indexfile,
73 raise error.LookupError(p, self.indexfile,
74 _("unknown parent"))
74 _("unknown parent"))
75
75
76 if deltabase not in self.nodemap:
76 if deltabase not in self.nodemap:
77 raise LookupError(deltabase, self.indexfile,
77 raise LookupError(deltabase, self.indexfile,
78 _('unknown delta base'))
78 _('unknown delta base'))
79
79
80 baserev = self.rev(deltabase)
80 baserev = self.rev(deltabase)
81 # start, size, full unc. size, base (unused), link, p1, p2, node
81 # start, size, full unc. size, base (unused), link, p1, p2, node
82 e = (revlog.offset_type(start, flags), size, -1, baserev, link,
82 e = (revlog.offset_type(start, flags), size, -1, baserev, link,
83 self.rev(p1), self.rev(p2), node)
83 self.rev(p1), self.rev(p2), node)
84 self.index.append(e)
84 self.index.append(e)
85 self.nodemap[node] = n
85 self.nodemap[node] = n
86 self.bundlerevs.add(n)
86 self.bundlerevs.add(n)
87 n += 1
87 n += 1
88
88
89 def _chunk(self, rev, df=None):
89 def _chunk(self, rev, df=None):
90 # Warning: in case of bundle, the diff is against what we stored as
90 # Warning: in case of bundle, the diff is against what we stored as
91 # delta base, not against rev - 1
91 # delta base, not against rev - 1
92 # XXX: could use some caching
92 # XXX: could use some caching
93 if rev <= self.repotiprev:
93 if rev <= self.repotiprev:
94 return revlog.revlog._chunk(self, rev)
94 return revlog.revlog._chunk(self, rev)
95 self.bundle.seek(self.start(rev))
95 self.bundle.seek(self.start(rev))
96 return self.bundle.read(self.length(rev))
96 return self.bundle.read(self.length(rev))
97
97
98 def revdiff(self, rev1, rev2):
98 def revdiff(self, rev1, rev2):
99 """return or calculate a delta between two revisions"""
99 """return or calculate a delta between two revisions"""
100 if rev1 > self.repotiprev and rev2 > self.repotiprev:
100 if rev1 > self.repotiprev and rev2 > self.repotiprev:
101 # hot path for bundle
101 # hot path for bundle
102 revb = self.index[rev2][3]
102 revb = self.index[rev2][3]
103 if revb == rev1:
103 if revb == rev1:
104 return self._chunk(rev2)
104 return self._chunk(rev2)
105 elif rev1 <= self.repotiprev and rev2 <= self.repotiprev:
105 elif rev1 <= self.repotiprev and rev2 <= self.repotiprev:
106 return revlog.revlog.revdiff(self, rev1, rev2)
106 return revlog.revlog.revdiff(self, rev1, rev2)
107
107
108 return mdiff.textdiff(self.revision(rev1, raw=True),
108 return mdiff.textdiff(self.revision(rev1, raw=True),
109 self.revision(rev2, raw=True))
109 self.revision(rev2, raw=True))
110
110
111 def revision(self, nodeorrev, _df=None, raw=False):
111 def revision(self, nodeorrev, _df=None, raw=False):
112 """return an uncompressed revision of a given node or revision
112 """return an uncompressed revision of a given node or revision
113 number.
113 number.
114 """
114 """
115 if isinstance(nodeorrev, int):
115 if isinstance(nodeorrev, int):
116 rev = nodeorrev
116 rev = nodeorrev
117 node = self.node(rev)
117 node = self.node(rev)
118 else:
118 else:
119 node = nodeorrev
119 node = nodeorrev
120 rev = self.rev(node)
120 rev = self.rev(node)
121
121
122 if node == nullid:
122 if node == nullid:
123 return ""
123 return ""
124
124
125 rawtext = None
125 rawtext = None
126 chain = []
126 chain = []
127 iterrev = rev
127 iterrev = rev
128 # reconstruct the revision if it is from a changegroup
128 # reconstruct the revision if it is from a changegroup
129 while iterrev > self.repotiprev:
129 while iterrev > self.repotiprev:
130 if self._revisioncache and self._revisioncache[1] == iterrev:
130 if self._revisioncache and self._revisioncache[1] == iterrev:
131 rawtext = self._revisioncache[2]
131 rawtext = self._revisioncache[2]
132 break
132 break
133 chain.append(iterrev)
133 chain.append(iterrev)
134 iterrev = self.index[iterrev][3]
134 iterrev = self.index[iterrev][3]
135 if rawtext is None:
135 if rawtext is None:
136 rawtext = self.baserevision(iterrev)
136 rawtext = self.baserevision(iterrev)
137
137
138 while chain:
138 while chain:
139 delta = self._chunk(chain.pop())
139 delta = self._chunk(chain.pop())
140 rawtext = mdiff.patches(rawtext, [delta])
140 rawtext = mdiff.patches(rawtext, [delta])
141
141
142 text, validatehash = self._processflags(rawtext, self.flags(rev),
142 text, validatehash = self._processflags(rawtext, self.flags(rev),
143 'read', raw=raw)
143 'read', raw=raw)
144 if validatehash:
144 if validatehash:
145 self.checkhash(text, node, rev=rev)
145 self.checkhash(text, node, rev=rev)
146 self._revisioncache = (node, rev, rawtext)
146 self._revisioncache = (node, rev, rawtext)
147 return text
147 return text
148
148
149 def baserevision(self, nodeorrev):
149 def baserevision(self, nodeorrev):
150 # Revlog subclasses may override 'revision' method to modify format of
150 # Revlog subclasses may override 'revision' method to modify format of
151 # content retrieved from revlog. To use bundlerevlog with such class one
151 # content retrieved from revlog. To use bundlerevlog with such class one
152 # needs to override 'baserevision' and make more specific call here.
152 # needs to override 'baserevision' and make more specific call here.
153 return revlog.revlog.revision(self, nodeorrev, raw=True)
153 return revlog.revlog.revision(self, nodeorrev, raw=True)
154
154
155 def addrevision(self, *args, **kwargs):
155 def addrevision(self, *args, **kwargs):
156 raise NotImplementedError
156 raise NotImplementedError
157
157
158 def addgroup(self, *args, **kwargs):
158 def addgroup(self, *args, **kwargs):
159 raise NotImplementedError
159 raise NotImplementedError
160
160
161 def strip(self, *args, **kwargs):
161 def strip(self, *args, **kwargs):
162 raise NotImplementedError
162 raise NotImplementedError
163
163
164 def checksize(self):
164 def checksize(self):
165 raise NotImplementedError
165 raise NotImplementedError
166
166
167 class bundlechangelog(bundlerevlog, changelog.changelog):
167 class bundlechangelog(bundlerevlog, changelog.changelog):
168 def __init__(self, opener, cgunpacker):
168 def __init__(self, opener, cgunpacker):
169 changelog.changelog.__init__(self, opener)
169 changelog.changelog.__init__(self, opener)
170 linkmapper = lambda x: x
170 linkmapper = lambda x: x
171 bundlerevlog.__init__(self, opener, self.indexfile, cgunpacker,
171 bundlerevlog.__init__(self, opener, self.indexfile, cgunpacker,
172 linkmapper)
172 linkmapper)
173
173
174 def baserevision(self, nodeorrev):
174 def baserevision(self, nodeorrev):
175 # Although changelog doesn't override 'revision' method, some extensions
175 # Although changelog doesn't override 'revision' method, some extensions
176 # may replace this class with another that does. Same story with
176 # may replace this class with another that does. Same story with
177 # manifest and filelog classes.
177 # manifest and filelog classes.
178
178
179 # This bypasses filtering on changelog.node() and rev() because we need
179 # This bypasses filtering on changelog.node() and rev() because we need
180 # revision text of the bundle base even if it is hidden.
180 # revision text of the bundle base even if it is hidden.
181 oldfilter = self.filteredrevs
181 oldfilter = self.filteredrevs
182 try:
182 try:
183 self.filteredrevs = ()
183 self.filteredrevs = ()
184 return changelog.changelog.revision(self, nodeorrev, raw=True)
184 return changelog.changelog.revision(self, nodeorrev, raw=True)
185 finally:
185 finally:
186 self.filteredrevs = oldfilter
186 self.filteredrevs = oldfilter
187
187
188 class bundlemanifest(bundlerevlog, manifest.manifestrevlog):
188 class bundlemanifest(bundlerevlog, manifest.manifestrevlog):
189 def __init__(self, opener, cgunpacker, linkmapper, dirlogstarts=None,
189 def __init__(self, opener, cgunpacker, linkmapper, dirlogstarts=None,
190 dir=''):
190 dir=''):
191 manifest.manifestrevlog.__init__(self, opener, tree=dir)
191 manifest.manifestrevlog.__init__(self, opener, tree=dir)
192 bundlerevlog.__init__(self, opener, self.indexfile, cgunpacker,
192 bundlerevlog.__init__(self, opener, self.indexfile, cgunpacker,
193 linkmapper)
193 linkmapper)
194 if dirlogstarts is None:
194 if dirlogstarts is None:
195 dirlogstarts = {}
195 dirlogstarts = {}
196 if self.bundle.version == "03":
196 if self.bundle.version == "03":
197 dirlogstarts = _getfilestarts(self.bundle)
197 dirlogstarts = _getfilestarts(self.bundle)
198 self._dirlogstarts = dirlogstarts
198 self._dirlogstarts = dirlogstarts
199 self._linkmapper = linkmapper
199 self._linkmapper = linkmapper
200
200
201 def baserevision(self, nodeorrev):
201 def baserevision(self, nodeorrev):
202 node = nodeorrev
202 node = nodeorrev
203 if isinstance(node, int):
203 if isinstance(node, int):
204 node = self.node(node)
204 node = self.node(node)
205
205
206 if node in self.fulltextcache:
206 if node in self.fulltextcache:
207 result = '%s' % self.fulltextcache[node]
207 result = '%s' % self.fulltextcache[node]
208 else:
208 else:
209 result = manifest.manifestrevlog.revision(self, nodeorrev, raw=True)
209 result = manifest.manifestrevlog.revision(self, nodeorrev, raw=True)
210 return result
210 return result
211
211
212 def dirlog(self, d):
212 def dirlog(self, d):
213 if d in self._dirlogstarts:
213 if d in self._dirlogstarts:
214 self.bundle.seek(self._dirlogstarts[d])
214 self.bundle.seek(self._dirlogstarts[d])
215 return bundlemanifest(
215 return bundlemanifest(
216 self.opener, self.bundle, self._linkmapper,
216 self.opener, self.bundle, self._linkmapper,
217 self._dirlogstarts, dir=d)
217 self._dirlogstarts, dir=d)
218 return super(bundlemanifest, self).dirlog(d)
218 return super(bundlemanifest, self).dirlog(d)
219
219
220 class bundlefilelog(filelog.filelog):
220 class bundlefilelog(filelog.filelog):
221 def __init__(self, opener, path, cgunpacker, linkmapper):
221 def __init__(self, opener, path, cgunpacker, linkmapper):
222 filelog.filelog.__init__(self, opener, path)
222 filelog.filelog.__init__(self, opener, path)
223 self._revlog = bundlerevlog(opener, self.indexfile,
223 self._revlog = bundlerevlog(opener, self.indexfile,
224 cgunpacker, linkmapper)
224 cgunpacker, linkmapper)
225
225
226 def baserevision(self, nodeorrev):
226 def baserevision(self, nodeorrev):
227 return filelog.filelog.revision(self, nodeorrev, raw=True)
227 return filelog.filelog.revision(self, nodeorrev, raw=True)
228
228
229 class bundlepeer(localrepo.localpeer):
229 class bundlepeer(localrepo.localpeer):
230 def canpush(self):
230 def canpush(self):
231 return False
231 return False
232
232
233 class bundlephasecache(phases.phasecache):
233 class bundlephasecache(phases.phasecache):
234 def __init__(self, *args, **kwargs):
234 def __init__(self, *args, **kwargs):
235 super(bundlephasecache, self).__init__(*args, **kwargs)
235 super(bundlephasecache, self).__init__(*args, **kwargs)
236 if util.safehasattr(self, 'opener'):
236 if util.safehasattr(self, 'opener'):
237 self.opener = vfsmod.readonlyvfs(self.opener)
237 self.opener = vfsmod.readonlyvfs(self.opener)
238
238
239 def write(self):
239 def write(self):
240 raise NotImplementedError
240 raise NotImplementedError
241
241
242 def _write(self, fp):
242 def _write(self, fp):
243 raise NotImplementedError
243 raise NotImplementedError
244
244
245 def _updateroots(self, phase, newroots, tr):
245 def _updateroots(self, phase, newroots, tr):
246 self.phaseroots[phase] = newroots
246 self.phaseroots[phase] = newroots
247 self.invalidate()
247 self.invalidate()
248 self.dirty = True
248 self.dirty = True
249
249
250 def _getfilestarts(cgunpacker):
250 def _getfilestarts(cgunpacker):
251 filespos = {}
251 filespos = {}
252 for chunkdata in iter(cgunpacker.filelogheader, {}):
252 for chunkdata in iter(cgunpacker.filelogheader, {}):
253 fname = chunkdata['filename']
253 fname = chunkdata['filename']
254 filespos[fname] = cgunpacker.tell()
254 filespos[fname] = cgunpacker.tell()
255 for chunk in iter(lambda: cgunpacker.deltachunk(None), {}):
255 for chunk in iter(lambda: cgunpacker.deltachunk(None), {}):
256 pass
256 pass
257 return filespos
257 return filespos
258
258
259 class bundlerepository(object):
259 class bundlerepository(object):
260 """A repository instance that is a union of a local repo and a bundle.
260 """A repository instance that is a union of a local repo and a bundle.
261
261
262 Instances represent a read-only repository composed of a local repository
262 Instances represent a read-only repository composed of a local repository
263 with the contents of a bundle file applied. The repository instance is
263 with the contents of a bundle file applied. The repository instance is
264 conceptually similar to the state of a repository after an
264 conceptually similar to the state of a repository after an
265 ``hg unbundle`` operation. However, the contents of the bundle are never
265 ``hg unbundle`` operation. However, the contents of the bundle are never
266 applied to the actual base repository.
266 applied to the actual base repository.
267
267
268 Instances constructed directly are not usable as repository objects.
268 Instances constructed directly are not usable as repository objects.
269 Use instance() or makebundlerepository() to create instances.
269 Use instance() or makebundlerepository() to create instances.
270 """
270 """
271 def __init__(self, bundlepath, url, tempparent):
271 def __init__(self, bundlepath, url, tempparent):
272 self._tempparent = tempparent
272 self._tempparent = tempparent
273 self._url = url
273 self._url = url
274
274
275 self.ui.setconfig('phases', 'publish', False, 'bundlerepo')
275 self.ui.setconfig('phases', 'publish', False, 'bundlerepo')
276
276
277 self.tempfile = None
277 self.tempfile = None
278 f = util.posixfile(bundlepath, "rb")
278 f = util.posixfile(bundlepath, "rb")
279 bundle = exchange.readbundle(self.ui, f, bundlepath)
279 bundle = exchange.readbundle(self.ui, f, bundlepath)
280
280
281 if isinstance(bundle, bundle2.unbundle20):
281 if isinstance(bundle, bundle2.unbundle20):
282 self._bundlefile = bundle
282 self._bundlefile = bundle
283 self._cgunpacker = None
283 self._cgunpacker = None
284
284
285 cgpart = None
285 cgpart = None
286 for part in bundle.iterparts(seekable=True):
286 for part in bundle.iterparts(seekable=True):
287 if part.type == 'changegroup':
287 if part.type == 'changegroup':
288 if cgpart:
288 if cgpart:
289 raise NotImplementedError("can't process "
289 raise NotImplementedError("can't process "
290 "multiple changegroups")
290 "multiple changegroups")
291 cgpart = part
291 cgpart = part
292
292
293 self._handlebundle2part(bundle, part)
293 self._handlebundle2part(bundle, part)
294
294
295 if not cgpart:
295 if not cgpart:
296 raise error.Abort(_("No changegroups found"))
296 raise error.Abort(_("No changegroups found"))
297
297
298 # This is required to placate a later consumer, which expects
298 # This is required to placate a later consumer, which expects
299 # the payload offset to be at the beginning of the changegroup.
299 # the payload offset to be at the beginning of the changegroup.
300 # We need to do this after the iterparts() generator advances
300 # We need to do this after the iterparts() generator advances
301 # because iterparts() will seek to end of payload after the
301 # because iterparts() will seek to end of payload after the
302 # generator returns control to iterparts().
302 # generator returns control to iterparts().
303 cgpart.seek(0, os.SEEK_SET)
303 cgpart.seek(0, os.SEEK_SET)
304
304
305 elif isinstance(bundle, changegroup.cg1unpacker):
305 elif isinstance(bundle, changegroup.cg1unpacker):
306 if bundle.compressed():
306 if bundle.compressed():
307 f = self._writetempbundle(bundle.read, '.hg10un',
307 f = self._writetempbundle(bundle.read, '.hg10un',
308 header='HG10UN')
308 header='HG10UN')
309 bundle = exchange.readbundle(self.ui, f, bundlepath, self.vfs)
309 bundle = exchange.readbundle(self.ui, f, bundlepath, self.vfs)
310
310
311 self._bundlefile = bundle
311 self._bundlefile = bundle
312 self._cgunpacker = bundle
312 self._cgunpacker = bundle
313 else:
313 else:
314 raise error.Abort(_('bundle type %s cannot be read') %
314 raise error.Abort(_('bundle type %s cannot be read') %
315 type(bundle))
315 type(bundle))
316
316
317 # dict with the mapping 'filename' -> position in the changegroup.
317 # dict with the mapping 'filename' -> position in the changegroup.
318 self._cgfilespos = {}
318 self._cgfilespos = {}
319
319
320 self.firstnewrev = self.changelog.repotiprev + 1
320 self.firstnewrev = self.changelog.repotiprev + 1
321 phases.retractboundary(self, None, phases.draft,
321 phases.retractboundary(self, None, phases.draft,
322 [ctx.node() for ctx in self[self.firstnewrev:]])
322 [ctx.node() for ctx in self[self.firstnewrev:]])
323
323
324 def _handlebundle2part(self, bundle, part):
324 def _handlebundle2part(self, bundle, part):
325 if part.type != 'changegroup':
325 if part.type != 'changegroup':
326 return
326 return
327
327
328 cgstream = part
328 cgstream = part
329 version = part.params.get('version', '01')
329 version = part.params.get('version', '01')
330 legalcgvers = changegroup.supportedincomingversions(self)
330 legalcgvers = changegroup.supportedincomingversions(self)
331 if version not in legalcgvers:
331 if version not in legalcgvers:
332 msg = _('Unsupported changegroup version: %s')
332 msg = _('Unsupported changegroup version: %s')
333 raise error.Abort(msg % version)
333 raise error.Abort(msg % version)
334 if bundle.compressed():
334 if bundle.compressed():
335 cgstream = self._writetempbundle(part.read, '.cg%sun' % version)
335 cgstream = self._writetempbundle(part.read, '.cg%sun' % version)
336
336
337 self._cgunpacker = changegroup.getunbundler(version, cgstream, 'UN')
337 self._cgunpacker = changegroup.getunbundler(version, cgstream, 'UN')
338
338
339 def _writetempbundle(self, readfn, suffix, header=''):
339 def _writetempbundle(self, readfn, suffix, header=''):
340 """Write a temporary file to disk
340 """Write a temporary file to disk
341 """
341 """
342 fdtemp, temp = self.vfs.mkstemp(prefix="hg-bundle-",
342 fdtemp, temp = self.vfs.mkstemp(prefix="hg-bundle-",
343 suffix=suffix)
343 suffix=suffix)
344 self.tempfile = temp
344 self.tempfile = temp
345
345
346 with os.fdopen(fdtemp, r'wb') as fptemp:
346 with os.fdopen(fdtemp, r'wb') as fptemp:
347 fptemp.write(header)
347 fptemp.write(header)
348 while True:
348 while True:
349 chunk = readfn(2**18)
349 chunk = readfn(2**18)
350 if not chunk:
350 if not chunk:
351 break
351 break
352 fptemp.write(chunk)
352 fptemp.write(chunk)
353
353
354 return self.vfs.open(self.tempfile, mode="rb")
354 return self.vfs.open(self.tempfile, mode="rb")
355
355
356 @localrepo.unfilteredpropertycache
356 @localrepo.unfilteredpropertycache
357 def _phasecache(self):
357 def _phasecache(self):
358 return bundlephasecache(self, self._phasedefaults)
358 return bundlephasecache(self, self._phasedefaults)
359
359
360 @localrepo.unfilteredpropertycache
360 @localrepo.unfilteredpropertycache
361 def changelog(self):
361 def changelog(self):
362 # consume the header if it exists
362 # consume the header if it exists
363 self._cgunpacker.changelogheader()
363 self._cgunpacker.changelogheader()
364 c = bundlechangelog(self.svfs, self._cgunpacker)
364 c = bundlechangelog(self.svfs, self._cgunpacker)
365 self.manstart = self._cgunpacker.tell()
365 self.manstart = self._cgunpacker.tell()
366 return c
366 return c
367
367
368 def _refreshchangelog(self):
369 # changelog for bundle repo are not filecache, this method is not
370 # applicable.
371 pass
372
368 @localrepo.unfilteredpropertycache
373 @localrepo.unfilteredpropertycache
369 def manifestlog(self):
374 def manifestlog(self):
370 self._cgunpacker.seek(self.manstart)
375 self._cgunpacker.seek(self.manstart)
371 # consume the header if it exists
376 # consume the header if it exists
372 self._cgunpacker.manifestheader()
377 self._cgunpacker.manifestheader()
373 linkmapper = self.unfiltered().changelog.rev
378 linkmapper = self.unfiltered().changelog.rev
374 rootstore = bundlemanifest(self.svfs, self._cgunpacker, linkmapper)
379 rootstore = bundlemanifest(self.svfs, self._cgunpacker, linkmapper)
375 self.filestart = self._cgunpacker.tell()
380 self.filestart = self._cgunpacker.tell()
376
381
377 return manifest.manifestlog(self.svfs, self, rootstore,
382 return manifest.manifestlog(self.svfs, self, rootstore,
378 self.narrowmatch())
383 self.narrowmatch())
379
384
380 def _consumemanifest(self):
385 def _consumemanifest(self):
381 """Consumes the manifest portion of the bundle, setting filestart so the
386 """Consumes the manifest portion of the bundle, setting filestart so the
382 file portion can be read."""
387 file portion can be read."""
383 self._cgunpacker.seek(self.manstart)
388 self._cgunpacker.seek(self.manstart)
384 self._cgunpacker.manifestheader()
389 self._cgunpacker.manifestheader()
385 for delta in self._cgunpacker.deltaiter():
390 for delta in self._cgunpacker.deltaiter():
386 pass
391 pass
387 self.filestart = self._cgunpacker.tell()
392 self.filestart = self._cgunpacker.tell()
388
393
389 @localrepo.unfilteredpropertycache
394 @localrepo.unfilteredpropertycache
390 def manstart(self):
395 def manstart(self):
391 self.changelog
396 self.changelog
392 return self.manstart
397 return self.manstart
393
398
394 @localrepo.unfilteredpropertycache
399 @localrepo.unfilteredpropertycache
395 def filestart(self):
400 def filestart(self):
396 self.manifestlog
401 self.manifestlog
397
402
398 # If filestart was not set by self.manifestlog, that means the
403 # If filestart was not set by self.manifestlog, that means the
399 # manifestlog implementation did not consume the manifests from the
404 # manifestlog implementation did not consume the manifests from the
400 # changegroup (ex: it might be consuming trees from a separate bundle2
405 # changegroup (ex: it might be consuming trees from a separate bundle2
401 # part instead). So we need to manually consume it.
406 # part instead). So we need to manually consume it.
402 if r'filestart' not in self.__dict__:
407 if r'filestart' not in self.__dict__:
403 self._consumemanifest()
408 self._consumemanifest()
404
409
405 return self.filestart
410 return self.filestart
406
411
407 def url(self):
412 def url(self):
408 return self._url
413 return self._url
409
414
410 def file(self, f):
415 def file(self, f):
411 if not self._cgfilespos:
416 if not self._cgfilespos:
412 self._cgunpacker.seek(self.filestart)
417 self._cgunpacker.seek(self.filestart)
413 self._cgfilespos = _getfilestarts(self._cgunpacker)
418 self._cgfilespos = _getfilestarts(self._cgunpacker)
414
419
415 if f in self._cgfilespos:
420 if f in self._cgfilespos:
416 self._cgunpacker.seek(self._cgfilespos[f])
421 self._cgunpacker.seek(self._cgfilespos[f])
417 linkmapper = self.unfiltered().changelog.rev
422 linkmapper = self.unfiltered().changelog.rev
418 return bundlefilelog(self.svfs, f, self._cgunpacker, linkmapper)
423 return bundlefilelog(self.svfs, f, self._cgunpacker, linkmapper)
419 else:
424 else:
420 return super(bundlerepository, self).file(f)
425 return super(bundlerepository, self).file(f)
421
426
422 def close(self):
427 def close(self):
423 """Close assigned bundle file immediately."""
428 """Close assigned bundle file immediately."""
424 self._bundlefile.close()
429 self._bundlefile.close()
425 if self.tempfile is not None:
430 if self.tempfile is not None:
426 self.vfs.unlink(self.tempfile)
431 self.vfs.unlink(self.tempfile)
427 if self._tempparent:
432 if self._tempparent:
428 shutil.rmtree(self._tempparent, True)
433 shutil.rmtree(self._tempparent, True)
429
434
430 def cancopy(self):
435 def cancopy(self):
431 return False
436 return False
432
437
433 def peer(self):
438 def peer(self):
434 return bundlepeer(self)
439 return bundlepeer(self)
435
440
436 def getcwd(self):
441 def getcwd(self):
437 return encoding.getcwd() # always outside the repo
442 return encoding.getcwd() # always outside the repo
438
443
439 # Check if parents exist in localrepo before setting
444 # Check if parents exist in localrepo before setting
440 def setparents(self, p1, p2=nullid):
445 def setparents(self, p1, p2=nullid):
441 p1rev = self.changelog.rev(p1)
446 p1rev = self.changelog.rev(p1)
442 p2rev = self.changelog.rev(p2)
447 p2rev = self.changelog.rev(p2)
443 msg = _("setting parent to node %s that only exists in the bundle\n")
448 msg = _("setting parent to node %s that only exists in the bundle\n")
444 if self.changelog.repotiprev < p1rev:
449 if self.changelog.repotiprev < p1rev:
445 self.ui.warn(msg % nodemod.hex(p1))
450 self.ui.warn(msg % nodemod.hex(p1))
446 if self.changelog.repotiprev < p2rev:
451 if self.changelog.repotiprev < p2rev:
447 self.ui.warn(msg % nodemod.hex(p2))
452 self.ui.warn(msg % nodemod.hex(p2))
448 return super(bundlerepository, self).setparents(p1, p2)
453 return super(bundlerepository, self).setparents(p1, p2)
449
454
450 def instance(ui, path, create, intents=None, createopts=None):
455 def instance(ui, path, create, intents=None, createopts=None):
451 if create:
456 if create:
452 raise error.Abort(_('cannot create new bundle repository'))
457 raise error.Abort(_('cannot create new bundle repository'))
453 # internal config: bundle.mainreporoot
458 # internal config: bundle.mainreporoot
454 parentpath = ui.config("bundle", "mainreporoot")
459 parentpath = ui.config("bundle", "mainreporoot")
455 if not parentpath:
460 if not parentpath:
456 # try to find the correct path to the working directory repo
461 # try to find the correct path to the working directory repo
457 parentpath = cmdutil.findrepo(encoding.getcwd())
462 parentpath = cmdutil.findrepo(encoding.getcwd())
458 if parentpath is None:
463 if parentpath is None:
459 parentpath = ''
464 parentpath = ''
460 if parentpath:
465 if parentpath:
461 # Try to make the full path relative so we get a nice, short URL.
466 # Try to make the full path relative so we get a nice, short URL.
462 # In particular, we don't want temp dir names in test outputs.
467 # In particular, we don't want temp dir names in test outputs.
463 cwd = encoding.getcwd()
468 cwd = encoding.getcwd()
464 if parentpath == cwd:
469 if parentpath == cwd:
465 parentpath = ''
470 parentpath = ''
466 else:
471 else:
467 cwd = pathutil.normasprefix(cwd)
472 cwd = pathutil.normasprefix(cwd)
468 if parentpath.startswith(cwd):
473 if parentpath.startswith(cwd):
469 parentpath = parentpath[len(cwd):]
474 parentpath = parentpath[len(cwd):]
470 u = util.url(path)
475 u = util.url(path)
471 path = u.localpath()
476 path = u.localpath()
472 if u.scheme == 'bundle':
477 if u.scheme == 'bundle':
473 s = path.split("+", 1)
478 s = path.split("+", 1)
474 if len(s) == 1:
479 if len(s) == 1:
475 repopath, bundlename = parentpath, s[0]
480 repopath, bundlename = parentpath, s[0]
476 else:
481 else:
477 repopath, bundlename = s
482 repopath, bundlename = s
478 else:
483 else:
479 repopath, bundlename = parentpath, path
484 repopath, bundlename = parentpath, path
480
485
481 return makebundlerepository(ui, repopath, bundlename)
486 return makebundlerepository(ui, repopath, bundlename)
482
487
483 def makebundlerepository(ui, repopath, bundlepath):
488 def makebundlerepository(ui, repopath, bundlepath):
484 """Make a bundle repository object based on repo and bundle paths."""
489 """Make a bundle repository object based on repo and bundle paths."""
485 if repopath:
490 if repopath:
486 url = 'bundle:%s+%s' % (util.expandpath(repopath), bundlepath)
491 url = 'bundle:%s+%s' % (util.expandpath(repopath), bundlepath)
487 else:
492 else:
488 url = 'bundle:%s' % bundlepath
493 url = 'bundle:%s' % bundlepath
489
494
490 # Because we can't make any guarantees about the type of the base
495 # Because we can't make any guarantees about the type of the base
491 # repository, we can't have a static class representing the bundle
496 # repository, we can't have a static class representing the bundle
492 # repository. We also can't make any guarantees about how to even
497 # repository. We also can't make any guarantees about how to even
493 # call the base repository's constructor!
498 # call the base repository's constructor!
494 #
499 #
495 # So, our strategy is to go through ``localrepo.instance()`` to construct
500 # So, our strategy is to go through ``localrepo.instance()`` to construct
496 # a repo instance. Then, we dynamically create a new type derived from
501 # a repo instance. Then, we dynamically create a new type derived from
497 # both it and our ``bundlerepository`` class which overrides some
502 # both it and our ``bundlerepository`` class which overrides some
498 # functionality. We then change the type of the constructed repository
503 # functionality. We then change the type of the constructed repository
499 # to this new type and initialize the bundle-specific bits of it.
504 # to this new type and initialize the bundle-specific bits of it.
500
505
501 try:
506 try:
502 repo = localrepo.instance(ui, repopath, create=False)
507 repo = localrepo.instance(ui, repopath, create=False)
503 tempparent = None
508 tempparent = None
504 except error.RepoError:
509 except error.RepoError:
505 tempparent = pycompat.mkdtemp()
510 tempparent = pycompat.mkdtemp()
506 try:
511 try:
507 repo = localrepo.instance(ui, tempparent, create=True)
512 repo = localrepo.instance(ui, tempparent, create=True)
508 except Exception:
513 except Exception:
509 shutil.rmtree(tempparent)
514 shutil.rmtree(tempparent)
510 raise
515 raise
511
516
512 class derivedbundlerepository(bundlerepository, repo.__class__):
517 class derivedbundlerepository(bundlerepository, repo.__class__):
513 pass
518 pass
514
519
515 repo.__class__ = derivedbundlerepository
520 repo.__class__ = derivedbundlerepository
516 bundlerepository.__init__(repo, bundlepath, url, tempparent)
521 bundlerepository.__init__(repo, bundlepath, url, tempparent)
517
522
518 return repo
523 return repo
519
524
520 class bundletransactionmanager(object):
525 class bundletransactionmanager(object):
521 def transaction(self):
526 def transaction(self):
522 return None
527 return None
523
528
524 def close(self):
529 def close(self):
525 raise NotImplementedError
530 raise NotImplementedError
526
531
527 def release(self):
532 def release(self):
528 raise NotImplementedError
533 raise NotImplementedError
529
534
530 def getremotechanges(ui, repo, peer, onlyheads=None, bundlename=None,
535 def getremotechanges(ui, repo, peer, onlyheads=None, bundlename=None,
531 force=False):
536 force=False):
532 '''obtains a bundle of changes incoming from peer
537 '''obtains a bundle of changes incoming from peer
533
538
534 "onlyheads" restricts the returned changes to those reachable from the
539 "onlyheads" restricts the returned changes to those reachable from the
535 specified heads.
540 specified heads.
536 "bundlename", if given, stores the bundle to this file path permanently;
541 "bundlename", if given, stores the bundle to this file path permanently;
537 otherwise it's stored to a temp file and gets deleted again when you call
542 otherwise it's stored to a temp file and gets deleted again when you call
538 the returned "cleanupfn".
543 the returned "cleanupfn".
539 "force" indicates whether to proceed on unrelated repos.
544 "force" indicates whether to proceed on unrelated repos.
540
545
541 Returns a tuple (local, csets, cleanupfn):
546 Returns a tuple (local, csets, cleanupfn):
542
547
543 "local" is a local repo from which to obtain the actual incoming
548 "local" is a local repo from which to obtain the actual incoming
544 changesets; it is a bundlerepo for the obtained bundle when the
549 changesets; it is a bundlerepo for the obtained bundle when the
545 original "peer" is remote.
550 original "peer" is remote.
546 "csets" lists the incoming changeset node ids.
551 "csets" lists the incoming changeset node ids.
547 "cleanupfn" must be called without arguments when you're done processing
552 "cleanupfn" must be called without arguments when you're done processing
548 the changes; it closes both the original "peer" and the one returned
553 the changes; it closes both the original "peer" and the one returned
549 here.
554 here.
550 '''
555 '''
551 tmp = discovery.findcommonincoming(repo, peer, heads=onlyheads,
556 tmp = discovery.findcommonincoming(repo, peer, heads=onlyheads,
552 force=force)
557 force=force)
553 common, incoming, rheads = tmp
558 common, incoming, rheads = tmp
554 if not incoming:
559 if not incoming:
555 try:
560 try:
556 if bundlename:
561 if bundlename:
557 os.unlink(bundlename)
562 os.unlink(bundlename)
558 except OSError:
563 except OSError:
559 pass
564 pass
560 return repo, [], peer.close
565 return repo, [], peer.close
561
566
562 commonset = set(common)
567 commonset = set(common)
563 rheads = [x for x in rheads if x not in commonset]
568 rheads = [x for x in rheads if x not in commonset]
564
569
565 bundle = None
570 bundle = None
566 bundlerepo = None
571 bundlerepo = None
567 localrepo = peer.local()
572 localrepo = peer.local()
568 if bundlename or not localrepo:
573 if bundlename or not localrepo:
569 # create a bundle (uncompressed if peer repo is not local)
574 # create a bundle (uncompressed if peer repo is not local)
570
575
571 # developer config: devel.legacy.exchange
576 # developer config: devel.legacy.exchange
572 legexc = ui.configlist('devel', 'legacy.exchange')
577 legexc = ui.configlist('devel', 'legacy.exchange')
573 forcebundle1 = 'bundle2' not in legexc and 'bundle1' in legexc
578 forcebundle1 = 'bundle2' not in legexc and 'bundle1' in legexc
574 canbundle2 = (not forcebundle1
579 canbundle2 = (not forcebundle1
575 and peer.capable('getbundle')
580 and peer.capable('getbundle')
576 and peer.capable('bundle2'))
581 and peer.capable('bundle2'))
577 if canbundle2:
582 if canbundle2:
578 with peer.commandexecutor() as e:
583 with peer.commandexecutor() as e:
579 b2 = e.callcommand('getbundle', {
584 b2 = e.callcommand('getbundle', {
580 'source': 'incoming',
585 'source': 'incoming',
581 'common': common,
586 'common': common,
582 'heads': rheads,
587 'heads': rheads,
583 'bundlecaps': exchange.caps20to10(repo, role='client'),
588 'bundlecaps': exchange.caps20to10(repo, role='client'),
584 'cg': True,
589 'cg': True,
585 }).result()
590 }).result()
586
591
587 fname = bundle = changegroup.writechunks(ui,
592 fname = bundle = changegroup.writechunks(ui,
588 b2._forwardchunks(),
593 b2._forwardchunks(),
589 bundlename)
594 bundlename)
590 else:
595 else:
591 if peer.capable('getbundle'):
596 if peer.capable('getbundle'):
592 with peer.commandexecutor() as e:
597 with peer.commandexecutor() as e:
593 cg = e.callcommand('getbundle', {
598 cg = e.callcommand('getbundle', {
594 'source': 'incoming',
599 'source': 'incoming',
595 'common': common,
600 'common': common,
596 'heads': rheads,
601 'heads': rheads,
597 }).result()
602 }).result()
598 elif onlyheads is None and not peer.capable('changegroupsubset'):
603 elif onlyheads is None and not peer.capable('changegroupsubset'):
599 # compat with older servers when pulling all remote heads
604 # compat with older servers when pulling all remote heads
600
605
601 with peer.commandexecutor() as e:
606 with peer.commandexecutor() as e:
602 cg = e.callcommand('changegroup', {
607 cg = e.callcommand('changegroup', {
603 'nodes': incoming,
608 'nodes': incoming,
604 'source': 'incoming',
609 'source': 'incoming',
605 }).result()
610 }).result()
606
611
607 rheads = None
612 rheads = None
608 else:
613 else:
609 with peer.commandexecutor() as e:
614 with peer.commandexecutor() as e:
610 cg = e.callcommand('changegroupsubset', {
615 cg = e.callcommand('changegroupsubset', {
611 'bases': incoming,
616 'bases': incoming,
612 'heads': rheads,
617 'heads': rheads,
613 'source': 'incoming',
618 'source': 'incoming',
614 }).result()
619 }).result()
615
620
616 if localrepo:
621 if localrepo:
617 bundletype = "HG10BZ"
622 bundletype = "HG10BZ"
618 else:
623 else:
619 bundletype = "HG10UN"
624 bundletype = "HG10UN"
620 fname = bundle = bundle2.writebundle(ui, cg, bundlename,
625 fname = bundle = bundle2.writebundle(ui, cg, bundlename,
621 bundletype)
626 bundletype)
622 # keep written bundle?
627 # keep written bundle?
623 if bundlename:
628 if bundlename:
624 bundle = None
629 bundle = None
625 if not localrepo:
630 if not localrepo:
626 # use the created uncompressed bundlerepo
631 # use the created uncompressed bundlerepo
627 localrepo = bundlerepo = makebundlerepository(repo. baseui,
632 localrepo = bundlerepo = makebundlerepository(repo. baseui,
628 repo.root,
633 repo.root,
629 fname)
634 fname)
630
635
631 # this repo contains local and peer now, so filter out local again
636 # this repo contains local and peer now, so filter out local again
632 common = repo.heads()
637 common = repo.heads()
633 if localrepo:
638 if localrepo:
634 # Part of common may be remotely filtered
639 # Part of common may be remotely filtered
635 # So use an unfiltered version
640 # So use an unfiltered version
636 # The discovery process probably need cleanup to avoid that
641 # The discovery process probably need cleanup to avoid that
637 localrepo = localrepo.unfiltered()
642 localrepo = localrepo.unfiltered()
638
643
639 csets = localrepo.changelog.findmissing(common, rheads)
644 csets = localrepo.changelog.findmissing(common, rheads)
640
645
641 if bundlerepo:
646 if bundlerepo:
642 reponodes = [ctx.node() for ctx in bundlerepo[bundlerepo.firstnewrev:]]
647 reponodes = [ctx.node() for ctx in bundlerepo[bundlerepo.firstnewrev:]]
643
648
644 with peer.commandexecutor() as e:
649 with peer.commandexecutor() as e:
645 remotephases = e.callcommand('listkeys', {
650 remotephases = e.callcommand('listkeys', {
646 'namespace': 'phases',
651 'namespace': 'phases',
647 }).result()
652 }).result()
648
653
649 pullop = exchange.pulloperation(bundlerepo, peer, heads=reponodes)
654 pullop = exchange.pulloperation(bundlerepo, peer, heads=reponodes)
650 pullop.trmanager = bundletransactionmanager()
655 pullop.trmanager = bundletransactionmanager()
651 exchange._pullapplyphases(pullop, remotephases)
656 exchange._pullapplyphases(pullop, remotephases)
652
657
653 def cleanup():
658 def cleanup():
654 if bundlerepo:
659 if bundlerepo:
655 bundlerepo.close()
660 bundlerepo.close()
656 if bundle:
661 if bundle:
657 os.unlink(bundle)
662 os.unlink(bundle)
658 peer.close()
663 peer.close()
659
664
660 return (localrepo, csets, cleanup)
665 return (localrepo, csets, cleanup)
@@ -1,3156 +1,3161 b''
1 # localrepo.py - read/write repository class for mercurial
1 # localrepo.py - read/write repository class for mercurial
2 #
2 #
3 # Copyright 2005-2007 Matt Mackall <mpm@selenic.com>
3 # Copyright 2005-2007 Matt Mackall <mpm@selenic.com>
4 #
4 #
5 # This software may be used and distributed according to the terms of the
5 # This software may be used and distributed according to the terms of the
6 # GNU General Public License version 2 or any later version.
6 # GNU General Public License version 2 or any later version.
7
7
8 from __future__ import absolute_import
8 from __future__ import absolute_import
9
9
10 import errno
10 import errno
11 import hashlib
11 import hashlib
12 import os
12 import os
13 import random
13 import random
14 import sys
14 import sys
15 import time
15 import time
16 import weakref
16 import weakref
17
17
18 from .i18n import _
18 from .i18n import _
19 from .node import (
19 from .node import (
20 bin,
20 bin,
21 hex,
21 hex,
22 nullid,
22 nullid,
23 nullrev,
23 nullrev,
24 short,
24 short,
25 )
25 )
26 from . import (
26 from . import (
27 bookmarks,
27 bookmarks,
28 branchmap,
28 branchmap,
29 bundle2,
29 bundle2,
30 changegroup,
30 changegroup,
31 changelog,
31 changelog,
32 color,
32 color,
33 context,
33 context,
34 dirstate,
34 dirstate,
35 dirstateguard,
35 dirstateguard,
36 discovery,
36 discovery,
37 encoding,
37 encoding,
38 error,
38 error,
39 exchange,
39 exchange,
40 extensions,
40 extensions,
41 filelog,
41 filelog,
42 hook,
42 hook,
43 lock as lockmod,
43 lock as lockmod,
44 manifest,
44 manifest,
45 match as matchmod,
45 match as matchmod,
46 merge as mergemod,
46 merge as mergemod,
47 mergeutil,
47 mergeutil,
48 namespaces,
48 namespaces,
49 narrowspec,
49 narrowspec,
50 obsolete,
50 obsolete,
51 pathutil,
51 pathutil,
52 phases,
52 phases,
53 pushkey,
53 pushkey,
54 pycompat,
54 pycompat,
55 repository,
55 repository,
56 repoview,
56 repoview,
57 revset,
57 revset,
58 revsetlang,
58 revsetlang,
59 scmutil,
59 scmutil,
60 sparse,
60 sparse,
61 store as storemod,
61 store as storemod,
62 subrepoutil,
62 subrepoutil,
63 tags as tagsmod,
63 tags as tagsmod,
64 transaction,
64 transaction,
65 txnutil,
65 txnutil,
66 util,
66 util,
67 vfs as vfsmod,
67 vfs as vfsmod,
68 )
68 )
69 from .utils import (
69 from .utils import (
70 interfaceutil,
70 interfaceutil,
71 procutil,
71 procutil,
72 stringutil,
72 stringutil,
73 )
73 )
74
74
75 from .revlogutils import (
75 from .revlogutils import (
76 constants as revlogconst,
76 constants as revlogconst,
77 )
77 )
78
78
79 release = lockmod.release
79 release = lockmod.release
80 urlerr = util.urlerr
80 urlerr = util.urlerr
81 urlreq = util.urlreq
81 urlreq = util.urlreq
82
82
83 # set of (path, vfs-location) tuples. vfs-location is:
83 # set of (path, vfs-location) tuples. vfs-location is:
84 # - 'plain for vfs relative paths
84 # - 'plain for vfs relative paths
85 # - '' for svfs relative paths
85 # - '' for svfs relative paths
86 _cachedfiles = set()
86 _cachedfiles = set()
87
87
88 class _basefilecache(scmutil.filecache):
88 class _basefilecache(scmutil.filecache):
89 """All filecache usage on repo are done for logic that should be unfiltered
89 """All filecache usage on repo are done for logic that should be unfiltered
90 """
90 """
91 def __get__(self, repo, type=None):
91 def __get__(self, repo, type=None):
92 if repo is None:
92 if repo is None:
93 return self
93 return self
94 # proxy to unfiltered __dict__ since filtered repo has no entry
94 # proxy to unfiltered __dict__ since filtered repo has no entry
95 unfi = repo.unfiltered()
95 unfi = repo.unfiltered()
96 try:
96 try:
97 return unfi.__dict__[self.sname]
97 return unfi.__dict__[self.sname]
98 except KeyError:
98 except KeyError:
99 pass
99 pass
100 return super(_basefilecache, self).__get__(unfi, type)
100 return super(_basefilecache, self).__get__(unfi, type)
101
101
102 def set(self, repo, value):
102 def set(self, repo, value):
103 return super(_basefilecache, self).set(repo.unfiltered(), value)
103 return super(_basefilecache, self).set(repo.unfiltered(), value)
104
104
105 class repofilecache(_basefilecache):
105 class repofilecache(_basefilecache):
106 """filecache for files in .hg but outside of .hg/store"""
106 """filecache for files in .hg but outside of .hg/store"""
107 def __init__(self, *paths):
107 def __init__(self, *paths):
108 super(repofilecache, self).__init__(*paths)
108 super(repofilecache, self).__init__(*paths)
109 for path in paths:
109 for path in paths:
110 _cachedfiles.add((path, 'plain'))
110 _cachedfiles.add((path, 'plain'))
111
111
112 def join(self, obj, fname):
112 def join(self, obj, fname):
113 return obj.vfs.join(fname)
113 return obj.vfs.join(fname)
114
114
115 class storecache(_basefilecache):
115 class storecache(_basefilecache):
116 """filecache for files in the store"""
116 """filecache for files in the store"""
117 def __init__(self, *paths):
117 def __init__(self, *paths):
118 super(storecache, self).__init__(*paths)
118 super(storecache, self).__init__(*paths)
119 for path in paths:
119 for path in paths:
120 _cachedfiles.add((path, ''))
120 _cachedfiles.add((path, ''))
121
121
122 def join(self, obj, fname):
122 def join(self, obj, fname):
123 return obj.sjoin(fname)
123 return obj.sjoin(fname)
124
124
125 class mixedrepostorecache(_basefilecache):
125 class mixedrepostorecache(_basefilecache):
126 """filecache for a mix files in .hg/store and outside"""
126 """filecache for a mix files in .hg/store and outside"""
127 def __init__(self, *pathsandlocations):
127 def __init__(self, *pathsandlocations):
128 # scmutil.filecache only uses the path for passing back into our
128 # scmutil.filecache only uses the path for passing back into our
129 # join(), so we can safely pass a list of paths and locations
129 # join(), so we can safely pass a list of paths and locations
130 super(mixedrepostorecache, self).__init__(*pathsandlocations)
130 super(mixedrepostorecache, self).__init__(*pathsandlocations)
131 for path, location in pathsandlocations:
131 for path, location in pathsandlocations:
132 _cachedfiles.update(pathsandlocations)
132 _cachedfiles.update(pathsandlocations)
133
133
134 def join(self, obj, fnameandlocation):
134 def join(self, obj, fnameandlocation):
135 fname, location = fnameandlocation
135 fname, location = fnameandlocation
136 if location == 'plain':
136 if location == 'plain':
137 return obj.vfs.join(fname)
137 return obj.vfs.join(fname)
138 else:
138 else:
139 if location != '':
139 if location != '':
140 raise error.ProgrammingError('unexpected location: %s' %
140 raise error.ProgrammingError('unexpected location: %s' %
141 location)
141 location)
142 return obj.sjoin(fname)
142 return obj.sjoin(fname)
143
143
144 def isfilecached(repo, name):
144 def isfilecached(repo, name):
145 """check if a repo has already cached "name" filecache-ed property
145 """check if a repo has already cached "name" filecache-ed property
146
146
147 This returns (cachedobj-or-None, iscached) tuple.
147 This returns (cachedobj-or-None, iscached) tuple.
148 """
148 """
149 cacheentry = repo.unfiltered()._filecache.get(name, None)
149 cacheentry = repo.unfiltered()._filecache.get(name, None)
150 if not cacheentry:
150 if not cacheentry:
151 return None, False
151 return None, False
152 return cacheentry.obj, True
152 return cacheentry.obj, True
153
153
154 class unfilteredpropertycache(util.propertycache):
154 class unfilteredpropertycache(util.propertycache):
155 """propertycache that apply to unfiltered repo only"""
155 """propertycache that apply to unfiltered repo only"""
156
156
157 def __get__(self, repo, type=None):
157 def __get__(self, repo, type=None):
158 unfi = repo.unfiltered()
158 unfi = repo.unfiltered()
159 if unfi is repo:
159 if unfi is repo:
160 return super(unfilteredpropertycache, self).__get__(unfi)
160 return super(unfilteredpropertycache, self).__get__(unfi)
161 return getattr(unfi, self.name)
161 return getattr(unfi, self.name)
162
162
163 class filteredpropertycache(util.propertycache):
163 class filteredpropertycache(util.propertycache):
164 """propertycache that must take filtering in account"""
164 """propertycache that must take filtering in account"""
165
165
166 def cachevalue(self, obj, value):
166 def cachevalue(self, obj, value):
167 object.__setattr__(obj, self.name, value)
167 object.__setattr__(obj, self.name, value)
168
168
169
169
170 def hasunfilteredcache(repo, name):
170 def hasunfilteredcache(repo, name):
171 """check if a repo has an unfilteredpropertycache value for <name>"""
171 """check if a repo has an unfilteredpropertycache value for <name>"""
172 return name in vars(repo.unfiltered())
172 return name in vars(repo.unfiltered())
173
173
174 def unfilteredmethod(orig):
174 def unfilteredmethod(orig):
175 """decorate method that always need to be run on unfiltered version"""
175 """decorate method that always need to be run on unfiltered version"""
176 def wrapper(repo, *args, **kwargs):
176 def wrapper(repo, *args, **kwargs):
177 return orig(repo.unfiltered(), *args, **kwargs)
177 return orig(repo.unfiltered(), *args, **kwargs)
178 return wrapper
178 return wrapper
179
179
180 moderncaps = {'lookup', 'branchmap', 'pushkey', 'known', 'getbundle',
180 moderncaps = {'lookup', 'branchmap', 'pushkey', 'known', 'getbundle',
181 'unbundle'}
181 'unbundle'}
182 legacycaps = moderncaps.union({'changegroupsubset'})
182 legacycaps = moderncaps.union({'changegroupsubset'})
183
183
184 @interfaceutil.implementer(repository.ipeercommandexecutor)
184 @interfaceutil.implementer(repository.ipeercommandexecutor)
185 class localcommandexecutor(object):
185 class localcommandexecutor(object):
186 def __init__(self, peer):
186 def __init__(self, peer):
187 self._peer = peer
187 self._peer = peer
188 self._sent = False
188 self._sent = False
189 self._closed = False
189 self._closed = False
190
190
191 def __enter__(self):
191 def __enter__(self):
192 return self
192 return self
193
193
194 def __exit__(self, exctype, excvalue, exctb):
194 def __exit__(self, exctype, excvalue, exctb):
195 self.close()
195 self.close()
196
196
197 def callcommand(self, command, args):
197 def callcommand(self, command, args):
198 if self._sent:
198 if self._sent:
199 raise error.ProgrammingError('callcommand() cannot be used after '
199 raise error.ProgrammingError('callcommand() cannot be used after '
200 'sendcommands()')
200 'sendcommands()')
201
201
202 if self._closed:
202 if self._closed:
203 raise error.ProgrammingError('callcommand() cannot be used after '
203 raise error.ProgrammingError('callcommand() cannot be used after '
204 'close()')
204 'close()')
205
205
206 # We don't need to support anything fancy. Just call the named
206 # We don't need to support anything fancy. Just call the named
207 # method on the peer and return a resolved future.
207 # method on the peer and return a resolved future.
208 fn = getattr(self._peer, pycompat.sysstr(command))
208 fn = getattr(self._peer, pycompat.sysstr(command))
209
209
210 f = pycompat.futures.Future()
210 f = pycompat.futures.Future()
211
211
212 try:
212 try:
213 result = fn(**pycompat.strkwargs(args))
213 result = fn(**pycompat.strkwargs(args))
214 except Exception:
214 except Exception:
215 pycompat.future_set_exception_info(f, sys.exc_info()[1:])
215 pycompat.future_set_exception_info(f, sys.exc_info()[1:])
216 else:
216 else:
217 f.set_result(result)
217 f.set_result(result)
218
218
219 return f
219 return f
220
220
221 def sendcommands(self):
221 def sendcommands(self):
222 self._sent = True
222 self._sent = True
223
223
224 def close(self):
224 def close(self):
225 self._closed = True
225 self._closed = True
226
226
227 @interfaceutil.implementer(repository.ipeercommands)
227 @interfaceutil.implementer(repository.ipeercommands)
228 class localpeer(repository.peer):
228 class localpeer(repository.peer):
229 '''peer for a local repo; reflects only the most recent API'''
229 '''peer for a local repo; reflects only the most recent API'''
230
230
231 def __init__(self, repo, caps=None):
231 def __init__(self, repo, caps=None):
232 super(localpeer, self).__init__()
232 super(localpeer, self).__init__()
233
233
234 if caps is None:
234 if caps is None:
235 caps = moderncaps.copy()
235 caps = moderncaps.copy()
236 self._repo = repo.filtered('served')
236 self._repo = repo.filtered('served')
237 self.ui = repo.ui
237 self.ui = repo.ui
238 self._caps = repo._restrictcapabilities(caps)
238 self._caps = repo._restrictcapabilities(caps)
239
239
240 # Begin of _basepeer interface.
240 # Begin of _basepeer interface.
241
241
242 def url(self):
242 def url(self):
243 return self._repo.url()
243 return self._repo.url()
244
244
245 def local(self):
245 def local(self):
246 return self._repo
246 return self._repo
247
247
248 def peer(self):
248 def peer(self):
249 return self
249 return self
250
250
251 def canpush(self):
251 def canpush(self):
252 return True
252 return True
253
253
254 def close(self):
254 def close(self):
255 self._repo.close()
255 self._repo.close()
256
256
257 # End of _basepeer interface.
257 # End of _basepeer interface.
258
258
259 # Begin of _basewirecommands interface.
259 # Begin of _basewirecommands interface.
260
260
261 def branchmap(self):
261 def branchmap(self):
262 return self._repo.branchmap()
262 return self._repo.branchmap()
263
263
264 def capabilities(self):
264 def capabilities(self):
265 return self._caps
265 return self._caps
266
266
267 def clonebundles(self):
267 def clonebundles(self):
268 return self._repo.tryread('clonebundles.manifest')
268 return self._repo.tryread('clonebundles.manifest')
269
269
270 def debugwireargs(self, one, two, three=None, four=None, five=None):
270 def debugwireargs(self, one, two, three=None, four=None, five=None):
271 """Used to test argument passing over the wire"""
271 """Used to test argument passing over the wire"""
272 return "%s %s %s %s %s" % (one, two, pycompat.bytestr(three),
272 return "%s %s %s %s %s" % (one, two, pycompat.bytestr(three),
273 pycompat.bytestr(four),
273 pycompat.bytestr(four),
274 pycompat.bytestr(five))
274 pycompat.bytestr(five))
275
275
276 def getbundle(self, source, heads=None, common=None, bundlecaps=None,
276 def getbundle(self, source, heads=None, common=None, bundlecaps=None,
277 **kwargs):
277 **kwargs):
278 chunks = exchange.getbundlechunks(self._repo, source, heads=heads,
278 chunks = exchange.getbundlechunks(self._repo, source, heads=heads,
279 common=common, bundlecaps=bundlecaps,
279 common=common, bundlecaps=bundlecaps,
280 **kwargs)[1]
280 **kwargs)[1]
281 cb = util.chunkbuffer(chunks)
281 cb = util.chunkbuffer(chunks)
282
282
283 if exchange.bundle2requested(bundlecaps):
283 if exchange.bundle2requested(bundlecaps):
284 # When requesting a bundle2, getbundle returns a stream to make the
284 # When requesting a bundle2, getbundle returns a stream to make the
285 # wire level function happier. We need to build a proper object
285 # wire level function happier. We need to build a proper object
286 # from it in local peer.
286 # from it in local peer.
287 return bundle2.getunbundler(self.ui, cb)
287 return bundle2.getunbundler(self.ui, cb)
288 else:
288 else:
289 return changegroup.getunbundler('01', cb, None)
289 return changegroup.getunbundler('01', cb, None)
290
290
291 def heads(self):
291 def heads(self):
292 return self._repo.heads()
292 return self._repo.heads()
293
293
294 def known(self, nodes):
294 def known(self, nodes):
295 return self._repo.known(nodes)
295 return self._repo.known(nodes)
296
296
297 def listkeys(self, namespace):
297 def listkeys(self, namespace):
298 return self._repo.listkeys(namespace)
298 return self._repo.listkeys(namespace)
299
299
300 def lookup(self, key):
300 def lookup(self, key):
301 return self._repo.lookup(key)
301 return self._repo.lookup(key)
302
302
303 def pushkey(self, namespace, key, old, new):
303 def pushkey(self, namespace, key, old, new):
304 return self._repo.pushkey(namespace, key, old, new)
304 return self._repo.pushkey(namespace, key, old, new)
305
305
306 def stream_out(self):
306 def stream_out(self):
307 raise error.Abort(_('cannot perform stream clone against local '
307 raise error.Abort(_('cannot perform stream clone against local '
308 'peer'))
308 'peer'))
309
309
310 def unbundle(self, bundle, heads, url):
310 def unbundle(self, bundle, heads, url):
311 """apply a bundle on a repo
311 """apply a bundle on a repo
312
312
313 This function handles the repo locking itself."""
313 This function handles the repo locking itself."""
314 try:
314 try:
315 try:
315 try:
316 bundle = exchange.readbundle(self.ui, bundle, None)
316 bundle = exchange.readbundle(self.ui, bundle, None)
317 ret = exchange.unbundle(self._repo, bundle, heads, 'push', url)
317 ret = exchange.unbundle(self._repo, bundle, heads, 'push', url)
318 if util.safehasattr(ret, 'getchunks'):
318 if util.safehasattr(ret, 'getchunks'):
319 # This is a bundle20 object, turn it into an unbundler.
319 # This is a bundle20 object, turn it into an unbundler.
320 # This little dance should be dropped eventually when the
320 # This little dance should be dropped eventually when the
321 # API is finally improved.
321 # API is finally improved.
322 stream = util.chunkbuffer(ret.getchunks())
322 stream = util.chunkbuffer(ret.getchunks())
323 ret = bundle2.getunbundler(self.ui, stream)
323 ret = bundle2.getunbundler(self.ui, stream)
324 return ret
324 return ret
325 except Exception as exc:
325 except Exception as exc:
326 # If the exception contains output salvaged from a bundle2
326 # If the exception contains output salvaged from a bundle2
327 # reply, we need to make sure it is printed before continuing
327 # reply, we need to make sure it is printed before continuing
328 # to fail. So we build a bundle2 with such output and consume
328 # to fail. So we build a bundle2 with such output and consume
329 # it directly.
329 # it directly.
330 #
330 #
331 # This is not very elegant but allows a "simple" solution for
331 # This is not very elegant but allows a "simple" solution for
332 # issue4594
332 # issue4594
333 output = getattr(exc, '_bundle2salvagedoutput', ())
333 output = getattr(exc, '_bundle2salvagedoutput', ())
334 if output:
334 if output:
335 bundler = bundle2.bundle20(self._repo.ui)
335 bundler = bundle2.bundle20(self._repo.ui)
336 for out in output:
336 for out in output:
337 bundler.addpart(out)
337 bundler.addpart(out)
338 stream = util.chunkbuffer(bundler.getchunks())
338 stream = util.chunkbuffer(bundler.getchunks())
339 b = bundle2.getunbundler(self.ui, stream)
339 b = bundle2.getunbundler(self.ui, stream)
340 bundle2.processbundle(self._repo, b)
340 bundle2.processbundle(self._repo, b)
341 raise
341 raise
342 except error.PushRaced as exc:
342 except error.PushRaced as exc:
343 raise error.ResponseError(_('push failed:'),
343 raise error.ResponseError(_('push failed:'),
344 stringutil.forcebytestr(exc))
344 stringutil.forcebytestr(exc))
345
345
346 # End of _basewirecommands interface.
346 # End of _basewirecommands interface.
347
347
348 # Begin of peer interface.
348 # Begin of peer interface.
349
349
350 def commandexecutor(self):
350 def commandexecutor(self):
351 return localcommandexecutor(self)
351 return localcommandexecutor(self)
352
352
353 # End of peer interface.
353 # End of peer interface.
354
354
355 @interfaceutil.implementer(repository.ipeerlegacycommands)
355 @interfaceutil.implementer(repository.ipeerlegacycommands)
356 class locallegacypeer(localpeer):
356 class locallegacypeer(localpeer):
357 '''peer extension which implements legacy methods too; used for tests with
357 '''peer extension which implements legacy methods too; used for tests with
358 restricted capabilities'''
358 restricted capabilities'''
359
359
360 def __init__(self, repo):
360 def __init__(self, repo):
361 super(locallegacypeer, self).__init__(repo, caps=legacycaps)
361 super(locallegacypeer, self).__init__(repo, caps=legacycaps)
362
362
363 # Begin of baselegacywirecommands interface.
363 # Begin of baselegacywirecommands interface.
364
364
365 def between(self, pairs):
365 def between(self, pairs):
366 return self._repo.between(pairs)
366 return self._repo.between(pairs)
367
367
368 def branches(self, nodes):
368 def branches(self, nodes):
369 return self._repo.branches(nodes)
369 return self._repo.branches(nodes)
370
370
371 def changegroup(self, nodes, source):
371 def changegroup(self, nodes, source):
372 outgoing = discovery.outgoing(self._repo, missingroots=nodes,
372 outgoing = discovery.outgoing(self._repo, missingroots=nodes,
373 missingheads=self._repo.heads())
373 missingheads=self._repo.heads())
374 return changegroup.makechangegroup(self._repo, outgoing, '01', source)
374 return changegroup.makechangegroup(self._repo, outgoing, '01', source)
375
375
376 def changegroupsubset(self, bases, heads, source):
376 def changegroupsubset(self, bases, heads, source):
377 outgoing = discovery.outgoing(self._repo, missingroots=bases,
377 outgoing = discovery.outgoing(self._repo, missingroots=bases,
378 missingheads=heads)
378 missingheads=heads)
379 return changegroup.makechangegroup(self._repo, outgoing, '01', source)
379 return changegroup.makechangegroup(self._repo, outgoing, '01', source)
380
380
381 # End of baselegacywirecommands interface.
381 # End of baselegacywirecommands interface.
382
382
383 # Increment the sub-version when the revlog v2 format changes to lock out old
383 # Increment the sub-version when the revlog v2 format changes to lock out old
384 # clients.
384 # clients.
385 REVLOGV2_REQUIREMENT = 'exp-revlogv2.1'
385 REVLOGV2_REQUIREMENT = 'exp-revlogv2.1'
386
386
387 # A repository with the sparserevlog feature will have delta chains that
387 # A repository with the sparserevlog feature will have delta chains that
388 # can spread over a larger span. Sparse reading cuts these large spans into
388 # can spread over a larger span. Sparse reading cuts these large spans into
389 # pieces, so that each piece isn't too big.
389 # pieces, so that each piece isn't too big.
390 # Without the sparserevlog capability, reading from the repository could use
390 # Without the sparserevlog capability, reading from the repository could use
391 # huge amounts of memory, because the whole span would be read at once,
391 # huge amounts of memory, because the whole span would be read at once,
392 # including all the intermediate revisions that aren't pertinent for the chain.
392 # including all the intermediate revisions that aren't pertinent for the chain.
393 # This is why once a repository has enabled sparse-read, it becomes required.
393 # This is why once a repository has enabled sparse-read, it becomes required.
394 SPARSEREVLOG_REQUIREMENT = 'sparserevlog'
394 SPARSEREVLOG_REQUIREMENT = 'sparserevlog'
395
395
396 # Functions receiving (ui, features) that extensions can register to impact
396 # Functions receiving (ui, features) that extensions can register to impact
397 # the ability to load repositories with custom requirements. Only
397 # the ability to load repositories with custom requirements. Only
398 # functions defined in loaded extensions are called.
398 # functions defined in loaded extensions are called.
399 #
399 #
400 # The function receives a set of requirement strings that the repository
400 # The function receives a set of requirement strings that the repository
401 # is capable of opening. Functions will typically add elements to the
401 # is capable of opening. Functions will typically add elements to the
402 # set to reflect that the extension knows how to handle that requirements.
402 # set to reflect that the extension knows how to handle that requirements.
403 featuresetupfuncs = set()
403 featuresetupfuncs = set()
404
404
405 def makelocalrepository(baseui, path, intents=None):
405 def makelocalrepository(baseui, path, intents=None):
406 """Create a local repository object.
406 """Create a local repository object.
407
407
408 Given arguments needed to construct a local repository, this function
408 Given arguments needed to construct a local repository, this function
409 performs various early repository loading functionality (such as
409 performs various early repository loading functionality (such as
410 reading the ``.hg/requires`` and ``.hg/hgrc`` files), validates that
410 reading the ``.hg/requires`` and ``.hg/hgrc`` files), validates that
411 the repository can be opened, derives a type suitable for representing
411 the repository can be opened, derives a type suitable for representing
412 that repository, and returns an instance of it.
412 that repository, and returns an instance of it.
413
413
414 The returned object conforms to the ``repository.completelocalrepository``
414 The returned object conforms to the ``repository.completelocalrepository``
415 interface.
415 interface.
416
416
417 The repository type is derived by calling a series of factory functions
417 The repository type is derived by calling a series of factory functions
418 for each aspect/interface of the final repository. These are defined by
418 for each aspect/interface of the final repository. These are defined by
419 ``REPO_INTERFACES``.
419 ``REPO_INTERFACES``.
420
420
421 Each factory function is called to produce a type implementing a specific
421 Each factory function is called to produce a type implementing a specific
422 interface. The cumulative list of returned types will be combined into a
422 interface. The cumulative list of returned types will be combined into a
423 new type and that type will be instantiated to represent the local
423 new type and that type will be instantiated to represent the local
424 repository.
424 repository.
425
425
426 The factory functions each receive various state that may be consulted
426 The factory functions each receive various state that may be consulted
427 as part of deriving a type.
427 as part of deriving a type.
428
428
429 Extensions should wrap these factory functions to customize repository type
429 Extensions should wrap these factory functions to customize repository type
430 creation. Note that an extension's wrapped function may be called even if
430 creation. Note that an extension's wrapped function may be called even if
431 that extension is not loaded for the repo being constructed. Extensions
431 that extension is not loaded for the repo being constructed. Extensions
432 should check if their ``__name__`` appears in the
432 should check if their ``__name__`` appears in the
433 ``extensionmodulenames`` set passed to the factory function and no-op if
433 ``extensionmodulenames`` set passed to the factory function and no-op if
434 not.
434 not.
435 """
435 """
436 ui = baseui.copy()
436 ui = baseui.copy()
437 # Prevent copying repo configuration.
437 # Prevent copying repo configuration.
438 ui.copy = baseui.copy
438 ui.copy = baseui.copy
439
439
440 # Working directory VFS rooted at repository root.
440 # Working directory VFS rooted at repository root.
441 wdirvfs = vfsmod.vfs(path, expandpath=True, realpath=True)
441 wdirvfs = vfsmod.vfs(path, expandpath=True, realpath=True)
442
442
443 # Main VFS for .hg/ directory.
443 # Main VFS for .hg/ directory.
444 hgpath = wdirvfs.join(b'.hg')
444 hgpath = wdirvfs.join(b'.hg')
445 hgvfs = vfsmod.vfs(hgpath, cacheaudited=True)
445 hgvfs = vfsmod.vfs(hgpath, cacheaudited=True)
446
446
447 # The .hg/ path should exist and should be a directory. All other
447 # The .hg/ path should exist and should be a directory. All other
448 # cases are errors.
448 # cases are errors.
449 if not hgvfs.isdir():
449 if not hgvfs.isdir():
450 try:
450 try:
451 hgvfs.stat()
451 hgvfs.stat()
452 except OSError as e:
452 except OSError as e:
453 if e.errno != errno.ENOENT:
453 if e.errno != errno.ENOENT:
454 raise
454 raise
455
455
456 raise error.RepoError(_(b'repository %s not found') % path)
456 raise error.RepoError(_(b'repository %s not found') % path)
457
457
458 # .hg/requires file contains a newline-delimited list of
458 # .hg/requires file contains a newline-delimited list of
459 # features/capabilities the opener (us) must have in order to use
459 # features/capabilities the opener (us) must have in order to use
460 # the repository. This file was introduced in Mercurial 0.9.2,
460 # the repository. This file was introduced in Mercurial 0.9.2,
461 # which means very old repositories may not have one. We assume
461 # which means very old repositories may not have one. We assume
462 # a missing file translates to no requirements.
462 # a missing file translates to no requirements.
463 try:
463 try:
464 requirements = set(hgvfs.read(b'requires').splitlines())
464 requirements = set(hgvfs.read(b'requires').splitlines())
465 except IOError as e:
465 except IOError as e:
466 if e.errno != errno.ENOENT:
466 if e.errno != errno.ENOENT:
467 raise
467 raise
468 requirements = set()
468 requirements = set()
469
469
470 # The .hg/hgrc file may load extensions or contain config options
470 # The .hg/hgrc file may load extensions or contain config options
471 # that influence repository construction. Attempt to load it and
471 # that influence repository construction. Attempt to load it and
472 # process any new extensions that it may have pulled in.
472 # process any new extensions that it may have pulled in.
473 if loadhgrc(ui, wdirvfs, hgvfs, requirements):
473 if loadhgrc(ui, wdirvfs, hgvfs, requirements):
474 afterhgrcload(ui, wdirvfs, hgvfs, requirements)
474 afterhgrcload(ui, wdirvfs, hgvfs, requirements)
475 extensions.loadall(ui)
475 extensions.loadall(ui)
476 extensions.populateui(ui)
476 extensions.populateui(ui)
477
477
478 # Set of module names of extensions loaded for this repository.
478 # Set of module names of extensions loaded for this repository.
479 extensionmodulenames = {m.__name__ for n, m in extensions.extensions(ui)}
479 extensionmodulenames = {m.__name__ for n, m in extensions.extensions(ui)}
480
480
481 supportedrequirements = gathersupportedrequirements(ui)
481 supportedrequirements = gathersupportedrequirements(ui)
482
482
483 # We first validate the requirements are known.
483 # We first validate the requirements are known.
484 ensurerequirementsrecognized(requirements, supportedrequirements)
484 ensurerequirementsrecognized(requirements, supportedrequirements)
485
485
486 # Then we validate that the known set is reasonable to use together.
486 # Then we validate that the known set is reasonable to use together.
487 ensurerequirementscompatible(ui, requirements)
487 ensurerequirementscompatible(ui, requirements)
488
488
489 # TODO there are unhandled edge cases related to opening repositories with
489 # TODO there are unhandled edge cases related to opening repositories with
490 # shared storage. If storage is shared, we should also test for requirements
490 # shared storage. If storage is shared, we should also test for requirements
491 # compatibility in the pointed-to repo. This entails loading the .hg/hgrc in
491 # compatibility in the pointed-to repo. This entails loading the .hg/hgrc in
492 # that repo, as that repo may load extensions needed to open it. This is a
492 # that repo, as that repo may load extensions needed to open it. This is a
493 # bit complicated because we don't want the other hgrc to overwrite settings
493 # bit complicated because we don't want the other hgrc to overwrite settings
494 # in this hgrc.
494 # in this hgrc.
495 #
495 #
496 # This bug is somewhat mitigated by the fact that we copy the .hg/requires
496 # This bug is somewhat mitigated by the fact that we copy the .hg/requires
497 # file when sharing repos. But if a requirement is added after the share is
497 # file when sharing repos. But if a requirement is added after the share is
498 # performed, thereby introducing a new requirement for the opener, we may
498 # performed, thereby introducing a new requirement for the opener, we may
499 # will not see that and could encounter a run-time error interacting with
499 # will not see that and could encounter a run-time error interacting with
500 # that shared store since it has an unknown-to-us requirement.
500 # that shared store since it has an unknown-to-us requirement.
501
501
502 # At this point, we know we should be capable of opening the repository.
502 # At this point, we know we should be capable of opening the repository.
503 # Now get on with doing that.
503 # Now get on with doing that.
504
504
505 features = set()
505 features = set()
506
506
507 # The "store" part of the repository holds versioned data. How it is
507 # The "store" part of the repository holds versioned data. How it is
508 # accessed is determined by various requirements. The ``shared`` or
508 # accessed is determined by various requirements. The ``shared`` or
509 # ``relshared`` requirements indicate the store lives in the path contained
509 # ``relshared`` requirements indicate the store lives in the path contained
510 # in the ``.hg/sharedpath`` file. This is an absolute path for
510 # in the ``.hg/sharedpath`` file. This is an absolute path for
511 # ``shared`` and relative to ``.hg/`` for ``relshared``.
511 # ``shared`` and relative to ``.hg/`` for ``relshared``.
512 if b'shared' in requirements or b'relshared' in requirements:
512 if b'shared' in requirements or b'relshared' in requirements:
513 sharedpath = hgvfs.read(b'sharedpath').rstrip(b'\n')
513 sharedpath = hgvfs.read(b'sharedpath').rstrip(b'\n')
514 if b'relshared' in requirements:
514 if b'relshared' in requirements:
515 sharedpath = hgvfs.join(sharedpath)
515 sharedpath = hgvfs.join(sharedpath)
516
516
517 sharedvfs = vfsmod.vfs(sharedpath, realpath=True)
517 sharedvfs = vfsmod.vfs(sharedpath, realpath=True)
518
518
519 if not sharedvfs.exists():
519 if not sharedvfs.exists():
520 raise error.RepoError(_(b'.hg/sharedpath points to nonexistent '
520 raise error.RepoError(_(b'.hg/sharedpath points to nonexistent '
521 b'directory %s') % sharedvfs.base)
521 b'directory %s') % sharedvfs.base)
522
522
523 features.add(repository.REPO_FEATURE_SHARED_STORAGE)
523 features.add(repository.REPO_FEATURE_SHARED_STORAGE)
524
524
525 storebasepath = sharedvfs.base
525 storebasepath = sharedvfs.base
526 cachepath = sharedvfs.join(b'cache')
526 cachepath = sharedvfs.join(b'cache')
527 else:
527 else:
528 storebasepath = hgvfs.base
528 storebasepath = hgvfs.base
529 cachepath = hgvfs.join(b'cache')
529 cachepath = hgvfs.join(b'cache')
530 wcachepath = hgvfs.join(b'wcache')
530 wcachepath = hgvfs.join(b'wcache')
531
531
532
532
533 # The store has changed over time and the exact layout is dictated by
533 # The store has changed over time and the exact layout is dictated by
534 # requirements. The store interface abstracts differences across all
534 # requirements. The store interface abstracts differences across all
535 # of them.
535 # of them.
536 store = makestore(requirements, storebasepath,
536 store = makestore(requirements, storebasepath,
537 lambda base: vfsmod.vfs(base, cacheaudited=True))
537 lambda base: vfsmod.vfs(base, cacheaudited=True))
538 hgvfs.createmode = store.createmode
538 hgvfs.createmode = store.createmode
539
539
540 storevfs = store.vfs
540 storevfs = store.vfs
541 storevfs.options = resolvestorevfsoptions(ui, requirements, features)
541 storevfs.options = resolvestorevfsoptions(ui, requirements, features)
542
542
543 # The cache vfs is used to manage cache files.
543 # The cache vfs is used to manage cache files.
544 cachevfs = vfsmod.vfs(cachepath, cacheaudited=True)
544 cachevfs = vfsmod.vfs(cachepath, cacheaudited=True)
545 cachevfs.createmode = store.createmode
545 cachevfs.createmode = store.createmode
546 # The cache vfs is used to manage cache files related to the working copy
546 # The cache vfs is used to manage cache files related to the working copy
547 wcachevfs = vfsmod.vfs(wcachepath, cacheaudited=True)
547 wcachevfs = vfsmod.vfs(wcachepath, cacheaudited=True)
548 wcachevfs.createmode = store.createmode
548 wcachevfs.createmode = store.createmode
549
549
550 # Now resolve the type for the repository object. We do this by repeatedly
550 # Now resolve the type for the repository object. We do this by repeatedly
551 # calling a factory function to produces types for specific aspects of the
551 # calling a factory function to produces types for specific aspects of the
552 # repo's operation. The aggregate returned types are used as base classes
552 # repo's operation. The aggregate returned types are used as base classes
553 # for a dynamically-derived type, which will represent our new repository.
553 # for a dynamically-derived type, which will represent our new repository.
554
554
555 bases = []
555 bases = []
556 extrastate = {}
556 extrastate = {}
557
557
558 for iface, fn in REPO_INTERFACES:
558 for iface, fn in REPO_INTERFACES:
559 # We pass all potentially useful state to give extensions tons of
559 # We pass all potentially useful state to give extensions tons of
560 # flexibility.
560 # flexibility.
561 typ = fn()(ui=ui,
561 typ = fn()(ui=ui,
562 intents=intents,
562 intents=intents,
563 requirements=requirements,
563 requirements=requirements,
564 features=features,
564 features=features,
565 wdirvfs=wdirvfs,
565 wdirvfs=wdirvfs,
566 hgvfs=hgvfs,
566 hgvfs=hgvfs,
567 store=store,
567 store=store,
568 storevfs=storevfs,
568 storevfs=storevfs,
569 storeoptions=storevfs.options,
569 storeoptions=storevfs.options,
570 cachevfs=cachevfs,
570 cachevfs=cachevfs,
571 wcachevfs=wcachevfs,
571 wcachevfs=wcachevfs,
572 extensionmodulenames=extensionmodulenames,
572 extensionmodulenames=extensionmodulenames,
573 extrastate=extrastate,
573 extrastate=extrastate,
574 baseclasses=bases)
574 baseclasses=bases)
575
575
576 if not isinstance(typ, type):
576 if not isinstance(typ, type):
577 raise error.ProgrammingError('unable to construct type for %s' %
577 raise error.ProgrammingError('unable to construct type for %s' %
578 iface)
578 iface)
579
579
580 bases.append(typ)
580 bases.append(typ)
581
581
582 # type() allows you to use characters in type names that wouldn't be
582 # type() allows you to use characters in type names that wouldn't be
583 # recognized as Python symbols in source code. We abuse that to add
583 # recognized as Python symbols in source code. We abuse that to add
584 # rich information about our constructed repo.
584 # rich information about our constructed repo.
585 name = pycompat.sysstr(b'derivedrepo:%s<%s>' % (
585 name = pycompat.sysstr(b'derivedrepo:%s<%s>' % (
586 wdirvfs.base,
586 wdirvfs.base,
587 b','.join(sorted(requirements))))
587 b','.join(sorted(requirements))))
588
588
589 cls = type(name, tuple(bases), {})
589 cls = type(name, tuple(bases), {})
590
590
591 return cls(
591 return cls(
592 baseui=baseui,
592 baseui=baseui,
593 ui=ui,
593 ui=ui,
594 origroot=path,
594 origroot=path,
595 wdirvfs=wdirvfs,
595 wdirvfs=wdirvfs,
596 hgvfs=hgvfs,
596 hgvfs=hgvfs,
597 requirements=requirements,
597 requirements=requirements,
598 supportedrequirements=supportedrequirements,
598 supportedrequirements=supportedrequirements,
599 sharedpath=storebasepath,
599 sharedpath=storebasepath,
600 store=store,
600 store=store,
601 cachevfs=cachevfs,
601 cachevfs=cachevfs,
602 wcachevfs=wcachevfs,
602 wcachevfs=wcachevfs,
603 features=features,
603 features=features,
604 intents=intents)
604 intents=intents)
605
605
606 def loadhgrc(ui, wdirvfs, hgvfs, requirements):
606 def loadhgrc(ui, wdirvfs, hgvfs, requirements):
607 """Load hgrc files/content into a ui instance.
607 """Load hgrc files/content into a ui instance.
608
608
609 This is called during repository opening to load any additional
609 This is called during repository opening to load any additional
610 config files or settings relevant to the current repository.
610 config files or settings relevant to the current repository.
611
611
612 Returns a bool indicating whether any additional configs were loaded.
612 Returns a bool indicating whether any additional configs were loaded.
613
613
614 Extensions should monkeypatch this function to modify how per-repo
614 Extensions should monkeypatch this function to modify how per-repo
615 configs are loaded. For example, an extension may wish to pull in
615 configs are loaded. For example, an extension may wish to pull in
616 configs from alternate files or sources.
616 configs from alternate files or sources.
617 """
617 """
618 try:
618 try:
619 ui.readconfig(hgvfs.join(b'hgrc'), root=wdirvfs.base)
619 ui.readconfig(hgvfs.join(b'hgrc'), root=wdirvfs.base)
620 return True
620 return True
621 except IOError:
621 except IOError:
622 return False
622 return False
623
623
624 def afterhgrcload(ui, wdirvfs, hgvfs, requirements):
624 def afterhgrcload(ui, wdirvfs, hgvfs, requirements):
625 """Perform additional actions after .hg/hgrc is loaded.
625 """Perform additional actions after .hg/hgrc is loaded.
626
626
627 This function is called during repository loading immediately after
627 This function is called during repository loading immediately after
628 the .hg/hgrc file is loaded and before per-repo extensions are loaded.
628 the .hg/hgrc file is loaded and before per-repo extensions are loaded.
629
629
630 The function can be used to validate configs, automatically add
630 The function can be used to validate configs, automatically add
631 options (including extensions) based on requirements, etc.
631 options (including extensions) based on requirements, etc.
632 """
632 """
633
633
634 # Map of requirements to list of extensions to load automatically when
634 # Map of requirements to list of extensions to load automatically when
635 # requirement is present.
635 # requirement is present.
636 autoextensions = {
636 autoextensions = {
637 b'largefiles': [b'largefiles'],
637 b'largefiles': [b'largefiles'],
638 b'lfs': [b'lfs'],
638 b'lfs': [b'lfs'],
639 }
639 }
640
640
641 for requirement, names in sorted(autoextensions.items()):
641 for requirement, names in sorted(autoextensions.items()):
642 if requirement not in requirements:
642 if requirement not in requirements:
643 continue
643 continue
644
644
645 for name in names:
645 for name in names:
646 if not ui.hasconfig(b'extensions', name):
646 if not ui.hasconfig(b'extensions', name):
647 ui.setconfig(b'extensions', name, b'', source='autoload')
647 ui.setconfig(b'extensions', name, b'', source='autoload')
648
648
649 def gathersupportedrequirements(ui):
649 def gathersupportedrequirements(ui):
650 """Determine the complete set of recognized requirements."""
650 """Determine the complete set of recognized requirements."""
651 # Start with all requirements supported by this file.
651 # Start with all requirements supported by this file.
652 supported = set(localrepository._basesupported)
652 supported = set(localrepository._basesupported)
653
653
654 # Execute ``featuresetupfuncs`` entries if they belong to an extension
654 # Execute ``featuresetupfuncs`` entries if they belong to an extension
655 # relevant to this ui instance.
655 # relevant to this ui instance.
656 modules = {m.__name__ for n, m in extensions.extensions(ui)}
656 modules = {m.__name__ for n, m in extensions.extensions(ui)}
657
657
658 for fn in featuresetupfuncs:
658 for fn in featuresetupfuncs:
659 if fn.__module__ in modules:
659 if fn.__module__ in modules:
660 fn(ui, supported)
660 fn(ui, supported)
661
661
662 # Add derived requirements from registered compression engines.
662 # Add derived requirements from registered compression engines.
663 for name in util.compengines:
663 for name in util.compengines:
664 engine = util.compengines[name]
664 engine = util.compengines[name]
665 if engine.available() and engine.revlogheader():
665 if engine.available() and engine.revlogheader():
666 supported.add(b'exp-compression-%s' % name)
666 supported.add(b'exp-compression-%s' % name)
667 if engine.name() == 'zstd':
667 if engine.name() == 'zstd':
668 supported.add(b'revlog-compression-zstd')
668 supported.add(b'revlog-compression-zstd')
669
669
670 return supported
670 return supported
671
671
672 def ensurerequirementsrecognized(requirements, supported):
672 def ensurerequirementsrecognized(requirements, supported):
673 """Validate that a set of local requirements is recognized.
673 """Validate that a set of local requirements is recognized.
674
674
675 Receives a set of requirements. Raises an ``error.RepoError`` if there
675 Receives a set of requirements. Raises an ``error.RepoError`` if there
676 exists any requirement in that set that currently loaded code doesn't
676 exists any requirement in that set that currently loaded code doesn't
677 recognize.
677 recognize.
678
678
679 Returns a set of supported requirements.
679 Returns a set of supported requirements.
680 """
680 """
681 missing = set()
681 missing = set()
682
682
683 for requirement in requirements:
683 for requirement in requirements:
684 if requirement in supported:
684 if requirement in supported:
685 continue
685 continue
686
686
687 if not requirement or not requirement[0:1].isalnum():
687 if not requirement or not requirement[0:1].isalnum():
688 raise error.RequirementError(_(b'.hg/requires file is corrupt'))
688 raise error.RequirementError(_(b'.hg/requires file is corrupt'))
689
689
690 missing.add(requirement)
690 missing.add(requirement)
691
691
692 if missing:
692 if missing:
693 raise error.RequirementError(
693 raise error.RequirementError(
694 _(b'repository requires features unknown to this Mercurial: %s') %
694 _(b'repository requires features unknown to this Mercurial: %s') %
695 b' '.join(sorted(missing)),
695 b' '.join(sorted(missing)),
696 hint=_(b'see https://mercurial-scm.org/wiki/MissingRequirement '
696 hint=_(b'see https://mercurial-scm.org/wiki/MissingRequirement '
697 b'for more information'))
697 b'for more information'))
698
698
699 def ensurerequirementscompatible(ui, requirements):
699 def ensurerequirementscompatible(ui, requirements):
700 """Validates that a set of recognized requirements is mutually compatible.
700 """Validates that a set of recognized requirements is mutually compatible.
701
701
702 Some requirements may not be compatible with others or require
702 Some requirements may not be compatible with others or require
703 config options that aren't enabled. This function is called during
703 config options that aren't enabled. This function is called during
704 repository opening to ensure that the set of requirements needed
704 repository opening to ensure that the set of requirements needed
705 to open a repository is sane and compatible with config options.
705 to open a repository is sane and compatible with config options.
706
706
707 Extensions can monkeypatch this function to perform additional
707 Extensions can monkeypatch this function to perform additional
708 checking.
708 checking.
709
709
710 ``error.RepoError`` should be raised on failure.
710 ``error.RepoError`` should be raised on failure.
711 """
711 """
712 if b'exp-sparse' in requirements and not sparse.enabled:
712 if b'exp-sparse' in requirements and not sparse.enabled:
713 raise error.RepoError(_(b'repository is using sparse feature but '
713 raise error.RepoError(_(b'repository is using sparse feature but '
714 b'sparse is not enabled; enable the '
714 b'sparse is not enabled; enable the '
715 b'"sparse" extensions to access'))
715 b'"sparse" extensions to access'))
716
716
717 def makestore(requirements, path, vfstype):
717 def makestore(requirements, path, vfstype):
718 """Construct a storage object for a repository."""
718 """Construct a storage object for a repository."""
719 if b'store' in requirements:
719 if b'store' in requirements:
720 if b'fncache' in requirements:
720 if b'fncache' in requirements:
721 return storemod.fncachestore(path, vfstype,
721 return storemod.fncachestore(path, vfstype,
722 b'dotencode' in requirements)
722 b'dotencode' in requirements)
723
723
724 return storemod.encodedstore(path, vfstype)
724 return storemod.encodedstore(path, vfstype)
725
725
726 return storemod.basicstore(path, vfstype)
726 return storemod.basicstore(path, vfstype)
727
727
728 def resolvestorevfsoptions(ui, requirements, features):
728 def resolvestorevfsoptions(ui, requirements, features):
729 """Resolve the options to pass to the store vfs opener.
729 """Resolve the options to pass to the store vfs opener.
730
730
731 The returned dict is used to influence behavior of the storage layer.
731 The returned dict is used to influence behavior of the storage layer.
732 """
732 """
733 options = {}
733 options = {}
734
734
735 if b'treemanifest' in requirements:
735 if b'treemanifest' in requirements:
736 options[b'treemanifest'] = True
736 options[b'treemanifest'] = True
737
737
738 # experimental config: format.manifestcachesize
738 # experimental config: format.manifestcachesize
739 manifestcachesize = ui.configint(b'format', b'manifestcachesize')
739 manifestcachesize = ui.configint(b'format', b'manifestcachesize')
740 if manifestcachesize is not None:
740 if manifestcachesize is not None:
741 options[b'manifestcachesize'] = manifestcachesize
741 options[b'manifestcachesize'] = manifestcachesize
742
742
743 # In the absence of another requirement superseding a revlog-related
743 # In the absence of another requirement superseding a revlog-related
744 # requirement, we have to assume the repo is using revlog version 0.
744 # requirement, we have to assume the repo is using revlog version 0.
745 # This revlog format is super old and we don't bother trying to parse
745 # This revlog format is super old and we don't bother trying to parse
746 # opener options for it because those options wouldn't do anything
746 # opener options for it because those options wouldn't do anything
747 # meaningful on such old repos.
747 # meaningful on such old repos.
748 if b'revlogv1' in requirements or REVLOGV2_REQUIREMENT in requirements:
748 if b'revlogv1' in requirements or REVLOGV2_REQUIREMENT in requirements:
749 options.update(resolverevlogstorevfsoptions(ui, requirements, features))
749 options.update(resolverevlogstorevfsoptions(ui, requirements, features))
750
750
751 return options
751 return options
752
752
753 def resolverevlogstorevfsoptions(ui, requirements, features):
753 def resolverevlogstorevfsoptions(ui, requirements, features):
754 """Resolve opener options specific to revlogs."""
754 """Resolve opener options specific to revlogs."""
755
755
756 options = {}
756 options = {}
757 options[b'flagprocessors'] = {}
757 options[b'flagprocessors'] = {}
758
758
759 if b'revlogv1' in requirements:
759 if b'revlogv1' in requirements:
760 options[b'revlogv1'] = True
760 options[b'revlogv1'] = True
761 if REVLOGV2_REQUIREMENT in requirements:
761 if REVLOGV2_REQUIREMENT in requirements:
762 options[b'revlogv2'] = True
762 options[b'revlogv2'] = True
763
763
764 if b'generaldelta' in requirements:
764 if b'generaldelta' in requirements:
765 options[b'generaldelta'] = True
765 options[b'generaldelta'] = True
766
766
767 # experimental config: format.chunkcachesize
767 # experimental config: format.chunkcachesize
768 chunkcachesize = ui.configint(b'format', b'chunkcachesize')
768 chunkcachesize = ui.configint(b'format', b'chunkcachesize')
769 if chunkcachesize is not None:
769 if chunkcachesize is not None:
770 options[b'chunkcachesize'] = chunkcachesize
770 options[b'chunkcachesize'] = chunkcachesize
771
771
772 deltabothparents = ui.configbool(b'storage',
772 deltabothparents = ui.configbool(b'storage',
773 b'revlog.optimize-delta-parent-choice')
773 b'revlog.optimize-delta-parent-choice')
774 options[b'deltabothparents'] = deltabothparents
774 options[b'deltabothparents'] = deltabothparents
775
775
776 lazydelta = ui.configbool(b'storage', b'revlog.reuse-external-delta')
776 lazydelta = ui.configbool(b'storage', b'revlog.reuse-external-delta')
777 lazydeltabase = False
777 lazydeltabase = False
778 if lazydelta:
778 if lazydelta:
779 lazydeltabase = ui.configbool(b'storage',
779 lazydeltabase = ui.configbool(b'storage',
780 b'revlog.reuse-external-delta-parent')
780 b'revlog.reuse-external-delta-parent')
781 if lazydeltabase is None:
781 if lazydeltabase is None:
782 lazydeltabase = not scmutil.gddeltaconfig(ui)
782 lazydeltabase = not scmutil.gddeltaconfig(ui)
783 options[b'lazydelta'] = lazydelta
783 options[b'lazydelta'] = lazydelta
784 options[b'lazydeltabase'] = lazydeltabase
784 options[b'lazydeltabase'] = lazydeltabase
785
785
786 chainspan = ui.configbytes(b'experimental', b'maxdeltachainspan')
786 chainspan = ui.configbytes(b'experimental', b'maxdeltachainspan')
787 if 0 <= chainspan:
787 if 0 <= chainspan:
788 options[b'maxdeltachainspan'] = chainspan
788 options[b'maxdeltachainspan'] = chainspan
789
789
790 mmapindexthreshold = ui.configbytes(b'experimental',
790 mmapindexthreshold = ui.configbytes(b'experimental',
791 b'mmapindexthreshold')
791 b'mmapindexthreshold')
792 if mmapindexthreshold is not None:
792 if mmapindexthreshold is not None:
793 options[b'mmapindexthreshold'] = mmapindexthreshold
793 options[b'mmapindexthreshold'] = mmapindexthreshold
794
794
795 withsparseread = ui.configbool(b'experimental', b'sparse-read')
795 withsparseread = ui.configbool(b'experimental', b'sparse-read')
796 srdensitythres = float(ui.config(b'experimental',
796 srdensitythres = float(ui.config(b'experimental',
797 b'sparse-read.density-threshold'))
797 b'sparse-read.density-threshold'))
798 srmingapsize = ui.configbytes(b'experimental',
798 srmingapsize = ui.configbytes(b'experimental',
799 b'sparse-read.min-gap-size')
799 b'sparse-read.min-gap-size')
800 options[b'with-sparse-read'] = withsparseread
800 options[b'with-sparse-read'] = withsparseread
801 options[b'sparse-read-density-threshold'] = srdensitythres
801 options[b'sparse-read-density-threshold'] = srdensitythres
802 options[b'sparse-read-min-gap-size'] = srmingapsize
802 options[b'sparse-read-min-gap-size'] = srmingapsize
803
803
804 sparserevlog = SPARSEREVLOG_REQUIREMENT in requirements
804 sparserevlog = SPARSEREVLOG_REQUIREMENT in requirements
805 options[b'sparse-revlog'] = sparserevlog
805 options[b'sparse-revlog'] = sparserevlog
806 if sparserevlog:
806 if sparserevlog:
807 options[b'generaldelta'] = True
807 options[b'generaldelta'] = True
808
808
809 maxchainlen = None
809 maxchainlen = None
810 if sparserevlog:
810 if sparserevlog:
811 maxchainlen = revlogconst.SPARSE_REVLOG_MAX_CHAIN_LENGTH
811 maxchainlen = revlogconst.SPARSE_REVLOG_MAX_CHAIN_LENGTH
812 # experimental config: format.maxchainlen
812 # experimental config: format.maxchainlen
813 maxchainlen = ui.configint(b'format', b'maxchainlen', maxchainlen)
813 maxchainlen = ui.configint(b'format', b'maxchainlen', maxchainlen)
814 if maxchainlen is not None:
814 if maxchainlen is not None:
815 options[b'maxchainlen'] = maxchainlen
815 options[b'maxchainlen'] = maxchainlen
816
816
817 for r in requirements:
817 for r in requirements:
818 # we allow multiple compression engine requirement to co-exist because
818 # we allow multiple compression engine requirement to co-exist because
819 # strickly speaking, revlog seems to support mixed compression style.
819 # strickly speaking, revlog seems to support mixed compression style.
820 #
820 #
821 # The compression used for new entries will be "the last one"
821 # The compression used for new entries will be "the last one"
822 prefix = r.startswith
822 prefix = r.startswith
823 if prefix('revlog-compression-') or prefix('exp-compression-'):
823 if prefix('revlog-compression-') or prefix('exp-compression-'):
824 options[b'compengine'] = r.split('-', 2)[2]
824 options[b'compengine'] = r.split('-', 2)[2]
825
825
826 options[b'zlib.level'] = ui.configint(b'storage', b'revlog.zlib.level')
826 options[b'zlib.level'] = ui.configint(b'storage', b'revlog.zlib.level')
827 if options[b'zlib.level'] is not None:
827 if options[b'zlib.level'] is not None:
828 if not (0 <= options[b'zlib.level'] <= 9):
828 if not (0 <= options[b'zlib.level'] <= 9):
829 msg = _('invalid value for `storage.revlog.zlib.level` config: %d')
829 msg = _('invalid value for `storage.revlog.zlib.level` config: %d')
830 raise error.Abort(msg % options[b'zlib.level'])
830 raise error.Abort(msg % options[b'zlib.level'])
831 options[b'zstd.level'] = ui.configint(b'storage', b'revlog.zstd.level')
831 options[b'zstd.level'] = ui.configint(b'storage', b'revlog.zstd.level')
832 if options[b'zstd.level'] is not None:
832 if options[b'zstd.level'] is not None:
833 if not (0 <= options[b'zstd.level'] <= 22):
833 if not (0 <= options[b'zstd.level'] <= 22):
834 msg = _('invalid value for `storage.revlog.zstd.level` config: %d')
834 msg = _('invalid value for `storage.revlog.zstd.level` config: %d')
835 raise error.Abort(msg % options[b'zstd.level'])
835 raise error.Abort(msg % options[b'zstd.level'])
836
836
837 if repository.NARROW_REQUIREMENT in requirements:
837 if repository.NARROW_REQUIREMENT in requirements:
838 options[b'enableellipsis'] = True
838 options[b'enableellipsis'] = True
839
839
840 return options
840 return options
841
841
842 def makemain(**kwargs):
842 def makemain(**kwargs):
843 """Produce a type conforming to ``ilocalrepositorymain``."""
843 """Produce a type conforming to ``ilocalrepositorymain``."""
844 return localrepository
844 return localrepository
845
845
846 @interfaceutil.implementer(repository.ilocalrepositoryfilestorage)
846 @interfaceutil.implementer(repository.ilocalrepositoryfilestorage)
847 class revlogfilestorage(object):
847 class revlogfilestorage(object):
848 """File storage when using revlogs."""
848 """File storage when using revlogs."""
849
849
850 def file(self, path):
850 def file(self, path):
851 if path[0] == b'/':
851 if path[0] == b'/':
852 path = path[1:]
852 path = path[1:]
853
853
854 return filelog.filelog(self.svfs, path)
854 return filelog.filelog(self.svfs, path)
855
855
856 @interfaceutil.implementer(repository.ilocalrepositoryfilestorage)
856 @interfaceutil.implementer(repository.ilocalrepositoryfilestorage)
857 class revlognarrowfilestorage(object):
857 class revlognarrowfilestorage(object):
858 """File storage when using revlogs and narrow files."""
858 """File storage when using revlogs and narrow files."""
859
859
860 def file(self, path):
860 def file(self, path):
861 if path[0] == b'/':
861 if path[0] == b'/':
862 path = path[1:]
862 path = path[1:]
863
863
864 return filelog.narrowfilelog(self.svfs, path, self._storenarrowmatch)
864 return filelog.narrowfilelog(self.svfs, path, self._storenarrowmatch)
865
865
866 def makefilestorage(requirements, features, **kwargs):
866 def makefilestorage(requirements, features, **kwargs):
867 """Produce a type conforming to ``ilocalrepositoryfilestorage``."""
867 """Produce a type conforming to ``ilocalrepositoryfilestorage``."""
868 features.add(repository.REPO_FEATURE_REVLOG_FILE_STORAGE)
868 features.add(repository.REPO_FEATURE_REVLOG_FILE_STORAGE)
869 features.add(repository.REPO_FEATURE_STREAM_CLONE)
869 features.add(repository.REPO_FEATURE_STREAM_CLONE)
870
870
871 if repository.NARROW_REQUIREMENT in requirements:
871 if repository.NARROW_REQUIREMENT in requirements:
872 return revlognarrowfilestorage
872 return revlognarrowfilestorage
873 else:
873 else:
874 return revlogfilestorage
874 return revlogfilestorage
875
875
876 # List of repository interfaces and factory functions for them. Each
876 # List of repository interfaces and factory functions for them. Each
877 # will be called in order during ``makelocalrepository()`` to iteratively
877 # will be called in order during ``makelocalrepository()`` to iteratively
878 # derive the final type for a local repository instance. We capture the
878 # derive the final type for a local repository instance. We capture the
879 # function as a lambda so we don't hold a reference and the module-level
879 # function as a lambda so we don't hold a reference and the module-level
880 # functions can be wrapped.
880 # functions can be wrapped.
881 REPO_INTERFACES = [
881 REPO_INTERFACES = [
882 (repository.ilocalrepositorymain, lambda: makemain),
882 (repository.ilocalrepositorymain, lambda: makemain),
883 (repository.ilocalrepositoryfilestorage, lambda: makefilestorage),
883 (repository.ilocalrepositoryfilestorage, lambda: makefilestorage),
884 ]
884 ]
885
885
886 @interfaceutil.implementer(repository.ilocalrepositorymain)
886 @interfaceutil.implementer(repository.ilocalrepositorymain)
887 class localrepository(object):
887 class localrepository(object):
888 """Main class for representing local repositories.
888 """Main class for representing local repositories.
889
889
890 All local repositories are instances of this class.
890 All local repositories are instances of this class.
891
891
892 Constructed on its own, instances of this class are not usable as
892 Constructed on its own, instances of this class are not usable as
893 repository objects. To obtain a usable repository object, call
893 repository objects. To obtain a usable repository object, call
894 ``hg.repository()``, ``localrepo.instance()``, or
894 ``hg.repository()``, ``localrepo.instance()``, or
895 ``localrepo.makelocalrepository()``. The latter is the lowest-level.
895 ``localrepo.makelocalrepository()``. The latter is the lowest-level.
896 ``instance()`` adds support for creating new repositories.
896 ``instance()`` adds support for creating new repositories.
897 ``hg.repository()`` adds more extension integration, including calling
897 ``hg.repository()`` adds more extension integration, including calling
898 ``reposetup()``. Generally speaking, ``hg.repository()`` should be
898 ``reposetup()``. Generally speaking, ``hg.repository()`` should be
899 used.
899 used.
900 """
900 """
901
901
902 # obsolete experimental requirements:
902 # obsolete experimental requirements:
903 # - manifestv2: An experimental new manifest format that allowed
903 # - manifestv2: An experimental new manifest format that allowed
904 # for stem compression of long paths. Experiment ended up not
904 # for stem compression of long paths. Experiment ended up not
905 # being successful (repository sizes went up due to worse delta
905 # being successful (repository sizes went up due to worse delta
906 # chains), and the code was deleted in 4.6.
906 # chains), and the code was deleted in 4.6.
907 supportedformats = {
907 supportedformats = {
908 'revlogv1',
908 'revlogv1',
909 'generaldelta',
909 'generaldelta',
910 'treemanifest',
910 'treemanifest',
911 REVLOGV2_REQUIREMENT,
911 REVLOGV2_REQUIREMENT,
912 SPARSEREVLOG_REQUIREMENT,
912 SPARSEREVLOG_REQUIREMENT,
913 }
913 }
914 _basesupported = supportedformats | {
914 _basesupported = supportedformats | {
915 'store',
915 'store',
916 'fncache',
916 'fncache',
917 'shared',
917 'shared',
918 'relshared',
918 'relshared',
919 'dotencode',
919 'dotencode',
920 'exp-sparse',
920 'exp-sparse',
921 'internal-phase'
921 'internal-phase'
922 }
922 }
923
923
924 # list of prefix for file which can be written without 'wlock'
924 # list of prefix for file which can be written without 'wlock'
925 # Extensions should extend this list when needed
925 # Extensions should extend this list when needed
926 _wlockfreeprefix = {
926 _wlockfreeprefix = {
927 # We migh consider requiring 'wlock' for the next
927 # We migh consider requiring 'wlock' for the next
928 # two, but pretty much all the existing code assume
928 # two, but pretty much all the existing code assume
929 # wlock is not needed so we keep them excluded for
929 # wlock is not needed so we keep them excluded for
930 # now.
930 # now.
931 'hgrc',
931 'hgrc',
932 'requires',
932 'requires',
933 # XXX cache is a complicatged business someone
933 # XXX cache is a complicatged business someone
934 # should investigate this in depth at some point
934 # should investigate this in depth at some point
935 'cache/',
935 'cache/',
936 # XXX shouldn't be dirstate covered by the wlock?
936 # XXX shouldn't be dirstate covered by the wlock?
937 'dirstate',
937 'dirstate',
938 # XXX bisect was still a bit too messy at the time
938 # XXX bisect was still a bit too messy at the time
939 # this changeset was introduced. Someone should fix
939 # this changeset was introduced. Someone should fix
940 # the remainig bit and drop this line
940 # the remainig bit and drop this line
941 'bisect.state',
941 'bisect.state',
942 }
942 }
943
943
944 def __init__(self, baseui, ui, origroot, wdirvfs, hgvfs, requirements,
944 def __init__(self, baseui, ui, origroot, wdirvfs, hgvfs, requirements,
945 supportedrequirements, sharedpath, store, cachevfs, wcachevfs,
945 supportedrequirements, sharedpath, store, cachevfs, wcachevfs,
946 features, intents=None):
946 features, intents=None):
947 """Create a new local repository instance.
947 """Create a new local repository instance.
948
948
949 Most callers should use ``hg.repository()``, ``localrepo.instance()``,
949 Most callers should use ``hg.repository()``, ``localrepo.instance()``,
950 or ``localrepo.makelocalrepository()`` for obtaining a new repository
950 or ``localrepo.makelocalrepository()`` for obtaining a new repository
951 object.
951 object.
952
952
953 Arguments:
953 Arguments:
954
954
955 baseui
955 baseui
956 ``ui.ui`` instance that ``ui`` argument was based off of.
956 ``ui.ui`` instance that ``ui`` argument was based off of.
957
957
958 ui
958 ui
959 ``ui.ui`` instance for use by the repository.
959 ``ui.ui`` instance for use by the repository.
960
960
961 origroot
961 origroot
962 ``bytes`` path to working directory root of this repository.
962 ``bytes`` path to working directory root of this repository.
963
963
964 wdirvfs
964 wdirvfs
965 ``vfs.vfs`` rooted at the working directory.
965 ``vfs.vfs`` rooted at the working directory.
966
966
967 hgvfs
967 hgvfs
968 ``vfs.vfs`` rooted at .hg/
968 ``vfs.vfs`` rooted at .hg/
969
969
970 requirements
970 requirements
971 ``set`` of bytestrings representing repository opening requirements.
971 ``set`` of bytestrings representing repository opening requirements.
972
972
973 supportedrequirements
973 supportedrequirements
974 ``set`` of bytestrings representing repository requirements that we
974 ``set`` of bytestrings representing repository requirements that we
975 know how to open. May be a supetset of ``requirements``.
975 know how to open. May be a supetset of ``requirements``.
976
976
977 sharedpath
977 sharedpath
978 ``bytes`` Defining path to storage base directory. Points to a
978 ``bytes`` Defining path to storage base directory. Points to a
979 ``.hg/`` directory somewhere.
979 ``.hg/`` directory somewhere.
980
980
981 store
981 store
982 ``store.basicstore`` (or derived) instance providing access to
982 ``store.basicstore`` (or derived) instance providing access to
983 versioned storage.
983 versioned storage.
984
984
985 cachevfs
985 cachevfs
986 ``vfs.vfs`` used for cache files.
986 ``vfs.vfs`` used for cache files.
987
987
988 wcachevfs
988 wcachevfs
989 ``vfs.vfs`` used for cache files related to the working copy.
989 ``vfs.vfs`` used for cache files related to the working copy.
990
990
991 features
991 features
992 ``set`` of bytestrings defining features/capabilities of this
992 ``set`` of bytestrings defining features/capabilities of this
993 instance.
993 instance.
994
994
995 intents
995 intents
996 ``set`` of system strings indicating what this repo will be used
996 ``set`` of system strings indicating what this repo will be used
997 for.
997 for.
998 """
998 """
999 self.baseui = baseui
999 self.baseui = baseui
1000 self.ui = ui
1000 self.ui = ui
1001 self.origroot = origroot
1001 self.origroot = origroot
1002 # vfs rooted at working directory.
1002 # vfs rooted at working directory.
1003 self.wvfs = wdirvfs
1003 self.wvfs = wdirvfs
1004 self.root = wdirvfs.base
1004 self.root = wdirvfs.base
1005 # vfs rooted at .hg/. Used to access most non-store paths.
1005 # vfs rooted at .hg/. Used to access most non-store paths.
1006 self.vfs = hgvfs
1006 self.vfs = hgvfs
1007 self.path = hgvfs.base
1007 self.path = hgvfs.base
1008 self.requirements = requirements
1008 self.requirements = requirements
1009 self.supported = supportedrequirements
1009 self.supported = supportedrequirements
1010 self.sharedpath = sharedpath
1010 self.sharedpath = sharedpath
1011 self.store = store
1011 self.store = store
1012 self.cachevfs = cachevfs
1012 self.cachevfs = cachevfs
1013 self.wcachevfs = wcachevfs
1013 self.wcachevfs = wcachevfs
1014 self.features = features
1014 self.features = features
1015
1015
1016 self.filtername = None
1016 self.filtername = None
1017
1017
1018 if (self.ui.configbool('devel', 'all-warnings') or
1018 if (self.ui.configbool('devel', 'all-warnings') or
1019 self.ui.configbool('devel', 'check-locks')):
1019 self.ui.configbool('devel', 'check-locks')):
1020 self.vfs.audit = self._getvfsward(self.vfs.audit)
1020 self.vfs.audit = self._getvfsward(self.vfs.audit)
1021 # A list of callback to shape the phase if no data were found.
1021 # A list of callback to shape the phase if no data were found.
1022 # Callback are in the form: func(repo, roots) --> processed root.
1022 # Callback are in the form: func(repo, roots) --> processed root.
1023 # This list it to be filled by extension during repo setup
1023 # This list it to be filled by extension during repo setup
1024 self._phasedefaults = []
1024 self._phasedefaults = []
1025
1025
1026 color.setup(self.ui)
1026 color.setup(self.ui)
1027
1027
1028 self.spath = self.store.path
1028 self.spath = self.store.path
1029 self.svfs = self.store.vfs
1029 self.svfs = self.store.vfs
1030 self.sjoin = self.store.join
1030 self.sjoin = self.store.join
1031 if (self.ui.configbool('devel', 'all-warnings') or
1031 if (self.ui.configbool('devel', 'all-warnings') or
1032 self.ui.configbool('devel', 'check-locks')):
1032 self.ui.configbool('devel', 'check-locks')):
1033 if util.safehasattr(self.svfs, 'vfs'): # this is filtervfs
1033 if util.safehasattr(self.svfs, 'vfs'): # this is filtervfs
1034 self.svfs.vfs.audit = self._getsvfsward(self.svfs.vfs.audit)
1034 self.svfs.vfs.audit = self._getsvfsward(self.svfs.vfs.audit)
1035 else: # standard vfs
1035 else: # standard vfs
1036 self.svfs.audit = self._getsvfsward(self.svfs.audit)
1036 self.svfs.audit = self._getsvfsward(self.svfs.audit)
1037
1037
1038 self._dirstatevalidatewarned = False
1038 self._dirstatevalidatewarned = False
1039
1039
1040 self._branchcaches = branchmap.BranchMapCache()
1040 self._branchcaches = branchmap.BranchMapCache()
1041 self._revbranchcache = None
1041 self._revbranchcache = None
1042 self._filterpats = {}
1042 self._filterpats = {}
1043 self._datafilters = {}
1043 self._datafilters = {}
1044 self._transref = self._lockref = self._wlockref = None
1044 self._transref = self._lockref = self._wlockref = None
1045
1045
1046 # A cache for various files under .hg/ that tracks file changes,
1046 # A cache for various files under .hg/ that tracks file changes,
1047 # (used by the filecache decorator)
1047 # (used by the filecache decorator)
1048 #
1048 #
1049 # Maps a property name to its util.filecacheentry
1049 # Maps a property name to its util.filecacheentry
1050 self._filecache = {}
1050 self._filecache = {}
1051
1051
1052 # hold sets of revision to be filtered
1052 # hold sets of revision to be filtered
1053 # should be cleared when something might have changed the filter value:
1053 # should be cleared when something might have changed the filter value:
1054 # - new changesets,
1054 # - new changesets,
1055 # - phase change,
1055 # - phase change,
1056 # - new obsolescence marker,
1056 # - new obsolescence marker,
1057 # - working directory parent change,
1057 # - working directory parent change,
1058 # - bookmark changes
1058 # - bookmark changes
1059 self.filteredrevcache = {}
1059 self.filteredrevcache = {}
1060
1060
1061 # post-dirstate-status hooks
1061 # post-dirstate-status hooks
1062 self._postdsstatus = []
1062 self._postdsstatus = []
1063
1063
1064 # generic mapping between names and nodes
1064 # generic mapping between names and nodes
1065 self.names = namespaces.namespaces()
1065 self.names = namespaces.namespaces()
1066
1066
1067 # Key to signature value.
1067 # Key to signature value.
1068 self._sparsesignaturecache = {}
1068 self._sparsesignaturecache = {}
1069 # Signature to cached matcher instance.
1069 # Signature to cached matcher instance.
1070 self._sparsematchercache = {}
1070 self._sparsematchercache = {}
1071
1071
1072 def _getvfsward(self, origfunc):
1072 def _getvfsward(self, origfunc):
1073 """build a ward for self.vfs"""
1073 """build a ward for self.vfs"""
1074 rref = weakref.ref(self)
1074 rref = weakref.ref(self)
1075 def checkvfs(path, mode=None):
1075 def checkvfs(path, mode=None):
1076 ret = origfunc(path, mode=mode)
1076 ret = origfunc(path, mode=mode)
1077 repo = rref()
1077 repo = rref()
1078 if (repo is None
1078 if (repo is None
1079 or not util.safehasattr(repo, '_wlockref')
1079 or not util.safehasattr(repo, '_wlockref')
1080 or not util.safehasattr(repo, '_lockref')):
1080 or not util.safehasattr(repo, '_lockref')):
1081 return
1081 return
1082 if mode in (None, 'r', 'rb'):
1082 if mode in (None, 'r', 'rb'):
1083 return
1083 return
1084 if path.startswith(repo.path):
1084 if path.startswith(repo.path):
1085 # truncate name relative to the repository (.hg)
1085 # truncate name relative to the repository (.hg)
1086 path = path[len(repo.path) + 1:]
1086 path = path[len(repo.path) + 1:]
1087 if path.startswith('cache/'):
1087 if path.startswith('cache/'):
1088 msg = 'accessing cache with vfs instead of cachevfs: "%s"'
1088 msg = 'accessing cache with vfs instead of cachevfs: "%s"'
1089 repo.ui.develwarn(msg % path, stacklevel=3, config="cache-vfs")
1089 repo.ui.develwarn(msg % path, stacklevel=3, config="cache-vfs")
1090 if path.startswith('journal.') or path.startswith('undo.'):
1090 if path.startswith('journal.') or path.startswith('undo.'):
1091 # journal is covered by 'lock'
1091 # journal is covered by 'lock'
1092 if repo._currentlock(repo._lockref) is None:
1092 if repo._currentlock(repo._lockref) is None:
1093 repo.ui.develwarn('write with no lock: "%s"' % path,
1093 repo.ui.develwarn('write with no lock: "%s"' % path,
1094 stacklevel=3, config='check-locks')
1094 stacklevel=3, config='check-locks')
1095 elif repo._currentlock(repo._wlockref) is None:
1095 elif repo._currentlock(repo._wlockref) is None:
1096 # rest of vfs files are covered by 'wlock'
1096 # rest of vfs files are covered by 'wlock'
1097 #
1097 #
1098 # exclude special files
1098 # exclude special files
1099 for prefix in self._wlockfreeprefix:
1099 for prefix in self._wlockfreeprefix:
1100 if path.startswith(prefix):
1100 if path.startswith(prefix):
1101 return
1101 return
1102 repo.ui.develwarn('write with no wlock: "%s"' % path,
1102 repo.ui.develwarn('write with no wlock: "%s"' % path,
1103 stacklevel=3, config='check-locks')
1103 stacklevel=3, config='check-locks')
1104 return ret
1104 return ret
1105 return checkvfs
1105 return checkvfs
1106
1106
1107 def _getsvfsward(self, origfunc):
1107 def _getsvfsward(self, origfunc):
1108 """build a ward for self.svfs"""
1108 """build a ward for self.svfs"""
1109 rref = weakref.ref(self)
1109 rref = weakref.ref(self)
1110 def checksvfs(path, mode=None):
1110 def checksvfs(path, mode=None):
1111 ret = origfunc(path, mode=mode)
1111 ret = origfunc(path, mode=mode)
1112 repo = rref()
1112 repo = rref()
1113 if repo is None or not util.safehasattr(repo, '_lockref'):
1113 if repo is None or not util.safehasattr(repo, '_lockref'):
1114 return
1114 return
1115 if mode in (None, 'r', 'rb'):
1115 if mode in (None, 'r', 'rb'):
1116 return
1116 return
1117 if path.startswith(repo.sharedpath):
1117 if path.startswith(repo.sharedpath):
1118 # truncate name relative to the repository (.hg)
1118 # truncate name relative to the repository (.hg)
1119 path = path[len(repo.sharedpath) + 1:]
1119 path = path[len(repo.sharedpath) + 1:]
1120 if repo._currentlock(repo._lockref) is None:
1120 if repo._currentlock(repo._lockref) is None:
1121 repo.ui.develwarn('write with no lock: "%s"' % path,
1121 repo.ui.develwarn('write with no lock: "%s"' % path,
1122 stacklevel=4)
1122 stacklevel=4)
1123 return ret
1123 return ret
1124 return checksvfs
1124 return checksvfs
1125
1125
1126 def close(self):
1126 def close(self):
1127 self._writecaches()
1127 self._writecaches()
1128
1128
1129 def _writecaches(self):
1129 def _writecaches(self):
1130 if self._revbranchcache:
1130 if self._revbranchcache:
1131 self._revbranchcache.write()
1131 self._revbranchcache.write()
1132
1132
1133 def _restrictcapabilities(self, caps):
1133 def _restrictcapabilities(self, caps):
1134 if self.ui.configbool('experimental', 'bundle2-advertise'):
1134 if self.ui.configbool('experimental', 'bundle2-advertise'):
1135 caps = set(caps)
1135 caps = set(caps)
1136 capsblob = bundle2.encodecaps(bundle2.getrepocaps(self,
1136 capsblob = bundle2.encodecaps(bundle2.getrepocaps(self,
1137 role='client'))
1137 role='client'))
1138 caps.add('bundle2=' + urlreq.quote(capsblob))
1138 caps.add('bundle2=' + urlreq.quote(capsblob))
1139 return caps
1139 return caps
1140
1140
1141 def _writerequirements(self):
1141 def _writerequirements(self):
1142 scmutil.writerequires(self.vfs, self.requirements)
1142 scmutil.writerequires(self.vfs, self.requirements)
1143
1143
1144 # Don't cache auditor/nofsauditor, or you'll end up with reference cycle:
1144 # Don't cache auditor/nofsauditor, or you'll end up with reference cycle:
1145 # self -> auditor -> self._checknested -> self
1145 # self -> auditor -> self._checknested -> self
1146
1146
1147 @property
1147 @property
1148 def auditor(self):
1148 def auditor(self):
1149 # This is only used by context.workingctx.match in order to
1149 # This is only used by context.workingctx.match in order to
1150 # detect files in subrepos.
1150 # detect files in subrepos.
1151 return pathutil.pathauditor(self.root, callback=self._checknested)
1151 return pathutil.pathauditor(self.root, callback=self._checknested)
1152
1152
1153 @property
1153 @property
1154 def nofsauditor(self):
1154 def nofsauditor(self):
1155 # This is only used by context.basectx.match in order to detect
1155 # This is only used by context.basectx.match in order to detect
1156 # files in subrepos.
1156 # files in subrepos.
1157 return pathutil.pathauditor(self.root, callback=self._checknested,
1157 return pathutil.pathauditor(self.root, callback=self._checknested,
1158 realfs=False, cached=True)
1158 realfs=False, cached=True)
1159
1159
1160 def _checknested(self, path):
1160 def _checknested(self, path):
1161 """Determine if path is a legal nested repository."""
1161 """Determine if path is a legal nested repository."""
1162 if not path.startswith(self.root):
1162 if not path.startswith(self.root):
1163 return False
1163 return False
1164 subpath = path[len(self.root) + 1:]
1164 subpath = path[len(self.root) + 1:]
1165 normsubpath = util.pconvert(subpath)
1165 normsubpath = util.pconvert(subpath)
1166
1166
1167 # XXX: Checking against the current working copy is wrong in
1167 # XXX: Checking against the current working copy is wrong in
1168 # the sense that it can reject things like
1168 # the sense that it can reject things like
1169 #
1169 #
1170 # $ hg cat -r 10 sub/x.txt
1170 # $ hg cat -r 10 sub/x.txt
1171 #
1171 #
1172 # if sub/ is no longer a subrepository in the working copy
1172 # if sub/ is no longer a subrepository in the working copy
1173 # parent revision.
1173 # parent revision.
1174 #
1174 #
1175 # However, it can of course also allow things that would have
1175 # However, it can of course also allow things that would have
1176 # been rejected before, such as the above cat command if sub/
1176 # been rejected before, such as the above cat command if sub/
1177 # is a subrepository now, but was a normal directory before.
1177 # is a subrepository now, but was a normal directory before.
1178 # The old path auditor would have rejected by mistake since it
1178 # The old path auditor would have rejected by mistake since it
1179 # panics when it sees sub/.hg/.
1179 # panics when it sees sub/.hg/.
1180 #
1180 #
1181 # All in all, checking against the working copy seems sensible
1181 # All in all, checking against the working copy seems sensible
1182 # since we want to prevent access to nested repositories on
1182 # since we want to prevent access to nested repositories on
1183 # the filesystem *now*.
1183 # the filesystem *now*.
1184 ctx = self[None]
1184 ctx = self[None]
1185 parts = util.splitpath(subpath)
1185 parts = util.splitpath(subpath)
1186 while parts:
1186 while parts:
1187 prefix = '/'.join(parts)
1187 prefix = '/'.join(parts)
1188 if prefix in ctx.substate:
1188 if prefix in ctx.substate:
1189 if prefix == normsubpath:
1189 if prefix == normsubpath:
1190 return True
1190 return True
1191 else:
1191 else:
1192 sub = ctx.sub(prefix)
1192 sub = ctx.sub(prefix)
1193 return sub.checknested(subpath[len(prefix) + 1:])
1193 return sub.checknested(subpath[len(prefix) + 1:])
1194 else:
1194 else:
1195 parts.pop()
1195 parts.pop()
1196 return False
1196 return False
1197
1197
1198 def peer(self):
1198 def peer(self):
1199 return localpeer(self) # not cached to avoid reference cycle
1199 return localpeer(self) # not cached to avoid reference cycle
1200
1200
1201 def unfiltered(self):
1201 def unfiltered(self):
1202 """Return unfiltered version of the repository
1202 """Return unfiltered version of the repository
1203
1203
1204 Intended to be overwritten by filtered repo."""
1204 Intended to be overwritten by filtered repo."""
1205 return self
1205 return self
1206
1206
1207 def filtered(self, name, visibilityexceptions=None):
1207 def filtered(self, name, visibilityexceptions=None):
1208 """Return a filtered version of a repository
1208 """Return a filtered version of a repository
1209
1209
1210 The `name` parameter is the identifier of the requested view. This
1210 The `name` parameter is the identifier of the requested view. This
1211 will return a repoview object set "exactly" to the specified view.
1211 will return a repoview object set "exactly" to the specified view.
1212
1212
1213 This function does not apply recursive filtering to a repository. For
1213 This function does not apply recursive filtering to a repository. For
1214 example calling `repo.filtered("served")` will return a repoview using
1214 example calling `repo.filtered("served")` will return a repoview using
1215 the "served" view, regardless of the initial view used by `repo`.
1215 the "served" view, regardless of the initial view used by `repo`.
1216
1216
1217 In other word, there is always only one level of `repoview` "filtering".
1217 In other word, there is always only one level of `repoview` "filtering".
1218 """
1218 """
1219 cls = repoview.newtype(self.unfiltered().__class__)
1219 cls = repoview.newtype(self.unfiltered().__class__)
1220 return cls(self, name, visibilityexceptions)
1220 return cls(self, name, visibilityexceptions)
1221
1221
1222 @mixedrepostorecache(('bookmarks', 'plain'), ('bookmarks.current', 'plain'),
1222 @mixedrepostorecache(('bookmarks', 'plain'), ('bookmarks.current', 'plain'),
1223 ('00changelog.i', ''))
1223 ('00changelog.i', ''))
1224 def _bookmarks(self):
1224 def _bookmarks(self):
1225 return bookmarks.bmstore(self)
1225 return bookmarks.bmstore(self)
1226
1226
1227 def _refreshchangelog(self):
1228 """make sure the in memory changelog match the on-disk one"""
1229 if ('changelog' in vars(self) and self.currenttransaction() is None):
1230 del self.changelog
1231
1227 @property
1232 @property
1228 def _activebookmark(self):
1233 def _activebookmark(self):
1229 return self._bookmarks.active
1234 return self._bookmarks.active
1230
1235
1231 # _phasesets depend on changelog. what we need is to call
1236 # _phasesets depend on changelog. what we need is to call
1232 # _phasecache.invalidate() if '00changelog.i' was changed, but it
1237 # _phasecache.invalidate() if '00changelog.i' was changed, but it
1233 # can't be easily expressed in filecache mechanism.
1238 # can't be easily expressed in filecache mechanism.
1234 @storecache('phaseroots', '00changelog.i')
1239 @storecache('phaseroots', '00changelog.i')
1235 def _phasecache(self):
1240 def _phasecache(self):
1236 return phases.phasecache(self, self._phasedefaults)
1241 return phases.phasecache(self, self._phasedefaults)
1237
1242
1238 @storecache('obsstore')
1243 @storecache('obsstore')
1239 def obsstore(self):
1244 def obsstore(self):
1240 return obsolete.makestore(self.ui, self)
1245 return obsolete.makestore(self.ui, self)
1241
1246
1242 @storecache('00changelog.i')
1247 @storecache('00changelog.i')
1243 def changelog(self):
1248 def changelog(self):
1244 return changelog.changelog(self.svfs,
1249 return changelog.changelog(self.svfs,
1245 trypending=txnutil.mayhavepending(self.root))
1250 trypending=txnutil.mayhavepending(self.root))
1246
1251
1247 @storecache('00manifest.i')
1252 @storecache('00manifest.i')
1248 def manifestlog(self):
1253 def manifestlog(self):
1249 rootstore = manifest.manifestrevlog(self.svfs)
1254 rootstore = manifest.manifestrevlog(self.svfs)
1250 return manifest.manifestlog(self.svfs, self, rootstore,
1255 return manifest.manifestlog(self.svfs, self, rootstore,
1251 self._storenarrowmatch)
1256 self._storenarrowmatch)
1252
1257
1253 @repofilecache('dirstate')
1258 @repofilecache('dirstate')
1254 def dirstate(self):
1259 def dirstate(self):
1255 return self._makedirstate()
1260 return self._makedirstate()
1256
1261
1257 def _makedirstate(self):
1262 def _makedirstate(self):
1258 """Extension point for wrapping the dirstate per-repo."""
1263 """Extension point for wrapping the dirstate per-repo."""
1259 sparsematchfn = lambda: sparse.matcher(self)
1264 sparsematchfn = lambda: sparse.matcher(self)
1260
1265
1261 return dirstate.dirstate(self.vfs, self.ui, self.root,
1266 return dirstate.dirstate(self.vfs, self.ui, self.root,
1262 self._dirstatevalidate, sparsematchfn)
1267 self._dirstatevalidate, sparsematchfn)
1263
1268
1264 def _dirstatevalidate(self, node):
1269 def _dirstatevalidate(self, node):
1265 try:
1270 try:
1266 self.changelog.rev(node)
1271 self.changelog.rev(node)
1267 return node
1272 return node
1268 except error.LookupError:
1273 except error.LookupError:
1269 if not self._dirstatevalidatewarned:
1274 if not self._dirstatevalidatewarned:
1270 self._dirstatevalidatewarned = True
1275 self._dirstatevalidatewarned = True
1271 self.ui.warn(_("warning: ignoring unknown"
1276 self.ui.warn(_("warning: ignoring unknown"
1272 " working parent %s!\n") % short(node))
1277 " working parent %s!\n") % short(node))
1273 return nullid
1278 return nullid
1274
1279
1275 @storecache(narrowspec.FILENAME)
1280 @storecache(narrowspec.FILENAME)
1276 def narrowpats(self):
1281 def narrowpats(self):
1277 """matcher patterns for this repository's narrowspec
1282 """matcher patterns for this repository's narrowspec
1278
1283
1279 A tuple of (includes, excludes).
1284 A tuple of (includes, excludes).
1280 """
1285 """
1281 return narrowspec.load(self)
1286 return narrowspec.load(self)
1282
1287
1283 @storecache(narrowspec.FILENAME)
1288 @storecache(narrowspec.FILENAME)
1284 def _storenarrowmatch(self):
1289 def _storenarrowmatch(self):
1285 if repository.NARROW_REQUIREMENT not in self.requirements:
1290 if repository.NARROW_REQUIREMENT not in self.requirements:
1286 return matchmod.always()
1291 return matchmod.always()
1287 include, exclude = self.narrowpats
1292 include, exclude = self.narrowpats
1288 return narrowspec.match(self.root, include=include, exclude=exclude)
1293 return narrowspec.match(self.root, include=include, exclude=exclude)
1289
1294
1290 @storecache(narrowspec.FILENAME)
1295 @storecache(narrowspec.FILENAME)
1291 def _narrowmatch(self):
1296 def _narrowmatch(self):
1292 if repository.NARROW_REQUIREMENT not in self.requirements:
1297 if repository.NARROW_REQUIREMENT not in self.requirements:
1293 return matchmod.always()
1298 return matchmod.always()
1294 narrowspec.checkworkingcopynarrowspec(self)
1299 narrowspec.checkworkingcopynarrowspec(self)
1295 include, exclude = self.narrowpats
1300 include, exclude = self.narrowpats
1296 return narrowspec.match(self.root, include=include, exclude=exclude)
1301 return narrowspec.match(self.root, include=include, exclude=exclude)
1297
1302
1298 def narrowmatch(self, match=None, includeexact=False):
1303 def narrowmatch(self, match=None, includeexact=False):
1299 """matcher corresponding the the repo's narrowspec
1304 """matcher corresponding the the repo's narrowspec
1300
1305
1301 If `match` is given, then that will be intersected with the narrow
1306 If `match` is given, then that will be intersected with the narrow
1302 matcher.
1307 matcher.
1303
1308
1304 If `includeexact` is True, then any exact matches from `match` will
1309 If `includeexact` is True, then any exact matches from `match` will
1305 be included even if they're outside the narrowspec.
1310 be included even if they're outside the narrowspec.
1306 """
1311 """
1307 if match:
1312 if match:
1308 if includeexact and not self._narrowmatch.always():
1313 if includeexact and not self._narrowmatch.always():
1309 # do not exclude explicitly-specified paths so that they can
1314 # do not exclude explicitly-specified paths so that they can
1310 # be warned later on
1315 # be warned later on
1311 em = matchmod.exact(match.files())
1316 em = matchmod.exact(match.files())
1312 nm = matchmod.unionmatcher([self._narrowmatch, em])
1317 nm = matchmod.unionmatcher([self._narrowmatch, em])
1313 return matchmod.intersectmatchers(match, nm)
1318 return matchmod.intersectmatchers(match, nm)
1314 return matchmod.intersectmatchers(match, self._narrowmatch)
1319 return matchmod.intersectmatchers(match, self._narrowmatch)
1315 return self._narrowmatch
1320 return self._narrowmatch
1316
1321
1317 def setnarrowpats(self, newincludes, newexcludes):
1322 def setnarrowpats(self, newincludes, newexcludes):
1318 narrowspec.save(self, newincludes, newexcludes)
1323 narrowspec.save(self, newincludes, newexcludes)
1319 self.invalidate(clearfilecache=True)
1324 self.invalidate(clearfilecache=True)
1320
1325
1321 def __getitem__(self, changeid):
1326 def __getitem__(self, changeid):
1322 if changeid is None:
1327 if changeid is None:
1323 return context.workingctx(self)
1328 return context.workingctx(self)
1324 if isinstance(changeid, context.basectx):
1329 if isinstance(changeid, context.basectx):
1325 return changeid
1330 return changeid
1326 if isinstance(changeid, slice):
1331 if isinstance(changeid, slice):
1327 # wdirrev isn't contiguous so the slice shouldn't include it
1332 # wdirrev isn't contiguous so the slice shouldn't include it
1328 return [self[i]
1333 return [self[i]
1329 for i in pycompat.xrange(*changeid.indices(len(self)))
1334 for i in pycompat.xrange(*changeid.indices(len(self)))
1330 if i not in self.changelog.filteredrevs]
1335 if i not in self.changelog.filteredrevs]
1331 try:
1336 try:
1332 if isinstance(changeid, int):
1337 if isinstance(changeid, int):
1333 node = self.changelog.node(changeid)
1338 node = self.changelog.node(changeid)
1334 rev = changeid
1339 rev = changeid
1335 elif changeid == 'null':
1340 elif changeid == 'null':
1336 node = nullid
1341 node = nullid
1337 rev = nullrev
1342 rev = nullrev
1338 elif changeid == 'tip':
1343 elif changeid == 'tip':
1339 node = self.changelog.tip()
1344 node = self.changelog.tip()
1340 rev = self.changelog.rev(node)
1345 rev = self.changelog.rev(node)
1341 elif changeid == '.':
1346 elif changeid == '.':
1342 # this is a hack to delay/avoid loading obsmarkers
1347 # this is a hack to delay/avoid loading obsmarkers
1343 # when we know that '.' won't be hidden
1348 # when we know that '.' won't be hidden
1344 node = self.dirstate.p1()
1349 node = self.dirstate.p1()
1345 rev = self.unfiltered().changelog.rev(node)
1350 rev = self.unfiltered().changelog.rev(node)
1346 elif len(changeid) == 20:
1351 elif len(changeid) == 20:
1347 try:
1352 try:
1348 node = changeid
1353 node = changeid
1349 rev = self.changelog.rev(changeid)
1354 rev = self.changelog.rev(changeid)
1350 except error.FilteredLookupError:
1355 except error.FilteredLookupError:
1351 changeid = hex(changeid) # for the error message
1356 changeid = hex(changeid) # for the error message
1352 raise
1357 raise
1353 except LookupError:
1358 except LookupError:
1354 # check if it might have come from damaged dirstate
1359 # check if it might have come from damaged dirstate
1355 #
1360 #
1356 # XXX we could avoid the unfiltered if we had a recognizable
1361 # XXX we could avoid the unfiltered if we had a recognizable
1357 # exception for filtered changeset access
1362 # exception for filtered changeset access
1358 if (self.local()
1363 if (self.local()
1359 and changeid in self.unfiltered().dirstate.parents()):
1364 and changeid in self.unfiltered().dirstate.parents()):
1360 msg = _("working directory has unknown parent '%s'!")
1365 msg = _("working directory has unknown parent '%s'!")
1361 raise error.Abort(msg % short(changeid))
1366 raise error.Abort(msg % short(changeid))
1362 changeid = hex(changeid) # for the error message
1367 changeid = hex(changeid) # for the error message
1363 raise
1368 raise
1364
1369
1365 elif len(changeid) == 40:
1370 elif len(changeid) == 40:
1366 node = bin(changeid)
1371 node = bin(changeid)
1367 rev = self.changelog.rev(node)
1372 rev = self.changelog.rev(node)
1368 else:
1373 else:
1369 raise error.ProgrammingError(
1374 raise error.ProgrammingError(
1370 "unsupported changeid '%s' of type %s" %
1375 "unsupported changeid '%s' of type %s" %
1371 (changeid, type(changeid)))
1376 (changeid, type(changeid)))
1372
1377
1373 return context.changectx(self, rev, node)
1378 return context.changectx(self, rev, node)
1374
1379
1375 except (error.FilteredIndexError, error.FilteredLookupError):
1380 except (error.FilteredIndexError, error.FilteredLookupError):
1376 raise error.FilteredRepoLookupError(_("filtered revision '%s'")
1381 raise error.FilteredRepoLookupError(_("filtered revision '%s'")
1377 % pycompat.bytestr(changeid))
1382 % pycompat.bytestr(changeid))
1378 except (IndexError, LookupError):
1383 except (IndexError, LookupError):
1379 raise error.RepoLookupError(
1384 raise error.RepoLookupError(
1380 _("unknown revision '%s'") % pycompat.bytestr(changeid))
1385 _("unknown revision '%s'") % pycompat.bytestr(changeid))
1381 except error.WdirUnsupported:
1386 except error.WdirUnsupported:
1382 return context.workingctx(self)
1387 return context.workingctx(self)
1383
1388
1384 def __contains__(self, changeid):
1389 def __contains__(self, changeid):
1385 """True if the given changeid exists
1390 """True if the given changeid exists
1386
1391
1387 error.AmbiguousPrefixLookupError is raised if an ambiguous node
1392 error.AmbiguousPrefixLookupError is raised if an ambiguous node
1388 specified.
1393 specified.
1389 """
1394 """
1390 try:
1395 try:
1391 self[changeid]
1396 self[changeid]
1392 return True
1397 return True
1393 except error.RepoLookupError:
1398 except error.RepoLookupError:
1394 return False
1399 return False
1395
1400
1396 def __nonzero__(self):
1401 def __nonzero__(self):
1397 return True
1402 return True
1398
1403
1399 __bool__ = __nonzero__
1404 __bool__ = __nonzero__
1400
1405
1401 def __len__(self):
1406 def __len__(self):
1402 # no need to pay the cost of repoview.changelog
1407 # no need to pay the cost of repoview.changelog
1403 unfi = self.unfiltered()
1408 unfi = self.unfiltered()
1404 return len(unfi.changelog)
1409 return len(unfi.changelog)
1405
1410
1406 def __iter__(self):
1411 def __iter__(self):
1407 return iter(self.changelog)
1412 return iter(self.changelog)
1408
1413
1409 def revs(self, expr, *args):
1414 def revs(self, expr, *args):
1410 '''Find revisions matching a revset.
1415 '''Find revisions matching a revset.
1411
1416
1412 The revset is specified as a string ``expr`` that may contain
1417 The revset is specified as a string ``expr`` that may contain
1413 %-formatting to escape certain types. See ``revsetlang.formatspec``.
1418 %-formatting to escape certain types. See ``revsetlang.formatspec``.
1414
1419
1415 Revset aliases from the configuration are not expanded. To expand
1420 Revset aliases from the configuration are not expanded. To expand
1416 user aliases, consider calling ``scmutil.revrange()`` or
1421 user aliases, consider calling ``scmutil.revrange()`` or
1417 ``repo.anyrevs([expr], user=True)``.
1422 ``repo.anyrevs([expr], user=True)``.
1418
1423
1419 Returns a revset.abstractsmartset, which is a list-like interface
1424 Returns a revset.abstractsmartset, which is a list-like interface
1420 that contains integer revisions.
1425 that contains integer revisions.
1421 '''
1426 '''
1422 tree = revsetlang.spectree(expr, *args)
1427 tree = revsetlang.spectree(expr, *args)
1423 return revset.makematcher(tree)(self)
1428 return revset.makematcher(tree)(self)
1424
1429
1425 def set(self, expr, *args):
1430 def set(self, expr, *args):
1426 '''Find revisions matching a revset and emit changectx instances.
1431 '''Find revisions matching a revset and emit changectx instances.
1427
1432
1428 This is a convenience wrapper around ``revs()`` that iterates the
1433 This is a convenience wrapper around ``revs()`` that iterates the
1429 result and is a generator of changectx instances.
1434 result and is a generator of changectx instances.
1430
1435
1431 Revset aliases from the configuration are not expanded. To expand
1436 Revset aliases from the configuration are not expanded. To expand
1432 user aliases, consider calling ``scmutil.revrange()``.
1437 user aliases, consider calling ``scmutil.revrange()``.
1433 '''
1438 '''
1434 for r in self.revs(expr, *args):
1439 for r in self.revs(expr, *args):
1435 yield self[r]
1440 yield self[r]
1436
1441
1437 def anyrevs(self, specs, user=False, localalias=None):
1442 def anyrevs(self, specs, user=False, localalias=None):
1438 '''Find revisions matching one of the given revsets.
1443 '''Find revisions matching one of the given revsets.
1439
1444
1440 Revset aliases from the configuration are not expanded by default. To
1445 Revset aliases from the configuration are not expanded by default. To
1441 expand user aliases, specify ``user=True``. To provide some local
1446 expand user aliases, specify ``user=True``. To provide some local
1442 definitions overriding user aliases, set ``localalias`` to
1447 definitions overriding user aliases, set ``localalias`` to
1443 ``{name: definitionstring}``.
1448 ``{name: definitionstring}``.
1444 '''
1449 '''
1445 if user:
1450 if user:
1446 m = revset.matchany(self.ui, specs,
1451 m = revset.matchany(self.ui, specs,
1447 lookup=revset.lookupfn(self),
1452 lookup=revset.lookupfn(self),
1448 localalias=localalias)
1453 localalias=localalias)
1449 else:
1454 else:
1450 m = revset.matchany(None, specs, localalias=localalias)
1455 m = revset.matchany(None, specs, localalias=localalias)
1451 return m(self)
1456 return m(self)
1452
1457
1453 def url(self):
1458 def url(self):
1454 return 'file:' + self.root
1459 return 'file:' + self.root
1455
1460
1456 def hook(self, name, throw=False, **args):
1461 def hook(self, name, throw=False, **args):
1457 """Call a hook, passing this repo instance.
1462 """Call a hook, passing this repo instance.
1458
1463
1459 This a convenience method to aid invoking hooks. Extensions likely
1464 This a convenience method to aid invoking hooks. Extensions likely
1460 won't call this unless they have registered a custom hook or are
1465 won't call this unless they have registered a custom hook or are
1461 replacing code that is expected to call a hook.
1466 replacing code that is expected to call a hook.
1462 """
1467 """
1463 return hook.hook(self.ui, self, name, throw, **args)
1468 return hook.hook(self.ui, self, name, throw, **args)
1464
1469
1465 @filteredpropertycache
1470 @filteredpropertycache
1466 def _tagscache(self):
1471 def _tagscache(self):
1467 '''Returns a tagscache object that contains various tags related
1472 '''Returns a tagscache object that contains various tags related
1468 caches.'''
1473 caches.'''
1469
1474
1470 # This simplifies its cache management by having one decorated
1475 # This simplifies its cache management by having one decorated
1471 # function (this one) and the rest simply fetch things from it.
1476 # function (this one) and the rest simply fetch things from it.
1472 class tagscache(object):
1477 class tagscache(object):
1473 def __init__(self):
1478 def __init__(self):
1474 # These two define the set of tags for this repository. tags
1479 # These two define the set of tags for this repository. tags
1475 # maps tag name to node; tagtypes maps tag name to 'global' or
1480 # maps tag name to node; tagtypes maps tag name to 'global' or
1476 # 'local'. (Global tags are defined by .hgtags across all
1481 # 'local'. (Global tags are defined by .hgtags across all
1477 # heads, and local tags are defined in .hg/localtags.)
1482 # heads, and local tags are defined in .hg/localtags.)
1478 # They constitute the in-memory cache of tags.
1483 # They constitute the in-memory cache of tags.
1479 self.tags = self.tagtypes = None
1484 self.tags = self.tagtypes = None
1480
1485
1481 self.nodetagscache = self.tagslist = None
1486 self.nodetagscache = self.tagslist = None
1482
1487
1483 cache = tagscache()
1488 cache = tagscache()
1484 cache.tags, cache.tagtypes = self._findtags()
1489 cache.tags, cache.tagtypes = self._findtags()
1485
1490
1486 return cache
1491 return cache
1487
1492
1488 def tags(self):
1493 def tags(self):
1489 '''return a mapping of tag to node'''
1494 '''return a mapping of tag to node'''
1490 t = {}
1495 t = {}
1491 if self.changelog.filteredrevs:
1496 if self.changelog.filteredrevs:
1492 tags, tt = self._findtags()
1497 tags, tt = self._findtags()
1493 else:
1498 else:
1494 tags = self._tagscache.tags
1499 tags = self._tagscache.tags
1495 rev = self.changelog.rev
1500 rev = self.changelog.rev
1496 for k, v in tags.iteritems():
1501 for k, v in tags.iteritems():
1497 try:
1502 try:
1498 # ignore tags to unknown nodes
1503 # ignore tags to unknown nodes
1499 rev(v)
1504 rev(v)
1500 t[k] = v
1505 t[k] = v
1501 except (error.LookupError, ValueError):
1506 except (error.LookupError, ValueError):
1502 pass
1507 pass
1503 return t
1508 return t
1504
1509
1505 def _findtags(self):
1510 def _findtags(self):
1506 '''Do the hard work of finding tags. Return a pair of dicts
1511 '''Do the hard work of finding tags. Return a pair of dicts
1507 (tags, tagtypes) where tags maps tag name to node, and tagtypes
1512 (tags, tagtypes) where tags maps tag name to node, and tagtypes
1508 maps tag name to a string like \'global\' or \'local\'.
1513 maps tag name to a string like \'global\' or \'local\'.
1509 Subclasses or extensions are free to add their own tags, but
1514 Subclasses or extensions are free to add their own tags, but
1510 should be aware that the returned dicts will be retained for the
1515 should be aware that the returned dicts will be retained for the
1511 duration of the localrepo object.'''
1516 duration of the localrepo object.'''
1512
1517
1513 # XXX what tagtype should subclasses/extensions use? Currently
1518 # XXX what tagtype should subclasses/extensions use? Currently
1514 # mq and bookmarks add tags, but do not set the tagtype at all.
1519 # mq and bookmarks add tags, but do not set the tagtype at all.
1515 # Should each extension invent its own tag type? Should there
1520 # Should each extension invent its own tag type? Should there
1516 # be one tagtype for all such "virtual" tags? Or is the status
1521 # be one tagtype for all such "virtual" tags? Or is the status
1517 # quo fine?
1522 # quo fine?
1518
1523
1519
1524
1520 # map tag name to (node, hist)
1525 # map tag name to (node, hist)
1521 alltags = tagsmod.findglobaltags(self.ui, self)
1526 alltags = tagsmod.findglobaltags(self.ui, self)
1522 # map tag name to tag type
1527 # map tag name to tag type
1523 tagtypes = dict((tag, 'global') for tag in alltags)
1528 tagtypes = dict((tag, 'global') for tag in alltags)
1524
1529
1525 tagsmod.readlocaltags(self.ui, self, alltags, tagtypes)
1530 tagsmod.readlocaltags(self.ui, self, alltags, tagtypes)
1526
1531
1527 # Build the return dicts. Have to re-encode tag names because
1532 # Build the return dicts. Have to re-encode tag names because
1528 # the tags module always uses UTF-8 (in order not to lose info
1533 # the tags module always uses UTF-8 (in order not to lose info
1529 # writing to the cache), but the rest of Mercurial wants them in
1534 # writing to the cache), but the rest of Mercurial wants them in
1530 # local encoding.
1535 # local encoding.
1531 tags = {}
1536 tags = {}
1532 for (name, (node, hist)) in alltags.iteritems():
1537 for (name, (node, hist)) in alltags.iteritems():
1533 if node != nullid:
1538 if node != nullid:
1534 tags[encoding.tolocal(name)] = node
1539 tags[encoding.tolocal(name)] = node
1535 tags['tip'] = self.changelog.tip()
1540 tags['tip'] = self.changelog.tip()
1536 tagtypes = dict([(encoding.tolocal(name), value)
1541 tagtypes = dict([(encoding.tolocal(name), value)
1537 for (name, value) in tagtypes.iteritems()])
1542 for (name, value) in tagtypes.iteritems()])
1538 return (tags, tagtypes)
1543 return (tags, tagtypes)
1539
1544
1540 def tagtype(self, tagname):
1545 def tagtype(self, tagname):
1541 '''
1546 '''
1542 return the type of the given tag. result can be:
1547 return the type of the given tag. result can be:
1543
1548
1544 'local' : a local tag
1549 'local' : a local tag
1545 'global' : a global tag
1550 'global' : a global tag
1546 None : tag does not exist
1551 None : tag does not exist
1547 '''
1552 '''
1548
1553
1549 return self._tagscache.tagtypes.get(tagname)
1554 return self._tagscache.tagtypes.get(tagname)
1550
1555
1551 def tagslist(self):
1556 def tagslist(self):
1552 '''return a list of tags ordered by revision'''
1557 '''return a list of tags ordered by revision'''
1553 if not self._tagscache.tagslist:
1558 if not self._tagscache.tagslist:
1554 l = []
1559 l = []
1555 for t, n in self.tags().iteritems():
1560 for t, n in self.tags().iteritems():
1556 l.append((self.changelog.rev(n), t, n))
1561 l.append((self.changelog.rev(n), t, n))
1557 self._tagscache.tagslist = [(t, n) for r, t, n in sorted(l)]
1562 self._tagscache.tagslist = [(t, n) for r, t, n in sorted(l)]
1558
1563
1559 return self._tagscache.tagslist
1564 return self._tagscache.tagslist
1560
1565
1561 def nodetags(self, node):
1566 def nodetags(self, node):
1562 '''return the tags associated with a node'''
1567 '''return the tags associated with a node'''
1563 if not self._tagscache.nodetagscache:
1568 if not self._tagscache.nodetagscache:
1564 nodetagscache = {}
1569 nodetagscache = {}
1565 for t, n in self._tagscache.tags.iteritems():
1570 for t, n in self._tagscache.tags.iteritems():
1566 nodetagscache.setdefault(n, []).append(t)
1571 nodetagscache.setdefault(n, []).append(t)
1567 for tags in nodetagscache.itervalues():
1572 for tags in nodetagscache.itervalues():
1568 tags.sort()
1573 tags.sort()
1569 self._tagscache.nodetagscache = nodetagscache
1574 self._tagscache.nodetagscache = nodetagscache
1570 return self._tagscache.nodetagscache.get(node, [])
1575 return self._tagscache.nodetagscache.get(node, [])
1571
1576
1572 def nodebookmarks(self, node):
1577 def nodebookmarks(self, node):
1573 """return the list of bookmarks pointing to the specified node"""
1578 """return the list of bookmarks pointing to the specified node"""
1574 return self._bookmarks.names(node)
1579 return self._bookmarks.names(node)
1575
1580
1576 def branchmap(self):
1581 def branchmap(self):
1577 '''returns a dictionary {branch: [branchheads]} with branchheads
1582 '''returns a dictionary {branch: [branchheads]} with branchheads
1578 ordered by increasing revision number'''
1583 ordered by increasing revision number'''
1579 return self._branchcaches[self]
1584 return self._branchcaches[self]
1580
1585
1581 @unfilteredmethod
1586 @unfilteredmethod
1582 def revbranchcache(self):
1587 def revbranchcache(self):
1583 if not self._revbranchcache:
1588 if not self._revbranchcache:
1584 self._revbranchcache = branchmap.revbranchcache(self.unfiltered())
1589 self._revbranchcache = branchmap.revbranchcache(self.unfiltered())
1585 return self._revbranchcache
1590 return self._revbranchcache
1586
1591
1587 def branchtip(self, branch, ignoremissing=False):
1592 def branchtip(self, branch, ignoremissing=False):
1588 '''return the tip node for a given branch
1593 '''return the tip node for a given branch
1589
1594
1590 If ignoremissing is True, then this method will not raise an error.
1595 If ignoremissing is True, then this method will not raise an error.
1591 This is helpful for callers that only expect None for a missing branch
1596 This is helpful for callers that only expect None for a missing branch
1592 (e.g. namespace).
1597 (e.g. namespace).
1593
1598
1594 '''
1599 '''
1595 try:
1600 try:
1596 return self.branchmap().branchtip(branch)
1601 return self.branchmap().branchtip(branch)
1597 except KeyError:
1602 except KeyError:
1598 if not ignoremissing:
1603 if not ignoremissing:
1599 raise error.RepoLookupError(_("unknown branch '%s'") % branch)
1604 raise error.RepoLookupError(_("unknown branch '%s'") % branch)
1600 else:
1605 else:
1601 pass
1606 pass
1602
1607
1603 def lookup(self, key):
1608 def lookup(self, key):
1604 node = scmutil.revsymbol(self, key).node()
1609 node = scmutil.revsymbol(self, key).node()
1605 if node is None:
1610 if node is None:
1606 raise error.RepoLookupError(_("unknown revision '%s'") % key)
1611 raise error.RepoLookupError(_("unknown revision '%s'") % key)
1607 return node
1612 return node
1608
1613
1609 def lookupbranch(self, key):
1614 def lookupbranch(self, key):
1610 if self.branchmap().hasbranch(key):
1615 if self.branchmap().hasbranch(key):
1611 return key
1616 return key
1612
1617
1613 return scmutil.revsymbol(self, key).branch()
1618 return scmutil.revsymbol(self, key).branch()
1614
1619
1615 def known(self, nodes):
1620 def known(self, nodes):
1616 cl = self.changelog
1621 cl = self.changelog
1617 nm = cl.nodemap
1622 nm = cl.nodemap
1618 filtered = cl.filteredrevs
1623 filtered = cl.filteredrevs
1619 result = []
1624 result = []
1620 for n in nodes:
1625 for n in nodes:
1621 r = nm.get(n)
1626 r = nm.get(n)
1622 resp = not (r is None or r in filtered)
1627 resp = not (r is None or r in filtered)
1623 result.append(resp)
1628 result.append(resp)
1624 return result
1629 return result
1625
1630
1626 def local(self):
1631 def local(self):
1627 return self
1632 return self
1628
1633
1629 def publishing(self):
1634 def publishing(self):
1630 # it's safe (and desirable) to trust the publish flag unconditionally
1635 # it's safe (and desirable) to trust the publish flag unconditionally
1631 # so that we don't finalize changes shared between users via ssh or nfs
1636 # so that we don't finalize changes shared between users via ssh or nfs
1632 return self.ui.configbool('phases', 'publish', untrusted=True)
1637 return self.ui.configbool('phases', 'publish', untrusted=True)
1633
1638
1634 def cancopy(self):
1639 def cancopy(self):
1635 # so statichttprepo's override of local() works
1640 # so statichttprepo's override of local() works
1636 if not self.local():
1641 if not self.local():
1637 return False
1642 return False
1638 if not self.publishing():
1643 if not self.publishing():
1639 return True
1644 return True
1640 # if publishing we can't copy if there is filtered content
1645 # if publishing we can't copy if there is filtered content
1641 return not self.filtered('visible').changelog.filteredrevs
1646 return not self.filtered('visible').changelog.filteredrevs
1642
1647
1643 def shared(self):
1648 def shared(self):
1644 '''the type of shared repository (None if not shared)'''
1649 '''the type of shared repository (None if not shared)'''
1645 if self.sharedpath != self.path:
1650 if self.sharedpath != self.path:
1646 return 'store'
1651 return 'store'
1647 return None
1652 return None
1648
1653
1649 def wjoin(self, f, *insidef):
1654 def wjoin(self, f, *insidef):
1650 return self.vfs.reljoin(self.root, f, *insidef)
1655 return self.vfs.reljoin(self.root, f, *insidef)
1651
1656
1652 def setparents(self, p1, p2=nullid):
1657 def setparents(self, p1, p2=nullid):
1653 with self.dirstate.parentchange():
1658 with self.dirstate.parentchange():
1654 copies = self.dirstate.setparents(p1, p2)
1659 copies = self.dirstate.setparents(p1, p2)
1655 pctx = self[p1]
1660 pctx = self[p1]
1656 if copies:
1661 if copies:
1657 # Adjust copy records, the dirstate cannot do it, it
1662 # Adjust copy records, the dirstate cannot do it, it
1658 # requires access to parents manifests. Preserve them
1663 # requires access to parents manifests. Preserve them
1659 # only for entries added to first parent.
1664 # only for entries added to first parent.
1660 for f in copies:
1665 for f in copies:
1661 if f not in pctx and copies[f] in pctx:
1666 if f not in pctx and copies[f] in pctx:
1662 self.dirstate.copy(copies[f], f)
1667 self.dirstate.copy(copies[f], f)
1663 if p2 == nullid:
1668 if p2 == nullid:
1664 for f, s in sorted(self.dirstate.copies().items()):
1669 for f, s in sorted(self.dirstate.copies().items()):
1665 if f not in pctx and s not in pctx:
1670 if f not in pctx and s not in pctx:
1666 self.dirstate.copy(None, f)
1671 self.dirstate.copy(None, f)
1667
1672
1668 def filectx(self, path, changeid=None, fileid=None, changectx=None):
1673 def filectx(self, path, changeid=None, fileid=None, changectx=None):
1669 """changeid must be a changeset revision, if specified.
1674 """changeid must be a changeset revision, if specified.
1670 fileid can be a file revision or node."""
1675 fileid can be a file revision or node."""
1671 return context.filectx(self, path, changeid, fileid,
1676 return context.filectx(self, path, changeid, fileid,
1672 changectx=changectx)
1677 changectx=changectx)
1673
1678
1674 def getcwd(self):
1679 def getcwd(self):
1675 return self.dirstate.getcwd()
1680 return self.dirstate.getcwd()
1676
1681
1677 def pathto(self, f, cwd=None):
1682 def pathto(self, f, cwd=None):
1678 return self.dirstate.pathto(f, cwd)
1683 return self.dirstate.pathto(f, cwd)
1679
1684
1680 def _loadfilter(self, filter):
1685 def _loadfilter(self, filter):
1681 if filter not in self._filterpats:
1686 if filter not in self._filterpats:
1682 l = []
1687 l = []
1683 for pat, cmd in self.ui.configitems(filter):
1688 for pat, cmd in self.ui.configitems(filter):
1684 if cmd == '!':
1689 if cmd == '!':
1685 continue
1690 continue
1686 mf = matchmod.match(self.root, '', [pat])
1691 mf = matchmod.match(self.root, '', [pat])
1687 fn = None
1692 fn = None
1688 params = cmd
1693 params = cmd
1689 for name, filterfn in self._datafilters.iteritems():
1694 for name, filterfn in self._datafilters.iteritems():
1690 if cmd.startswith(name):
1695 if cmd.startswith(name):
1691 fn = filterfn
1696 fn = filterfn
1692 params = cmd[len(name):].lstrip()
1697 params = cmd[len(name):].lstrip()
1693 break
1698 break
1694 if not fn:
1699 if not fn:
1695 fn = lambda s, c, **kwargs: procutil.filter(s, c)
1700 fn = lambda s, c, **kwargs: procutil.filter(s, c)
1696 # Wrap old filters not supporting keyword arguments
1701 # Wrap old filters not supporting keyword arguments
1697 if not pycompat.getargspec(fn)[2]:
1702 if not pycompat.getargspec(fn)[2]:
1698 oldfn = fn
1703 oldfn = fn
1699 fn = lambda s, c, **kwargs: oldfn(s, c)
1704 fn = lambda s, c, **kwargs: oldfn(s, c)
1700 l.append((mf, fn, params))
1705 l.append((mf, fn, params))
1701 self._filterpats[filter] = l
1706 self._filterpats[filter] = l
1702 return self._filterpats[filter]
1707 return self._filterpats[filter]
1703
1708
1704 def _filter(self, filterpats, filename, data):
1709 def _filter(self, filterpats, filename, data):
1705 for mf, fn, cmd in filterpats:
1710 for mf, fn, cmd in filterpats:
1706 if mf(filename):
1711 if mf(filename):
1707 self.ui.debug("filtering %s through %s\n" % (filename, cmd))
1712 self.ui.debug("filtering %s through %s\n" % (filename, cmd))
1708 data = fn(data, cmd, ui=self.ui, repo=self, filename=filename)
1713 data = fn(data, cmd, ui=self.ui, repo=self, filename=filename)
1709 break
1714 break
1710
1715
1711 return data
1716 return data
1712
1717
1713 @unfilteredpropertycache
1718 @unfilteredpropertycache
1714 def _encodefilterpats(self):
1719 def _encodefilterpats(self):
1715 return self._loadfilter('encode')
1720 return self._loadfilter('encode')
1716
1721
1717 @unfilteredpropertycache
1722 @unfilteredpropertycache
1718 def _decodefilterpats(self):
1723 def _decodefilterpats(self):
1719 return self._loadfilter('decode')
1724 return self._loadfilter('decode')
1720
1725
1721 def adddatafilter(self, name, filter):
1726 def adddatafilter(self, name, filter):
1722 self._datafilters[name] = filter
1727 self._datafilters[name] = filter
1723
1728
1724 def wread(self, filename):
1729 def wread(self, filename):
1725 if self.wvfs.islink(filename):
1730 if self.wvfs.islink(filename):
1726 data = self.wvfs.readlink(filename)
1731 data = self.wvfs.readlink(filename)
1727 else:
1732 else:
1728 data = self.wvfs.read(filename)
1733 data = self.wvfs.read(filename)
1729 return self._filter(self._encodefilterpats, filename, data)
1734 return self._filter(self._encodefilterpats, filename, data)
1730
1735
1731 def wwrite(self, filename, data, flags, backgroundclose=False, **kwargs):
1736 def wwrite(self, filename, data, flags, backgroundclose=False, **kwargs):
1732 """write ``data`` into ``filename`` in the working directory
1737 """write ``data`` into ``filename`` in the working directory
1733
1738
1734 This returns length of written (maybe decoded) data.
1739 This returns length of written (maybe decoded) data.
1735 """
1740 """
1736 data = self._filter(self._decodefilterpats, filename, data)
1741 data = self._filter(self._decodefilterpats, filename, data)
1737 if 'l' in flags:
1742 if 'l' in flags:
1738 self.wvfs.symlink(data, filename)
1743 self.wvfs.symlink(data, filename)
1739 else:
1744 else:
1740 self.wvfs.write(filename, data, backgroundclose=backgroundclose,
1745 self.wvfs.write(filename, data, backgroundclose=backgroundclose,
1741 **kwargs)
1746 **kwargs)
1742 if 'x' in flags:
1747 if 'x' in flags:
1743 self.wvfs.setflags(filename, False, True)
1748 self.wvfs.setflags(filename, False, True)
1744 else:
1749 else:
1745 self.wvfs.setflags(filename, False, False)
1750 self.wvfs.setflags(filename, False, False)
1746 return len(data)
1751 return len(data)
1747
1752
1748 def wwritedata(self, filename, data):
1753 def wwritedata(self, filename, data):
1749 return self._filter(self._decodefilterpats, filename, data)
1754 return self._filter(self._decodefilterpats, filename, data)
1750
1755
1751 def currenttransaction(self):
1756 def currenttransaction(self):
1752 """return the current transaction or None if non exists"""
1757 """return the current transaction or None if non exists"""
1753 if self._transref:
1758 if self._transref:
1754 tr = self._transref()
1759 tr = self._transref()
1755 else:
1760 else:
1756 tr = None
1761 tr = None
1757
1762
1758 if tr and tr.running():
1763 if tr and tr.running():
1759 return tr
1764 return tr
1760 return None
1765 return None
1761
1766
1762 def transaction(self, desc, report=None):
1767 def transaction(self, desc, report=None):
1763 if (self.ui.configbool('devel', 'all-warnings')
1768 if (self.ui.configbool('devel', 'all-warnings')
1764 or self.ui.configbool('devel', 'check-locks')):
1769 or self.ui.configbool('devel', 'check-locks')):
1765 if self._currentlock(self._lockref) is None:
1770 if self._currentlock(self._lockref) is None:
1766 raise error.ProgrammingError('transaction requires locking')
1771 raise error.ProgrammingError('transaction requires locking')
1767 tr = self.currenttransaction()
1772 tr = self.currenttransaction()
1768 if tr is not None:
1773 if tr is not None:
1769 return tr.nest(name=desc)
1774 return tr.nest(name=desc)
1770
1775
1771 # abort here if the journal already exists
1776 # abort here if the journal already exists
1772 if self.svfs.exists("journal"):
1777 if self.svfs.exists("journal"):
1773 raise error.RepoError(
1778 raise error.RepoError(
1774 _("abandoned transaction found"),
1779 _("abandoned transaction found"),
1775 hint=_("run 'hg recover' to clean up transaction"))
1780 hint=_("run 'hg recover' to clean up transaction"))
1776
1781
1777 idbase = "%.40f#%f" % (random.random(), time.time())
1782 idbase = "%.40f#%f" % (random.random(), time.time())
1778 ha = hex(hashlib.sha1(idbase).digest())
1783 ha = hex(hashlib.sha1(idbase).digest())
1779 txnid = 'TXN:' + ha
1784 txnid = 'TXN:' + ha
1780 self.hook('pretxnopen', throw=True, txnname=desc, txnid=txnid)
1785 self.hook('pretxnopen', throw=True, txnname=desc, txnid=txnid)
1781
1786
1782 self._writejournal(desc)
1787 self._writejournal(desc)
1783 renames = [(vfs, x, undoname(x)) for vfs, x in self._journalfiles()]
1788 renames = [(vfs, x, undoname(x)) for vfs, x in self._journalfiles()]
1784 if report:
1789 if report:
1785 rp = report
1790 rp = report
1786 else:
1791 else:
1787 rp = self.ui.warn
1792 rp = self.ui.warn
1788 vfsmap = {'plain': self.vfs, 'store': self.svfs} # root of .hg/
1793 vfsmap = {'plain': self.vfs, 'store': self.svfs} # root of .hg/
1789 # we must avoid cyclic reference between repo and transaction.
1794 # we must avoid cyclic reference between repo and transaction.
1790 reporef = weakref.ref(self)
1795 reporef = weakref.ref(self)
1791 # Code to track tag movement
1796 # Code to track tag movement
1792 #
1797 #
1793 # Since tags are all handled as file content, it is actually quite hard
1798 # Since tags are all handled as file content, it is actually quite hard
1794 # to track these movement from a code perspective. So we fallback to a
1799 # to track these movement from a code perspective. So we fallback to a
1795 # tracking at the repository level. One could envision to track changes
1800 # tracking at the repository level. One could envision to track changes
1796 # to the '.hgtags' file through changegroup apply but that fails to
1801 # to the '.hgtags' file through changegroup apply but that fails to
1797 # cope with case where transaction expose new heads without changegroup
1802 # cope with case where transaction expose new heads without changegroup
1798 # being involved (eg: phase movement).
1803 # being involved (eg: phase movement).
1799 #
1804 #
1800 # For now, We gate the feature behind a flag since this likely comes
1805 # For now, We gate the feature behind a flag since this likely comes
1801 # with performance impacts. The current code run more often than needed
1806 # with performance impacts. The current code run more often than needed
1802 # and do not use caches as much as it could. The current focus is on
1807 # and do not use caches as much as it could. The current focus is on
1803 # the behavior of the feature so we disable it by default. The flag
1808 # the behavior of the feature so we disable it by default. The flag
1804 # will be removed when we are happy with the performance impact.
1809 # will be removed when we are happy with the performance impact.
1805 #
1810 #
1806 # Once this feature is no longer experimental move the following
1811 # Once this feature is no longer experimental move the following
1807 # documentation to the appropriate help section:
1812 # documentation to the appropriate help section:
1808 #
1813 #
1809 # The ``HG_TAG_MOVED`` variable will be set if the transaction touched
1814 # The ``HG_TAG_MOVED`` variable will be set if the transaction touched
1810 # tags (new or changed or deleted tags). In addition the details of
1815 # tags (new or changed or deleted tags). In addition the details of
1811 # these changes are made available in a file at:
1816 # these changes are made available in a file at:
1812 # ``REPOROOT/.hg/changes/tags.changes``.
1817 # ``REPOROOT/.hg/changes/tags.changes``.
1813 # Make sure you check for HG_TAG_MOVED before reading that file as it
1818 # Make sure you check for HG_TAG_MOVED before reading that file as it
1814 # might exist from a previous transaction even if no tag were touched
1819 # might exist from a previous transaction even if no tag were touched
1815 # in this one. Changes are recorded in a line base format::
1820 # in this one. Changes are recorded in a line base format::
1816 #
1821 #
1817 # <action> <hex-node> <tag-name>\n
1822 # <action> <hex-node> <tag-name>\n
1818 #
1823 #
1819 # Actions are defined as follow:
1824 # Actions are defined as follow:
1820 # "-R": tag is removed,
1825 # "-R": tag is removed,
1821 # "+A": tag is added,
1826 # "+A": tag is added,
1822 # "-M": tag is moved (old value),
1827 # "-M": tag is moved (old value),
1823 # "+M": tag is moved (new value),
1828 # "+M": tag is moved (new value),
1824 tracktags = lambda x: None
1829 tracktags = lambda x: None
1825 # experimental config: experimental.hook-track-tags
1830 # experimental config: experimental.hook-track-tags
1826 shouldtracktags = self.ui.configbool('experimental', 'hook-track-tags')
1831 shouldtracktags = self.ui.configbool('experimental', 'hook-track-tags')
1827 if desc != 'strip' and shouldtracktags:
1832 if desc != 'strip' and shouldtracktags:
1828 oldheads = self.changelog.headrevs()
1833 oldheads = self.changelog.headrevs()
1829 def tracktags(tr2):
1834 def tracktags(tr2):
1830 repo = reporef()
1835 repo = reporef()
1831 oldfnodes = tagsmod.fnoderevs(repo.ui, repo, oldheads)
1836 oldfnodes = tagsmod.fnoderevs(repo.ui, repo, oldheads)
1832 newheads = repo.changelog.headrevs()
1837 newheads = repo.changelog.headrevs()
1833 newfnodes = tagsmod.fnoderevs(repo.ui, repo, newheads)
1838 newfnodes = tagsmod.fnoderevs(repo.ui, repo, newheads)
1834 # notes: we compare lists here.
1839 # notes: we compare lists here.
1835 # As we do it only once buiding set would not be cheaper
1840 # As we do it only once buiding set would not be cheaper
1836 changes = tagsmod.difftags(repo.ui, repo, oldfnodes, newfnodes)
1841 changes = tagsmod.difftags(repo.ui, repo, oldfnodes, newfnodes)
1837 if changes:
1842 if changes:
1838 tr2.hookargs['tag_moved'] = '1'
1843 tr2.hookargs['tag_moved'] = '1'
1839 with repo.vfs('changes/tags.changes', 'w',
1844 with repo.vfs('changes/tags.changes', 'w',
1840 atomictemp=True) as changesfile:
1845 atomictemp=True) as changesfile:
1841 # note: we do not register the file to the transaction
1846 # note: we do not register the file to the transaction
1842 # because we needs it to still exist on the transaction
1847 # because we needs it to still exist on the transaction
1843 # is close (for txnclose hooks)
1848 # is close (for txnclose hooks)
1844 tagsmod.writediff(changesfile, changes)
1849 tagsmod.writediff(changesfile, changes)
1845 def validate(tr2):
1850 def validate(tr2):
1846 """will run pre-closing hooks"""
1851 """will run pre-closing hooks"""
1847 # XXX the transaction API is a bit lacking here so we take a hacky
1852 # XXX the transaction API is a bit lacking here so we take a hacky
1848 # path for now
1853 # path for now
1849 #
1854 #
1850 # We cannot add this as a "pending" hooks since the 'tr.hookargs'
1855 # We cannot add this as a "pending" hooks since the 'tr.hookargs'
1851 # dict is copied before these run. In addition we needs the data
1856 # dict is copied before these run. In addition we needs the data
1852 # available to in memory hooks too.
1857 # available to in memory hooks too.
1853 #
1858 #
1854 # Moreover, we also need to make sure this runs before txnclose
1859 # Moreover, we also need to make sure this runs before txnclose
1855 # hooks and there is no "pending" mechanism that would execute
1860 # hooks and there is no "pending" mechanism that would execute
1856 # logic only if hooks are about to run.
1861 # logic only if hooks are about to run.
1857 #
1862 #
1858 # Fixing this limitation of the transaction is also needed to track
1863 # Fixing this limitation of the transaction is also needed to track
1859 # other families of changes (bookmarks, phases, obsolescence).
1864 # other families of changes (bookmarks, phases, obsolescence).
1860 #
1865 #
1861 # This will have to be fixed before we remove the experimental
1866 # This will have to be fixed before we remove the experimental
1862 # gating.
1867 # gating.
1863 tracktags(tr2)
1868 tracktags(tr2)
1864 repo = reporef()
1869 repo = reporef()
1865 if repo.ui.configbool('experimental', 'single-head-per-branch'):
1870 if repo.ui.configbool('experimental', 'single-head-per-branch'):
1866 scmutil.enforcesinglehead(repo, tr2, desc)
1871 scmutil.enforcesinglehead(repo, tr2, desc)
1867 if hook.hashook(repo.ui, 'pretxnclose-bookmark'):
1872 if hook.hashook(repo.ui, 'pretxnclose-bookmark'):
1868 for name, (old, new) in sorted(tr.changes['bookmarks'].items()):
1873 for name, (old, new) in sorted(tr.changes['bookmarks'].items()):
1869 args = tr.hookargs.copy()
1874 args = tr.hookargs.copy()
1870 args.update(bookmarks.preparehookargs(name, old, new))
1875 args.update(bookmarks.preparehookargs(name, old, new))
1871 repo.hook('pretxnclose-bookmark', throw=True,
1876 repo.hook('pretxnclose-bookmark', throw=True,
1872 **pycompat.strkwargs(args))
1877 **pycompat.strkwargs(args))
1873 if hook.hashook(repo.ui, 'pretxnclose-phase'):
1878 if hook.hashook(repo.ui, 'pretxnclose-phase'):
1874 cl = repo.unfiltered().changelog
1879 cl = repo.unfiltered().changelog
1875 for rev, (old, new) in tr.changes['phases'].items():
1880 for rev, (old, new) in tr.changes['phases'].items():
1876 args = tr.hookargs.copy()
1881 args = tr.hookargs.copy()
1877 node = hex(cl.node(rev))
1882 node = hex(cl.node(rev))
1878 args.update(phases.preparehookargs(node, old, new))
1883 args.update(phases.preparehookargs(node, old, new))
1879 repo.hook('pretxnclose-phase', throw=True,
1884 repo.hook('pretxnclose-phase', throw=True,
1880 **pycompat.strkwargs(args))
1885 **pycompat.strkwargs(args))
1881
1886
1882 repo.hook('pretxnclose', throw=True,
1887 repo.hook('pretxnclose', throw=True,
1883 **pycompat.strkwargs(tr.hookargs))
1888 **pycompat.strkwargs(tr.hookargs))
1884 def releasefn(tr, success):
1889 def releasefn(tr, success):
1885 repo = reporef()
1890 repo = reporef()
1886 if success:
1891 if success:
1887 # this should be explicitly invoked here, because
1892 # this should be explicitly invoked here, because
1888 # in-memory changes aren't written out at closing
1893 # in-memory changes aren't written out at closing
1889 # transaction, if tr.addfilegenerator (via
1894 # transaction, if tr.addfilegenerator (via
1890 # dirstate.write or so) isn't invoked while
1895 # dirstate.write or so) isn't invoked while
1891 # transaction running
1896 # transaction running
1892 repo.dirstate.write(None)
1897 repo.dirstate.write(None)
1893 else:
1898 else:
1894 # discard all changes (including ones already written
1899 # discard all changes (including ones already written
1895 # out) in this transaction
1900 # out) in this transaction
1896 narrowspec.restorebackup(self, 'journal.narrowspec')
1901 narrowspec.restorebackup(self, 'journal.narrowspec')
1897 narrowspec.restorewcbackup(self, 'journal.narrowspec.dirstate')
1902 narrowspec.restorewcbackup(self, 'journal.narrowspec.dirstate')
1898 repo.dirstate.restorebackup(None, 'journal.dirstate')
1903 repo.dirstate.restorebackup(None, 'journal.dirstate')
1899
1904
1900 repo.invalidate(clearfilecache=True)
1905 repo.invalidate(clearfilecache=True)
1901
1906
1902 tr = transaction.transaction(rp, self.svfs, vfsmap,
1907 tr = transaction.transaction(rp, self.svfs, vfsmap,
1903 "journal",
1908 "journal",
1904 "undo",
1909 "undo",
1905 aftertrans(renames),
1910 aftertrans(renames),
1906 self.store.createmode,
1911 self.store.createmode,
1907 validator=validate,
1912 validator=validate,
1908 releasefn=releasefn,
1913 releasefn=releasefn,
1909 checkambigfiles=_cachedfiles,
1914 checkambigfiles=_cachedfiles,
1910 name=desc)
1915 name=desc)
1911 tr.changes['origrepolen'] = len(self)
1916 tr.changes['origrepolen'] = len(self)
1912 tr.changes['obsmarkers'] = set()
1917 tr.changes['obsmarkers'] = set()
1913 tr.changes['phases'] = {}
1918 tr.changes['phases'] = {}
1914 tr.changes['bookmarks'] = {}
1919 tr.changes['bookmarks'] = {}
1915
1920
1916 tr.hookargs['txnid'] = txnid
1921 tr.hookargs['txnid'] = txnid
1917 tr.hookargs['txnname'] = desc
1922 tr.hookargs['txnname'] = desc
1918 # note: writing the fncache only during finalize mean that the file is
1923 # note: writing the fncache only during finalize mean that the file is
1919 # outdated when running hooks. As fncache is used for streaming clone,
1924 # outdated when running hooks. As fncache is used for streaming clone,
1920 # this is not expected to break anything that happen during the hooks.
1925 # this is not expected to break anything that happen during the hooks.
1921 tr.addfinalize('flush-fncache', self.store.write)
1926 tr.addfinalize('flush-fncache', self.store.write)
1922 def txnclosehook(tr2):
1927 def txnclosehook(tr2):
1923 """To be run if transaction is successful, will schedule a hook run
1928 """To be run if transaction is successful, will schedule a hook run
1924 """
1929 """
1925 # Don't reference tr2 in hook() so we don't hold a reference.
1930 # Don't reference tr2 in hook() so we don't hold a reference.
1926 # This reduces memory consumption when there are multiple
1931 # This reduces memory consumption when there are multiple
1927 # transactions per lock. This can likely go away if issue5045
1932 # transactions per lock. This can likely go away if issue5045
1928 # fixes the function accumulation.
1933 # fixes the function accumulation.
1929 hookargs = tr2.hookargs
1934 hookargs = tr2.hookargs
1930
1935
1931 def hookfunc():
1936 def hookfunc():
1932 repo = reporef()
1937 repo = reporef()
1933 if hook.hashook(repo.ui, 'txnclose-bookmark'):
1938 if hook.hashook(repo.ui, 'txnclose-bookmark'):
1934 bmchanges = sorted(tr.changes['bookmarks'].items())
1939 bmchanges = sorted(tr.changes['bookmarks'].items())
1935 for name, (old, new) in bmchanges:
1940 for name, (old, new) in bmchanges:
1936 args = tr.hookargs.copy()
1941 args = tr.hookargs.copy()
1937 args.update(bookmarks.preparehookargs(name, old, new))
1942 args.update(bookmarks.preparehookargs(name, old, new))
1938 repo.hook('txnclose-bookmark', throw=False,
1943 repo.hook('txnclose-bookmark', throw=False,
1939 **pycompat.strkwargs(args))
1944 **pycompat.strkwargs(args))
1940
1945
1941 if hook.hashook(repo.ui, 'txnclose-phase'):
1946 if hook.hashook(repo.ui, 'txnclose-phase'):
1942 cl = repo.unfiltered().changelog
1947 cl = repo.unfiltered().changelog
1943 phasemv = sorted(tr.changes['phases'].items())
1948 phasemv = sorted(tr.changes['phases'].items())
1944 for rev, (old, new) in phasemv:
1949 for rev, (old, new) in phasemv:
1945 args = tr.hookargs.copy()
1950 args = tr.hookargs.copy()
1946 node = hex(cl.node(rev))
1951 node = hex(cl.node(rev))
1947 args.update(phases.preparehookargs(node, old, new))
1952 args.update(phases.preparehookargs(node, old, new))
1948 repo.hook('txnclose-phase', throw=False,
1953 repo.hook('txnclose-phase', throw=False,
1949 **pycompat.strkwargs(args))
1954 **pycompat.strkwargs(args))
1950
1955
1951 repo.hook('txnclose', throw=False,
1956 repo.hook('txnclose', throw=False,
1952 **pycompat.strkwargs(hookargs))
1957 **pycompat.strkwargs(hookargs))
1953 reporef()._afterlock(hookfunc)
1958 reporef()._afterlock(hookfunc)
1954 tr.addfinalize('txnclose-hook', txnclosehook)
1959 tr.addfinalize('txnclose-hook', txnclosehook)
1955 # Include a leading "-" to make it happen before the transaction summary
1960 # Include a leading "-" to make it happen before the transaction summary
1956 # reports registered via scmutil.registersummarycallback() whose names
1961 # reports registered via scmutil.registersummarycallback() whose names
1957 # are 00-txnreport etc. That way, the caches will be warm when the
1962 # are 00-txnreport etc. That way, the caches will be warm when the
1958 # callbacks run.
1963 # callbacks run.
1959 tr.addpostclose('-warm-cache', self._buildcacheupdater(tr))
1964 tr.addpostclose('-warm-cache', self._buildcacheupdater(tr))
1960 def txnaborthook(tr2):
1965 def txnaborthook(tr2):
1961 """To be run if transaction is aborted
1966 """To be run if transaction is aborted
1962 """
1967 """
1963 reporef().hook('txnabort', throw=False,
1968 reporef().hook('txnabort', throw=False,
1964 **pycompat.strkwargs(tr2.hookargs))
1969 **pycompat.strkwargs(tr2.hookargs))
1965 tr.addabort('txnabort-hook', txnaborthook)
1970 tr.addabort('txnabort-hook', txnaborthook)
1966 # avoid eager cache invalidation. in-memory data should be identical
1971 # avoid eager cache invalidation. in-memory data should be identical
1967 # to stored data if transaction has no error.
1972 # to stored data if transaction has no error.
1968 tr.addpostclose('refresh-filecachestats', self._refreshfilecachestats)
1973 tr.addpostclose('refresh-filecachestats', self._refreshfilecachestats)
1969 self._transref = weakref.ref(tr)
1974 self._transref = weakref.ref(tr)
1970 scmutil.registersummarycallback(self, tr, desc)
1975 scmutil.registersummarycallback(self, tr, desc)
1971 return tr
1976 return tr
1972
1977
1973 def _journalfiles(self):
1978 def _journalfiles(self):
1974 return ((self.svfs, 'journal'),
1979 return ((self.svfs, 'journal'),
1975 (self.svfs, 'journal.narrowspec'),
1980 (self.svfs, 'journal.narrowspec'),
1976 (self.vfs, 'journal.narrowspec.dirstate'),
1981 (self.vfs, 'journal.narrowspec.dirstate'),
1977 (self.vfs, 'journal.dirstate'),
1982 (self.vfs, 'journal.dirstate'),
1978 (self.vfs, 'journal.branch'),
1983 (self.vfs, 'journal.branch'),
1979 (self.vfs, 'journal.desc'),
1984 (self.vfs, 'journal.desc'),
1980 (self.vfs, 'journal.bookmarks'),
1985 (self.vfs, 'journal.bookmarks'),
1981 (self.svfs, 'journal.phaseroots'))
1986 (self.svfs, 'journal.phaseroots'))
1982
1987
1983 def undofiles(self):
1988 def undofiles(self):
1984 return [(vfs, undoname(x)) for vfs, x in self._journalfiles()]
1989 return [(vfs, undoname(x)) for vfs, x in self._journalfiles()]
1985
1990
1986 @unfilteredmethod
1991 @unfilteredmethod
1987 def _writejournal(self, desc):
1992 def _writejournal(self, desc):
1988 self.dirstate.savebackup(None, 'journal.dirstate')
1993 self.dirstate.savebackup(None, 'journal.dirstate')
1989 narrowspec.savewcbackup(self, 'journal.narrowspec.dirstate')
1994 narrowspec.savewcbackup(self, 'journal.narrowspec.dirstate')
1990 narrowspec.savebackup(self, 'journal.narrowspec')
1995 narrowspec.savebackup(self, 'journal.narrowspec')
1991 self.vfs.write("journal.branch",
1996 self.vfs.write("journal.branch",
1992 encoding.fromlocal(self.dirstate.branch()))
1997 encoding.fromlocal(self.dirstate.branch()))
1993 self.vfs.write("journal.desc",
1998 self.vfs.write("journal.desc",
1994 "%d\n%s\n" % (len(self), desc))
1999 "%d\n%s\n" % (len(self), desc))
1995 self.vfs.write("journal.bookmarks",
2000 self.vfs.write("journal.bookmarks",
1996 self.vfs.tryread("bookmarks"))
2001 self.vfs.tryread("bookmarks"))
1997 self.svfs.write("journal.phaseroots",
2002 self.svfs.write("journal.phaseroots",
1998 self.svfs.tryread("phaseroots"))
2003 self.svfs.tryread("phaseroots"))
1999
2004
2000 def recover(self):
2005 def recover(self):
2001 with self.lock():
2006 with self.lock():
2002 if self.svfs.exists("journal"):
2007 if self.svfs.exists("journal"):
2003 self.ui.status(_("rolling back interrupted transaction\n"))
2008 self.ui.status(_("rolling back interrupted transaction\n"))
2004 vfsmap = {'': self.svfs,
2009 vfsmap = {'': self.svfs,
2005 'plain': self.vfs,}
2010 'plain': self.vfs,}
2006 transaction.rollback(self.svfs, vfsmap, "journal",
2011 transaction.rollback(self.svfs, vfsmap, "journal",
2007 self.ui.warn,
2012 self.ui.warn,
2008 checkambigfiles=_cachedfiles)
2013 checkambigfiles=_cachedfiles)
2009 self.invalidate()
2014 self.invalidate()
2010 return True
2015 return True
2011 else:
2016 else:
2012 self.ui.warn(_("no interrupted transaction available\n"))
2017 self.ui.warn(_("no interrupted transaction available\n"))
2013 return False
2018 return False
2014
2019
2015 def rollback(self, dryrun=False, force=False):
2020 def rollback(self, dryrun=False, force=False):
2016 wlock = lock = dsguard = None
2021 wlock = lock = dsguard = None
2017 try:
2022 try:
2018 wlock = self.wlock()
2023 wlock = self.wlock()
2019 lock = self.lock()
2024 lock = self.lock()
2020 if self.svfs.exists("undo"):
2025 if self.svfs.exists("undo"):
2021 dsguard = dirstateguard.dirstateguard(self, 'rollback')
2026 dsguard = dirstateguard.dirstateguard(self, 'rollback')
2022
2027
2023 return self._rollback(dryrun, force, dsguard)
2028 return self._rollback(dryrun, force, dsguard)
2024 else:
2029 else:
2025 self.ui.warn(_("no rollback information available\n"))
2030 self.ui.warn(_("no rollback information available\n"))
2026 return 1
2031 return 1
2027 finally:
2032 finally:
2028 release(dsguard, lock, wlock)
2033 release(dsguard, lock, wlock)
2029
2034
2030 @unfilteredmethod # Until we get smarter cache management
2035 @unfilteredmethod # Until we get smarter cache management
2031 def _rollback(self, dryrun, force, dsguard):
2036 def _rollback(self, dryrun, force, dsguard):
2032 ui = self.ui
2037 ui = self.ui
2033 try:
2038 try:
2034 args = self.vfs.read('undo.desc').splitlines()
2039 args = self.vfs.read('undo.desc').splitlines()
2035 (oldlen, desc, detail) = (int(args[0]), args[1], None)
2040 (oldlen, desc, detail) = (int(args[0]), args[1], None)
2036 if len(args) >= 3:
2041 if len(args) >= 3:
2037 detail = args[2]
2042 detail = args[2]
2038 oldtip = oldlen - 1
2043 oldtip = oldlen - 1
2039
2044
2040 if detail and ui.verbose:
2045 if detail and ui.verbose:
2041 msg = (_('repository tip rolled back to revision %d'
2046 msg = (_('repository tip rolled back to revision %d'
2042 ' (undo %s: %s)\n')
2047 ' (undo %s: %s)\n')
2043 % (oldtip, desc, detail))
2048 % (oldtip, desc, detail))
2044 else:
2049 else:
2045 msg = (_('repository tip rolled back to revision %d'
2050 msg = (_('repository tip rolled back to revision %d'
2046 ' (undo %s)\n')
2051 ' (undo %s)\n')
2047 % (oldtip, desc))
2052 % (oldtip, desc))
2048 except IOError:
2053 except IOError:
2049 msg = _('rolling back unknown transaction\n')
2054 msg = _('rolling back unknown transaction\n')
2050 desc = None
2055 desc = None
2051
2056
2052 if not force and self['.'] != self['tip'] and desc == 'commit':
2057 if not force and self['.'] != self['tip'] and desc == 'commit':
2053 raise error.Abort(
2058 raise error.Abort(
2054 _('rollback of last commit while not checked out '
2059 _('rollback of last commit while not checked out '
2055 'may lose data'), hint=_('use -f to force'))
2060 'may lose data'), hint=_('use -f to force'))
2056
2061
2057 ui.status(msg)
2062 ui.status(msg)
2058 if dryrun:
2063 if dryrun:
2059 return 0
2064 return 0
2060
2065
2061 parents = self.dirstate.parents()
2066 parents = self.dirstate.parents()
2062 self.destroying()
2067 self.destroying()
2063 vfsmap = {'plain': self.vfs, '': self.svfs}
2068 vfsmap = {'plain': self.vfs, '': self.svfs}
2064 transaction.rollback(self.svfs, vfsmap, 'undo', ui.warn,
2069 transaction.rollback(self.svfs, vfsmap, 'undo', ui.warn,
2065 checkambigfiles=_cachedfiles)
2070 checkambigfiles=_cachedfiles)
2066 if self.vfs.exists('undo.bookmarks'):
2071 if self.vfs.exists('undo.bookmarks'):
2067 self.vfs.rename('undo.bookmarks', 'bookmarks', checkambig=True)
2072 self.vfs.rename('undo.bookmarks', 'bookmarks', checkambig=True)
2068 if self.svfs.exists('undo.phaseroots'):
2073 if self.svfs.exists('undo.phaseroots'):
2069 self.svfs.rename('undo.phaseroots', 'phaseroots', checkambig=True)
2074 self.svfs.rename('undo.phaseroots', 'phaseroots', checkambig=True)
2070 self.invalidate()
2075 self.invalidate()
2071
2076
2072 parentgone = any(p not in self.changelog.nodemap for p in parents)
2077 parentgone = any(p not in self.changelog.nodemap for p in parents)
2073 if parentgone:
2078 if parentgone:
2074 # prevent dirstateguard from overwriting already restored one
2079 # prevent dirstateguard from overwriting already restored one
2075 dsguard.close()
2080 dsguard.close()
2076
2081
2077 narrowspec.restorebackup(self, 'undo.narrowspec')
2082 narrowspec.restorebackup(self, 'undo.narrowspec')
2078 narrowspec.restorewcbackup(self, 'undo.narrowspec.dirstate')
2083 narrowspec.restorewcbackup(self, 'undo.narrowspec.dirstate')
2079 self.dirstate.restorebackup(None, 'undo.dirstate')
2084 self.dirstate.restorebackup(None, 'undo.dirstate')
2080 try:
2085 try:
2081 branch = self.vfs.read('undo.branch')
2086 branch = self.vfs.read('undo.branch')
2082 self.dirstate.setbranch(encoding.tolocal(branch))
2087 self.dirstate.setbranch(encoding.tolocal(branch))
2083 except IOError:
2088 except IOError:
2084 ui.warn(_('named branch could not be reset: '
2089 ui.warn(_('named branch could not be reset: '
2085 'current branch is still \'%s\'\n')
2090 'current branch is still \'%s\'\n')
2086 % self.dirstate.branch())
2091 % self.dirstate.branch())
2087
2092
2088 parents = tuple([p.rev() for p in self[None].parents()])
2093 parents = tuple([p.rev() for p in self[None].parents()])
2089 if len(parents) > 1:
2094 if len(parents) > 1:
2090 ui.status(_('working directory now based on '
2095 ui.status(_('working directory now based on '
2091 'revisions %d and %d\n') % parents)
2096 'revisions %d and %d\n') % parents)
2092 else:
2097 else:
2093 ui.status(_('working directory now based on '
2098 ui.status(_('working directory now based on '
2094 'revision %d\n') % parents)
2099 'revision %d\n') % parents)
2095 mergemod.mergestate.clean(self, self['.'].node())
2100 mergemod.mergestate.clean(self, self['.'].node())
2096
2101
2097 # TODO: if we know which new heads may result from this rollback, pass
2102 # TODO: if we know which new heads may result from this rollback, pass
2098 # them to destroy(), which will prevent the branchhead cache from being
2103 # them to destroy(), which will prevent the branchhead cache from being
2099 # invalidated.
2104 # invalidated.
2100 self.destroyed()
2105 self.destroyed()
2101 return 0
2106 return 0
2102
2107
2103 def _buildcacheupdater(self, newtransaction):
2108 def _buildcacheupdater(self, newtransaction):
2104 """called during transaction to build the callback updating cache
2109 """called during transaction to build the callback updating cache
2105
2110
2106 Lives on the repository to help extension who might want to augment
2111 Lives on the repository to help extension who might want to augment
2107 this logic. For this purpose, the created transaction is passed to the
2112 this logic. For this purpose, the created transaction is passed to the
2108 method.
2113 method.
2109 """
2114 """
2110 # we must avoid cyclic reference between repo and transaction.
2115 # we must avoid cyclic reference between repo and transaction.
2111 reporef = weakref.ref(self)
2116 reporef = weakref.ref(self)
2112 def updater(tr):
2117 def updater(tr):
2113 repo = reporef()
2118 repo = reporef()
2114 repo.updatecaches(tr)
2119 repo.updatecaches(tr)
2115 return updater
2120 return updater
2116
2121
2117 @unfilteredmethod
2122 @unfilteredmethod
2118 def updatecaches(self, tr=None, full=False):
2123 def updatecaches(self, tr=None, full=False):
2119 """warm appropriate caches
2124 """warm appropriate caches
2120
2125
2121 If this function is called after a transaction closed. The transaction
2126 If this function is called after a transaction closed. The transaction
2122 will be available in the 'tr' argument. This can be used to selectively
2127 will be available in the 'tr' argument. This can be used to selectively
2123 update caches relevant to the changes in that transaction.
2128 update caches relevant to the changes in that transaction.
2124
2129
2125 If 'full' is set, make sure all caches the function knows about have
2130 If 'full' is set, make sure all caches the function knows about have
2126 up-to-date data. Even the ones usually loaded more lazily.
2131 up-to-date data. Even the ones usually loaded more lazily.
2127 """
2132 """
2128 if tr is not None and tr.hookargs.get('source') == 'strip':
2133 if tr is not None and tr.hookargs.get('source') == 'strip':
2129 # During strip, many caches are invalid but
2134 # During strip, many caches are invalid but
2130 # later call to `destroyed` will refresh them.
2135 # later call to `destroyed` will refresh them.
2131 return
2136 return
2132
2137
2133 if tr is None or tr.changes['origrepolen'] < len(self):
2138 if tr is None or tr.changes['origrepolen'] < len(self):
2134 # accessing the 'ser ved' branchmap should refresh all the others,
2139 # accessing the 'ser ved' branchmap should refresh all the others,
2135 self.ui.debug('updating the branch cache\n')
2140 self.ui.debug('updating the branch cache\n')
2136 self.filtered('served').branchmap()
2141 self.filtered('served').branchmap()
2137 self.filtered('served.hidden').branchmap()
2142 self.filtered('served.hidden').branchmap()
2138
2143
2139 if full:
2144 if full:
2140 unfi = self.unfiltered()
2145 unfi = self.unfiltered()
2141 rbc = unfi.revbranchcache()
2146 rbc = unfi.revbranchcache()
2142 for r in unfi.changelog:
2147 for r in unfi.changelog:
2143 rbc.branchinfo(r)
2148 rbc.branchinfo(r)
2144 rbc.write()
2149 rbc.write()
2145
2150
2146 # ensure the working copy parents are in the manifestfulltextcache
2151 # ensure the working copy parents are in the manifestfulltextcache
2147 for ctx in self['.'].parents():
2152 for ctx in self['.'].parents():
2148 ctx.manifest() # accessing the manifest is enough
2153 ctx.manifest() # accessing the manifest is enough
2149
2154
2150 # accessing tags warm the cache
2155 # accessing tags warm the cache
2151 self.tags()
2156 self.tags()
2152 self.filtered('served').tags()
2157 self.filtered('served').tags()
2153
2158
2154 def invalidatecaches(self):
2159 def invalidatecaches(self):
2155
2160
2156 if r'_tagscache' in vars(self):
2161 if r'_tagscache' in vars(self):
2157 # can't use delattr on proxy
2162 # can't use delattr on proxy
2158 del self.__dict__[r'_tagscache']
2163 del self.__dict__[r'_tagscache']
2159
2164
2160 self._branchcaches.clear()
2165 self._branchcaches.clear()
2161 self.invalidatevolatilesets()
2166 self.invalidatevolatilesets()
2162 self._sparsesignaturecache.clear()
2167 self._sparsesignaturecache.clear()
2163
2168
2164 def invalidatevolatilesets(self):
2169 def invalidatevolatilesets(self):
2165 self.filteredrevcache.clear()
2170 self.filteredrevcache.clear()
2166 obsolete.clearobscaches(self)
2171 obsolete.clearobscaches(self)
2167
2172
2168 def invalidatedirstate(self):
2173 def invalidatedirstate(self):
2169 '''Invalidates the dirstate, causing the next call to dirstate
2174 '''Invalidates the dirstate, causing the next call to dirstate
2170 to check if it was modified since the last time it was read,
2175 to check if it was modified since the last time it was read,
2171 rereading it if it has.
2176 rereading it if it has.
2172
2177
2173 This is different to dirstate.invalidate() that it doesn't always
2178 This is different to dirstate.invalidate() that it doesn't always
2174 rereads the dirstate. Use dirstate.invalidate() if you want to
2179 rereads the dirstate. Use dirstate.invalidate() if you want to
2175 explicitly read the dirstate again (i.e. restoring it to a previous
2180 explicitly read the dirstate again (i.e. restoring it to a previous
2176 known good state).'''
2181 known good state).'''
2177 if hasunfilteredcache(self, r'dirstate'):
2182 if hasunfilteredcache(self, r'dirstate'):
2178 for k in self.dirstate._filecache:
2183 for k in self.dirstate._filecache:
2179 try:
2184 try:
2180 delattr(self.dirstate, k)
2185 delattr(self.dirstate, k)
2181 except AttributeError:
2186 except AttributeError:
2182 pass
2187 pass
2183 delattr(self.unfiltered(), r'dirstate')
2188 delattr(self.unfiltered(), r'dirstate')
2184
2189
2185 def invalidate(self, clearfilecache=False):
2190 def invalidate(self, clearfilecache=False):
2186 '''Invalidates both store and non-store parts other than dirstate
2191 '''Invalidates both store and non-store parts other than dirstate
2187
2192
2188 If a transaction is running, invalidation of store is omitted,
2193 If a transaction is running, invalidation of store is omitted,
2189 because discarding in-memory changes might cause inconsistency
2194 because discarding in-memory changes might cause inconsistency
2190 (e.g. incomplete fncache causes unintentional failure, but
2195 (e.g. incomplete fncache causes unintentional failure, but
2191 redundant one doesn't).
2196 redundant one doesn't).
2192 '''
2197 '''
2193 unfiltered = self.unfiltered() # all file caches are stored unfiltered
2198 unfiltered = self.unfiltered() # all file caches are stored unfiltered
2194 for k in list(self._filecache.keys()):
2199 for k in list(self._filecache.keys()):
2195 # dirstate is invalidated separately in invalidatedirstate()
2200 # dirstate is invalidated separately in invalidatedirstate()
2196 if k == 'dirstate':
2201 if k == 'dirstate':
2197 continue
2202 continue
2198 if (k == 'changelog' and
2203 if (k == 'changelog' and
2199 self.currenttransaction() and
2204 self.currenttransaction() and
2200 self.changelog._delayed):
2205 self.changelog._delayed):
2201 # The changelog object may store unwritten revisions. We don't
2206 # The changelog object may store unwritten revisions. We don't
2202 # want to lose them.
2207 # want to lose them.
2203 # TODO: Solve the problem instead of working around it.
2208 # TODO: Solve the problem instead of working around it.
2204 continue
2209 continue
2205
2210
2206 if clearfilecache:
2211 if clearfilecache:
2207 del self._filecache[k]
2212 del self._filecache[k]
2208 try:
2213 try:
2209 delattr(unfiltered, k)
2214 delattr(unfiltered, k)
2210 except AttributeError:
2215 except AttributeError:
2211 pass
2216 pass
2212 self.invalidatecaches()
2217 self.invalidatecaches()
2213 if not self.currenttransaction():
2218 if not self.currenttransaction():
2214 # TODO: Changing contents of store outside transaction
2219 # TODO: Changing contents of store outside transaction
2215 # causes inconsistency. We should make in-memory store
2220 # causes inconsistency. We should make in-memory store
2216 # changes detectable, and abort if changed.
2221 # changes detectable, and abort if changed.
2217 self.store.invalidatecaches()
2222 self.store.invalidatecaches()
2218
2223
2219 def invalidateall(self):
2224 def invalidateall(self):
2220 '''Fully invalidates both store and non-store parts, causing the
2225 '''Fully invalidates both store and non-store parts, causing the
2221 subsequent operation to reread any outside changes.'''
2226 subsequent operation to reread any outside changes.'''
2222 # extension should hook this to invalidate its caches
2227 # extension should hook this to invalidate its caches
2223 self.invalidate()
2228 self.invalidate()
2224 self.invalidatedirstate()
2229 self.invalidatedirstate()
2225
2230
2226 @unfilteredmethod
2231 @unfilteredmethod
2227 def _refreshfilecachestats(self, tr):
2232 def _refreshfilecachestats(self, tr):
2228 """Reload stats of cached files so that they are flagged as valid"""
2233 """Reload stats of cached files so that they are flagged as valid"""
2229 for k, ce in self._filecache.items():
2234 for k, ce in self._filecache.items():
2230 k = pycompat.sysstr(k)
2235 k = pycompat.sysstr(k)
2231 if k == r'dirstate' or k not in self.__dict__:
2236 if k == r'dirstate' or k not in self.__dict__:
2232 continue
2237 continue
2233 ce.refresh()
2238 ce.refresh()
2234
2239
2235 def _lock(self, vfs, lockname, wait, releasefn, acquirefn, desc,
2240 def _lock(self, vfs, lockname, wait, releasefn, acquirefn, desc,
2236 inheritchecker=None, parentenvvar=None):
2241 inheritchecker=None, parentenvvar=None):
2237 parentlock = None
2242 parentlock = None
2238 # the contents of parentenvvar are used by the underlying lock to
2243 # the contents of parentenvvar are used by the underlying lock to
2239 # determine whether it can be inherited
2244 # determine whether it can be inherited
2240 if parentenvvar is not None:
2245 if parentenvvar is not None:
2241 parentlock = encoding.environ.get(parentenvvar)
2246 parentlock = encoding.environ.get(parentenvvar)
2242
2247
2243 timeout = 0
2248 timeout = 0
2244 warntimeout = 0
2249 warntimeout = 0
2245 if wait:
2250 if wait:
2246 timeout = self.ui.configint("ui", "timeout")
2251 timeout = self.ui.configint("ui", "timeout")
2247 warntimeout = self.ui.configint("ui", "timeout.warn")
2252 warntimeout = self.ui.configint("ui", "timeout.warn")
2248 # internal config: ui.signal-safe-lock
2253 # internal config: ui.signal-safe-lock
2249 signalsafe = self.ui.configbool('ui', 'signal-safe-lock')
2254 signalsafe = self.ui.configbool('ui', 'signal-safe-lock')
2250
2255
2251 l = lockmod.trylock(self.ui, vfs, lockname, timeout, warntimeout,
2256 l = lockmod.trylock(self.ui, vfs, lockname, timeout, warntimeout,
2252 releasefn=releasefn,
2257 releasefn=releasefn,
2253 acquirefn=acquirefn, desc=desc,
2258 acquirefn=acquirefn, desc=desc,
2254 inheritchecker=inheritchecker,
2259 inheritchecker=inheritchecker,
2255 parentlock=parentlock,
2260 parentlock=parentlock,
2256 signalsafe=signalsafe)
2261 signalsafe=signalsafe)
2257 return l
2262 return l
2258
2263
2259 def _afterlock(self, callback):
2264 def _afterlock(self, callback):
2260 """add a callback to be run when the repository is fully unlocked
2265 """add a callback to be run when the repository is fully unlocked
2261
2266
2262 The callback will be executed when the outermost lock is released
2267 The callback will be executed when the outermost lock is released
2263 (with wlock being higher level than 'lock')."""
2268 (with wlock being higher level than 'lock')."""
2264 for ref in (self._wlockref, self._lockref):
2269 for ref in (self._wlockref, self._lockref):
2265 l = ref and ref()
2270 l = ref and ref()
2266 if l and l.held:
2271 if l and l.held:
2267 l.postrelease.append(callback)
2272 l.postrelease.append(callback)
2268 break
2273 break
2269 else: # no lock have been found.
2274 else: # no lock have been found.
2270 callback()
2275 callback()
2271
2276
2272 def lock(self, wait=True):
2277 def lock(self, wait=True):
2273 '''Lock the repository store (.hg/store) and return a weak reference
2278 '''Lock the repository store (.hg/store) and return a weak reference
2274 to the lock. Use this before modifying the store (e.g. committing or
2279 to the lock. Use this before modifying the store (e.g. committing or
2275 stripping). If you are opening a transaction, get a lock as well.)
2280 stripping). If you are opening a transaction, get a lock as well.)
2276
2281
2277 If both 'lock' and 'wlock' must be acquired, ensure you always acquires
2282 If both 'lock' and 'wlock' must be acquired, ensure you always acquires
2278 'wlock' first to avoid a dead-lock hazard.'''
2283 'wlock' first to avoid a dead-lock hazard.'''
2279 l = self._currentlock(self._lockref)
2284 l = self._currentlock(self._lockref)
2280 if l is not None:
2285 if l is not None:
2281 l.lock()
2286 l.lock()
2282 return l
2287 return l
2283
2288
2284 l = self._lock(vfs=self.svfs,
2289 l = self._lock(vfs=self.svfs,
2285 lockname="lock",
2290 lockname="lock",
2286 wait=wait,
2291 wait=wait,
2287 releasefn=None,
2292 releasefn=None,
2288 acquirefn=self.invalidate,
2293 acquirefn=self.invalidate,
2289 desc=_('repository %s') % self.origroot)
2294 desc=_('repository %s') % self.origroot)
2290 self._lockref = weakref.ref(l)
2295 self._lockref = weakref.ref(l)
2291 return l
2296 return l
2292
2297
2293 def _wlockchecktransaction(self):
2298 def _wlockchecktransaction(self):
2294 if self.currenttransaction() is not None:
2299 if self.currenttransaction() is not None:
2295 raise error.LockInheritanceContractViolation(
2300 raise error.LockInheritanceContractViolation(
2296 'wlock cannot be inherited in the middle of a transaction')
2301 'wlock cannot be inherited in the middle of a transaction')
2297
2302
2298 def wlock(self, wait=True):
2303 def wlock(self, wait=True):
2299 '''Lock the non-store parts of the repository (everything under
2304 '''Lock the non-store parts of the repository (everything under
2300 .hg except .hg/store) and return a weak reference to the lock.
2305 .hg except .hg/store) and return a weak reference to the lock.
2301
2306
2302 Use this before modifying files in .hg.
2307 Use this before modifying files in .hg.
2303
2308
2304 If both 'lock' and 'wlock' must be acquired, ensure you always acquires
2309 If both 'lock' and 'wlock' must be acquired, ensure you always acquires
2305 'wlock' first to avoid a dead-lock hazard.'''
2310 'wlock' first to avoid a dead-lock hazard.'''
2306 l = self._wlockref and self._wlockref()
2311 l = self._wlockref and self._wlockref()
2307 if l is not None and l.held:
2312 if l is not None and l.held:
2308 l.lock()
2313 l.lock()
2309 return l
2314 return l
2310
2315
2311 # We do not need to check for non-waiting lock acquisition. Such
2316 # We do not need to check for non-waiting lock acquisition. Such
2312 # acquisition would not cause dead-lock as they would just fail.
2317 # acquisition would not cause dead-lock as they would just fail.
2313 if wait and (self.ui.configbool('devel', 'all-warnings')
2318 if wait and (self.ui.configbool('devel', 'all-warnings')
2314 or self.ui.configbool('devel', 'check-locks')):
2319 or self.ui.configbool('devel', 'check-locks')):
2315 if self._currentlock(self._lockref) is not None:
2320 if self._currentlock(self._lockref) is not None:
2316 self.ui.develwarn('"wlock" acquired after "lock"')
2321 self.ui.develwarn('"wlock" acquired after "lock"')
2317
2322
2318 def unlock():
2323 def unlock():
2319 if self.dirstate.pendingparentchange():
2324 if self.dirstate.pendingparentchange():
2320 self.dirstate.invalidate()
2325 self.dirstate.invalidate()
2321 else:
2326 else:
2322 self.dirstate.write(None)
2327 self.dirstate.write(None)
2323
2328
2324 self._filecache['dirstate'].refresh()
2329 self._filecache['dirstate'].refresh()
2325
2330
2326 l = self._lock(self.vfs, "wlock", wait, unlock,
2331 l = self._lock(self.vfs, "wlock", wait, unlock,
2327 self.invalidatedirstate, _('working directory of %s') %
2332 self.invalidatedirstate, _('working directory of %s') %
2328 self.origroot,
2333 self.origroot,
2329 inheritchecker=self._wlockchecktransaction,
2334 inheritchecker=self._wlockchecktransaction,
2330 parentenvvar='HG_WLOCK_LOCKER')
2335 parentenvvar='HG_WLOCK_LOCKER')
2331 self._wlockref = weakref.ref(l)
2336 self._wlockref = weakref.ref(l)
2332 return l
2337 return l
2333
2338
2334 def _currentlock(self, lockref):
2339 def _currentlock(self, lockref):
2335 """Returns the lock if it's held, or None if it's not."""
2340 """Returns the lock if it's held, or None if it's not."""
2336 if lockref is None:
2341 if lockref is None:
2337 return None
2342 return None
2338 l = lockref()
2343 l = lockref()
2339 if l is None or not l.held:
2344 if l is None or not l.held:
2340 return None
2345 return None
2341 return l
2346 return l
2342
2347
2343 def currentwlock(self):
2348 def currentwlock(self):
2344 """Returns the wlock if it's held, or None if it's not."""
2349 """Returns the wlock if it's held, or None if it's not."""
2345 return self._currentlock(self._wlockref)
2350 return self._currentlock(self._wlockref)
2346
2351
2347 def _filecommit(self, fctx, manifest1, manifest2, linkrev, tr, changelist,
2352 def _filecommit(self, fctx, manifest1, manifest2, linkrev, tr, changelist,
2348 includecopymeta):
2353 includecopymeta):
2349 """
2354 """
2350 commit an individual file as part of a larger transaction
2355 commit an individual file as part of a larger transaction
2351 """
2356 """
2352
2357
2353 fname = fctx.path()
2358 fname = fctx.path()
2354 fparent1 = manifest1.get(fname, nullid)
2359 fparent1 = manifest1.get(fname, nullid)
2355 fparent2 = manifest2.get(fname, nullid)
2360 fparent2 = manifest2.get(fname, nullid)
2356 if isinstance(fctx, context.filectx):
2361 if isinstance(fctx, context.filectx):
2357 node = fctx.filenode()
2362 node = fctx.filenode()
2358 if node in [fparent1, fparent2]:
2363 if node in [fparent1, fparent2]:
2359 self.ui.debug('reusing %s filelog entry\n' % fname)
2364 self.ui.debug('reusing %s filelog entry\n' % fname)
2360 if manifest1.flags(fname) != fctx.flags():
2365 if manifest1.flags(fname) != fctx.flags():
2361 changelist.append(fname)
2366 changelist.append(fname)
2362 return node
2367 return node
2363
2368
2364 flog = self.file(fname)
2369 flog = self.file(fname)
2365 meta = {}
2370 meta = {}
2366 cfname = fctx.copysource()
2371 cfname = fctx.copysource()
2367 if cfname and cfname != fname:
2372 if cfname and cfname != fname:
2368 # Mark the new revision of this file as a copy of another
2373 # Mark the new revision of this file as a copy of another
2369 # file. This copy data will effectively act as a parent
2374 # file. This copy data will effectively act as a parent
2370 # of this new revision. If this is a merge, the first
2375 # of this new revision. If this is a merge, the first
2371 # parent will be the nullid (meaning "look up the copy data")
2376 # parent will be the nullid (meaning "look up the copy data")
2372 # and the second one will be the other parent. For example:
2377 # and the second one will be the other parent. For example:
2373 #
2378 #
2374 # 0 --- 1 --- 3 rev1 changes file foo
2379 # 0 --- 1 --- 3 rev1 changes file foo
2375 # \ / rev2 renames foo to bar and changes it
2380 # \ / rev2 renames foo to bar and changes it
2376 # \- 2 -/ rev3 should have bar with all changes and
2381 # \- 2 -/ rev3 should have bar with all changes and
2377 # should record that bar descends from
2382 # should record that bar descends from
2378 # bar in rev2 and foo in rev1
2383 # bar in rev2 and foo in rev1
2379 #
2384 #
2380 # this allows this merge to succeed:
2385 # this allows this merge to succeed:
2381 #
2386 #
2382 # 0 --- 1 --- 3 rev4 reverts the content change from rev2
2387 # 0 --- 1 --- 3 rev4 reverts the content change from rev2
2383 # \ / merging rev3 and rev4 should use bar@rev2
2388 # \ / merging rev3 and rev4 should use bar@rev2
2384 # \- 2 --- 4 as the merge base
2389 # \- 2 --- 4 as the merge base
2385 #
2390 #
2386
2391
2387 cnode = manifest1.get(cfname)
2392 cnode = manifest1.get(cfname)
2388 newfparent = fparent2
2393 newfparent = fparent2
2389
2394
2390 if manifest2: # branch merge
2395 if manifest2: # branch merge
2391 if fparent2 == nullid or cnode is None: # copied on remote side
2396 if fparent2 == nullid or cnode is None: # copied on remote side
2392 if cfname in manifest2:
2397 if cfname in manifest2:
2393 cnode = manifest2[cfname]
2398 cnode = manifest2[cfname]
2394 newfparent = fparent1
2399 newfparent = fparent1
2395
2400
2396 # Here, we used to search backwards through history to try to find
2401 # Here, we used to search backwards through history to try to find
2397 # where the file copy came from if the source of a copy was not in
2402 # where the file copy came from if the source of a copy was not in
2398 # the parent directory. However, this doesn't actually make sense to
2403 # the parent directory. However, this doesn't actually make sense to
2399 # do (what does a copy from something not in your working copy even
2404 # do (what does a copy from something not in your working copy even
2400 # mean?) and it causes bugs (eg, issue4476). Instead, we will warn
2405 # mean?) and it causes bugs (eg, issue4476). Instead, we will warn
2401 # the user that copy information was dropped, so if they didn't
2406 # the user that copy information was dropped, so if they didn't
2402 # expect this outcome it can be fixed, but this is the correct
2407 # expect this outcome it can be fixed, but this is the correct
2403 # behavior in this circumstance.
2408 # behavior in this circumstance.
2404
2409
2405 if cnode:
2410 if cnode:
2406 self.ui.debug(" %s: copy %s:%s\n" % (fname, cfname, hex(cnode)))
2411 self.ui.debug(" %s: copy %s:%s\n" % (fname, cfname, hex(cnode)))
2407 if includecopymeta:
2412 if includecopymeta:
2408 meta["copy"] = cfname
2413 meta["copy"] = cfname
2409 meta["copyrev"] = hex(cnode)
2414 meta["copyrev"] = hex(cnode)
2410 fparent1, fparent2 = nullid, newfparent
2415 fparent1, fparent2 = nullid, newfparent
2411 else:
2416 else:
2412 self.ui.warn(_("warning: can't find ancestor for '%s' "
2417 self.ui.warn(_("warning: can't find ancestor for '%s' "
2413 "copied from '%s'!\n") % (fname, cfname))
2418 "copied from '%s'!\n") % (fname, cfname))
2414
2419
2415 elif fparent1 == nullid:
2420 elif fparent1 == nullid:
2416 fparent1, fparent2 = fparent2, nullid
2421 fparent1, fparent2 = fparent2, nullid
2417 elif fparent2 != nullid:
2422 elif fparent2 != nullid:
2418 # is one parent an ancestor of the other?
2423 # is one parent an ancestor of the other?
2419 fparentancestors = flog.commonancestorsheads(fparent1, fparent2)
2424 fparentancestors = flog.commonancestorsheads(fparent1, fparent2)
2420 if fparent1 in fparentancestors:
2425 if fparent1 in fparentancestors:
2421 fparent1, fparent2 = fparent2, nullid
2426 fparent1, fparent2 = fparent2, nullid
2422 elif fparent2 in fparentancestors:
2427 elif fparent2 in fparentancestors:
2423 fparent2 = nullid
2428 fparent2 = nullid
2424
2429
2425 # is the file changed?
2430 # is the file changed?
2426 text = fctx.data()
2431 text = fctx.data()
2427 if fparent2 != nullid or flog.cmp(fparent1, text) or meta:
2432 if fparent2 != nullid or flog.cmp(fparent1, text) or meta:
2428 changelist.append(fname)
2433 changelist.append(fname)
2429 return flog.add(text, meta, tr, linkrev, fparent1, fparent2)
2434 return flog.add(text, meta, tr, linkrev, fparent1, fparent2)
2430 # are just the flags changed during merge?
2435 # are just the flags changed during merge?
2431 elif fname in manifest1 and manifest1.flags(fname) != fctx.flags():
2436 elif fname in manifest1 and manifest1.flags(fname) != fctx.flags():
2432 changelist.append(fname)
2437 changelist.append(fname)
2433
2438
2434 return fparent1
2439 return fparent1
2435
2440
2436 def checkcommitpatterns(self, wctx, vdirs, match, status, fail):
2441 def checkcommitpatterns(self, wctx, vdirs, match, status, fail):
2437 """check for commit arguments that aren't committable"""
2442 """check for commit arguments that aren't committable"""
2438 if match.isexact() or match.prefix():
2443 if match.isexact() or match.prefix():
2439 matched = set(status.modified + status.added + status.removed)
2444 matched = set(status.modified + status.added + status.removed)
2440
2445
2441 for f in match.files():
2446 for f in match.files():
2442 f = self.dirstate.normalize(f)
2447 f = self.dirstate.normalize(f)
2443 if f == '.' or f in matched or f in wctx.substate:
2448 if f == '.' or f in matched or f in wctx.substate:
2444 continue
2449 continue
2445 if f in status.deleted:
2450 if f in status.deleted:
2446 fail(f, _('file not found!'))
2451 fail(f, _('file not found!'))
2447 if f in vdirs: # visited directory
2452 if f in vdirs: # visited directory
2448 d = f + '/'
2453 d = f + '/'
2449 for mf in matched:
2454 for mf in matched:
2450 if mf.startswith(d):
2455 if mf.startswith(d):
2451 break
2456 break
2452 else:
2457 else:
2453 fail(f, _("no match under directory!"))
2458 fail(f, _("no match under directory!"))
2454 elif f not in self.dirstate:
2459 elif f not in self.dirstate:
2455 fail(f, _("file not tracked!"))
2460 fail(f, _("file not tracked!"))
2456
2461
2457 @unfilteredmethod
2462 @unfilteredmethod
2458 def commit(self, text="", user=None, date=None, match=None, force=False,
2463 def commit(self, text="", user=None, date=None, match=None, force=False,
2459 editor=False, extra=None):
2464 editor=False, extra=None):
2460 """Add a new revision to current repository.
2465 """Add a new revision to current repository.
2461
2466
2462 Revision information is gathered from the working directory,
2467 Revision information is gathered from the working directory,
2463 match can be used to filter the committed files. If editor is
2468 match can be used to filter the committed files. If editor is
2464 supplied, it is called to get a commit message.
2469 supplied, it is called to get a commit message.
2465 """
2470 """
2466 if extra is None:
2471 if extra is None:
2467 extra = {}
2472 extra = {}
2468
2473
2469 def fail(f, msg):
2474 def fail(f, msg):
2470 raise error.Abort('%s: %s' % (f, msg))
2475 raise error.Abort('%s: %s' % (f, msg))
2471
2476
2472 if not match:
2477 if not match:
2473 match = matchmod.always()
2478 match = matchmod.always()
2474
2479
2475 if not force:
2480 if not force:
2476 vdirs = []
2481 vdirs = []
2477 match.explicitdir = vdirs.append
2482 match.explicitdir = vdirs.append
2478 match.bad = fail
2483 match.bad = fail
2479
2484
2480 # lock() for recent changelog (see issue4368)
2485 # lock() for recent changelog (see issue4368)
2481 with self.wlock(), self.lock():
2486 with self.wlock(), self.lock():
2482 wctx = self[None]
2487 wctx = self[None]
2483 merge = len(wctx.parents()) > 1
2488 merge = len(wctx.parents()) > 1
2484
2489
2485 if not force and merge and not match.always():
2490 if not force and merge and not match.always():
2486 raise error.Abort(_('cannot partially commit a merge '
2491 raise error.Abort(_('cannot partially commit a merge '
2487 '(do not specify files or patterns)'))
2492 '(do not specify files or patterns)'))
2488
2493
2489 status = self.status(match=match, clean=force)
2494 status = self.status(match=match, clean=force)
2490 if force:
2495 if force:
2491 status.modified.extend(status.clean) # mq may commit clean files
2496 status.modified.extend(status.clean) # mq may commit clean files
2492
2497
2493 # check subrepos
2498 # check subrepos
2494 subs, commitsubs, newstate = subrepoutil.precommit(
2499 subs, commitsubs, newstate = subrepoutil.precommit(
2495 self.ui, wctx, status, match, force=force)
2500 self.ui, wctx, status, match, force=force)
2496
2501
2497 # make sure all explicit patterns are matched
2502 # make sure all explicit patterns are matched
2498 if not force:
2503 if not force:
2499 self.checkcommitpatterns(wctx, vdirs, match, status, fail)
2504 self.checkcommitpatterns(wctx, vdirs, match, status, fail)
2500
2505
2501 cctx = context.workingcommitctx(self, status,
2506 cctx = context.workingcommitctx(self, status,
2502 text, user, date, extra)
2507 text, user, date, extra)
2503
2508
2504 # internal config: ui.allowemptycommit
2509 # internal config: ui.allowemptycommit
2505 allowemptycommit = (wctx.branch() != wctx.p1().branch()
2510 allowemptycommit = (wctx.branch() != wctx.p1().branch()
2506 or extra.get('close') or merge or cctx.files()
2511 or extra.get('close') or merge or cctx.files()
2507 or self.ui.configbool('ui', 'allowemptycommit'))
2512 or self.ui.configbool('ui', 'allowemptycommit'))
2508 if not allowemptycommit:
2513 if not allowemptycommit:
2509 return None
2514 return None
2510
2515
2511 if merge and cctx.deleted():
2516 if merge and cctx.deleted():
2512 raise error.Abort(_("cannot commit merge with missing files"))
2517 raise error.Abort(_("cannot commit merge with missing files"))
2513
2518
2514 ms = mergemod.mergestate.read(self)
2519 ms = mergemod.mergestate.read(self)
2515 mergeutil.checkunresolved(ms)
2520 mergeutil.checkunresolved(ms)
2516
2521
2517 if editor:
2522 if editor:
2518 cctx._text = editor(self, cctx, subs)
2523 cctx._text = editor(self, cctx, subs)
2519 edited = (text != cctx._text)
2524 edited = (text != cctx._text)
2520
2525
2521 # Save commit message in case this transaction gets rolled back
2526 # Save commit message in case this transaction gets rolled back
2522 # (e.g. by a pretxncommit hook). Leave the content alone on
2527 # (e.g. by a pretxncommit hook). Leave the content alone on
2523 # the assumption that the user will use the same editor again.
2528 # the assumption that the user will use the same editor again.
2524 msgfn = self.savecommitmessage(cctx._text)
2529 msgfn = self.savecommitmessage(cctx._text)
2525
2530
2526 # commit subs and write new state
2531 # commit subs and write new state
2527 if subs:
2532 if subs:
2528 uipathfn = scmutil.getuipathfn(self)
2533 uipathfn = scmutil.getuipathfn(self)
2529 for s in sorted(commitsubs):
2534 for s in sorted(commitsubs):
2530 sub = wctx.sub(s)
2535 sub = wctx.sub(s)
2531 self.ui.status(_('committing subrepository %s\n') %
2536 self.ui.status(_('committing subrepository %s\n') %
2532 uipathfn(subrepoutil.subrelpath(sub)))
2537 uipathfn(subrepoutil.subrelpath(sub)))
2533 sr = sub.commit(cctx._text, user, date)
2538 sr = sub.commit(cctx._text, user, date)
2534 newstate[s] = (newstate[s][0], sr)
2539 newstate[s] = (newstate[s][0], sr)
2535 subrepoutil.writestate(self, newstate)
2540 subrepoutil.writestate(self, newstate)
2536
2541
2537 p1, p2 = self.dirstate.parents()
2542 p1, p2 = self.dirstate.parents()
2538 hookp1, hookp2 = hex(p1), (p2 != nullid and hex(p2) or '')
2543 hookp1, hookp2 = hex(p1), (p2 != nullid and hex(p2) or '')
2539 try:
2544 try:
2540 self.hook("precommit", throw=True, parent1=hookp1,
2545 self.hook("precommit", throw=True, parent1=hookp1,
2541 parent2=hookp2)
2546 parent2=hookp2)
2542 with self.transaction('commit'):
2547 with self.transaction('commit'):
2543 ret = self.commitctx(cctx, True)
2548 ret = self.commitctx(cctx, True)
2544 # update bookmarks, dirstate and mergestate
2549 # update bookmarks, dirstate and mergestate
2545 bookmarks.update(self, [p1, p2], ret)
2550 bookmarks.update(self, [p1, p2], ret)
2546 cctx.markcommitted(ret)
2551 cctx.markcommitted(ret)
2547 ms.reset()
2552 ms.reset()
2548 except: # re-raises
2553 except: # re-raises
2549 if edited:
2554 if edited:
2550 self.ui.write(
2555 self.ui.write(
2551 _('note: commit message saved in %s\n') % msgfn)
2556 _('note: commit message saved in %s\n') % msgfn)
2552 raise
2557 raise
2553
2558
2554 def commithook(node=hex(ret), parent1=hookp1, parent2=hookp2):
2559 def commithook(node=hex(ret), parent1=hookp1, parent2=hookp2):
2555 # hack for command that use a temporary commit (eg: histedit)
2560 # hack for command that use a temporary commit (eg: histedit)
2556 # temporary commit got stripped before hook release
2561 # temporary commit got stripped before hook release
2557 if self.changelog.hasnode(ret):
2562 if self.changelog.hasnode(ret):
2558 self.hook("commit", node=node, parent1=parent1,
2563 self.hook("commit", node=node, parent1=parent1,
2559 parent2=parent2)
2564 parent2=parent2)
2560 self._afterlock(commithook)
2565 self._afterlock(commithook)
2561 return ret
2566 return ret
2562
2567
2563 @unfilteredmethod
2568 @unfilteredmethod
2564 def commitctx(self, ctx, error=False):
2569 def commitctx(self, ctx, error=False):
2565 """Add a new revision to current repository.
2570 """Add a new revision to current repository.
2566 Revision information is passed via the context argument.
2571 Revision information is passed via the context argument.
2567
2572
2568 ctx.files() should list all files involved in this commit, i.e.
2573 ctx.files() should list all files involved in this commit, i.e.
2569 modified/added/removed files. On merge, it may be wider than the
2574 modified/added/removed files. On merge, it may be wider than the
2570 ctx.files() to be committed, since any file nodes derived directly
2575 ctx.files() to be committed, since any file nodes derived directly
2571 from p1 or p2 are excluded from the committed ctx.files().
2576 from p1 or p2 are excluded from the committed ctx.files().
2572 """
2577 """
2573
2578
2574 p1, p2 = ctx.p1(), ctx.p2()
2579 p1, p2 = ctx.p1(), ctx.p2()
2575 user = ctx.user()
2580 user = ctx.user()
2576
2581
2577 writecopiesto = self.ui.config('experimental', 'copies.write-to')
2582 writecopiesto = self.ui.config('experimental', 'copies.write-to')
2578 writefilecopymeta = writecopiesto != 'changeset-only'
2583 writefilecopymeta = writecopiesto != 'changeset-only'
2579 p1copies, p2copies = None, None
2584 p1copies, p2copies = None, None
2580 if writecopiesto in ('changeset-only', 'compatibility'):
2585 if writecopiesto in ('changeset-only', 'compatibility'):
2581 p1copies = ctx.p1copies()
2586 p1copies = ctx.p1copies()
2582 p2copies = ctx.p2copies()
2587 p2copies = ctx.p2copies()
2583 with self.lock(), self.transaction("commit") as tr:
2588 with self.lock(), self.transaction("commit") as tr:
2584 trp = weakref.proxy(tr)
2589 trp = weakref.proxy(tr)
2585
2590
2586 if ctx.manifestnode():
2591 if ctx.manifestnode():
2587 # reuse an existing manifest revision
2592 # reuse an existing manifest revision
2588 self.ui.debug('reusing known manifest\n')
2593 self.ui.debug('reusing known manifest\n')
2589 mn = ctx.manifestnode()
2594 mn = ctx.manifestnode()
2590 files = ctx.files()
2595 files = ctx.files()
2591 elif ctx.files():
2596 elif ctx.files():
2592 m1ctx = p1.manifestctx()
2597 m1ctx = p1.manifestctx()
2593 m2ctx = p2.manifestctx()
2598 m2ctx = p2.manifestctx()
2594 mctx = m1ctx.copy()
2599 mctx = m1ctx.copy()
2595
2600
2596 m = mctx.read()
2601 m = mctx.read()
2597 m1 = m1ctx.read()
2602 m1 = m1ctx.read()
2598 m2 = m2ctx.read()
2603 m2 = m2ctx.read()
2599
2604
2600 # check in files
2605 # check in files
2601 added = []
2606 added = []
2602 changed = []
2607 changed = []
2603 removed = list(ctx.removed())
2608 removed = list(ctx.removed())
2604 linkrev = len(self)
2609 linkrev = len(self)
2605 self.ui.note(_("committing files:\n"))
2610 self.ui.note(_("committing files:\n"))
2606 uipathfn = scmutil.getuipathfn(self)
2611 uipathfn = scmutil.getuipathfn(self)
2607 for f in sorted(ctx.modified() + ctx.added()):
2612 for f in sorted(ctx.modified() + ctx.added()):
2608 self.ui.note(uipathfn(f) + "\n")
2613 self.ui.note(uipathfn(f) + "\n")
2609 try:
2614 try:
2610 fctx = ctx[f]
2615 fctx = ctx[f]
2611 if fctx is None:
2616 if fctx is None:
2612 removed.append(f)
2617 removed.append(f)
2613 else:
2618 else:
2614 added.append(f)
2619 added.append(f)
2615 m[f] = self._filecommit(fctx, m1, m2, linkrev,
2620 m[f] = self._filecommit(fctx, m1, m2, linkrev,
2616 trp, changed,
2621 trp, changed,
2617 writefilecopymeta)
2622 writefilecopymeta)
2618 m.setflag(f, fctx.flags())
2623 m.setflag(f, fctx.flags())
2619 except OSError:
2624 except OSError:
2620 self.ui.warn(_("trouble committing %s!\n") %
2625 self.ui.warn(_("trouble committing %s!\n") %
2621 uipathfn(f))
2626 uipathfn(f))
2622 raise
2627 raise
2623 except IOError as inst:
2628 except IOError as inst:
2624 errcode = getattr(inst, 'errno', errno.ENOENT)
2629 errcode = getattr(inst, 'errno', errno.ENOENT)
2625 if error or errcode and errcode != errno.ENOENT:
2630 if error or errcode and errcode != errno.ENOENT:
2626 self.ui.warn(_("trouble committing %s!\n") %
2631 self.ui.warn(_("trouble committing %s!\n") %
2627 uipathfn(f))
2632 uipathfn(f))
2628 raise
2633 raise
2629
2634
2630 # update manifest
2635 # update manifest
2631 removed = [f for f in sorted(removed) if f in m1 or f in m2]
2636 removed = [f for f in sorted(removed) if f in m1 or f in m2]
2632 drop = [f for f in removed if f in m]
2637 drop = [f for f in removed if f in m]
2633 for f in drop:
2638 for f in drop:
2634 del m[f]
2639 del m[f]
2635 files = changed + removed
2640 files = changed + removed
2636 md = None
2641 md = None
2637 if not files:
2642 if not files:
2638 # if no "files" actually changed in terms of the changelog,
2643 # if no "files" actually changed in terms of the changelog,
2639 # try hard to detect unmodified manifest entry so that the
2644 # try hard to detect unmodified manifest entry so that the
2640 # exact same commit can be reproduced later on convert.
2645 # exact same commit can be reproduced later on convert.
2641 md = m1.diff(m, scmutil.matchfiles(self, ctx.files()))
2646 md = m1.diff(m, scmutil.matchfiles(self, ctx.files()))
2642 if not files and md:
2647 if not files and md:
2643 self.ui.debug('not reusing manifest (no file change in '
2648 self.ui.debug('not reusing manifest (no file change in '
2644 'changelog, but manifest differs)\n')
2649 'changelog, but manifest differs)\n')
2645 if files or md:
2650 if files or md:
2646 self.ui.note(_("committing manifest\n"))
2651 self.ui.note(_("committing manifest\n"))
2647 # we're using narrowmatch here since it's already applied at
2652 # we're using narrowmatch here since it's already applied at
2648 # other stages (such as dirstate.walk), so we're already
2653 # other stages (such as dirstate.walk), so we're already
2649 # ignoring things outside of narrowspec in most cases. The
2654 # ignoring things outside of narrowspec in most cases. The
2650 # one case where we might have files outside the narrowspec
2655 # one case where we might have files outside the narrowspec
2651 # at this point is merges, and we already error out in the
2656 # at this point is merges, and we already error out in the
2652 # case where the merge has files outside of the narrowspec,
2657 # case where the merge has files outside of the narrowspec,
2653 # so this is safe.
2658 # so this is safe.
2654 mn = mctx.write(trp, linkrev,
2659 mn = mctx.write(trp, linkrev,
2655 p1.manifestnode(), p2.manifestnode(),
2660 p1.manifestnode(), p2.manifestnode(),
2656 added, drop, match=self.narrowmatch())
2661 added, drop, match=self.narrowmatch())
2657 else:
2662 else:
2658 self.ui.debug('reusing manifest form p1 (listed files '
2663 self.ui.debug('reusing manifest form p1 (listed files '
2659 'actually unchanged)\n')
2664 'actually unchanged)\n')
2660 mn = p1.manifestnode()
2665 mn = p1.manifestnode()
2661 else:
2666 else:
2662 self.ui.debug('reusing manifest from p1 (no file change)\n')
2667 self.ui.debug('reusing manifest from p1 (no file change)\n')
2663 mn = p1.manifestnode()
2668 mn = p1.manifestnode()
2664 files = []
2669 files = []
2665
2670
2666 # update changelog
2671 # update changelog
2667 self.ui.note(_("committing changelog\n"))
2672 self.ui.note(_("committing changelog\n"))
2668 self.changelog.delayupdate(tr)
2673 self.changelog.delayupdate(tr)
2669 n = self.changelog.add(mn, files, ctx.description(),
2674 n = self.changelog.add(mn, files, ctx.description(),
2670 trp, p1.node(), p2.node(),
2675 trp, p1.node(), p2.node(),
2671 user, ctx.date(), ctx.extra().copy(),
2676 user, ctx.date(), ctx.extra().copy(),
2672 p1copies, p2copies)
2677 p1copies, p2copies)
2673 xp1, xp2 = p1.hex(), p2 and p2.hex() or ''
2678 xp1, xp2 = p1.hex(), p2 and p2.hex() or ''
2674 self.hook('pretxncommit', throw=True, node=hex(n), parent1=xp1,
2679 self.hook('pretxncommit', throw=True, node=hex(n), parent1=xp1,
2675 parent2=xp2)
2680 parent2=xp2)
2676 # set the new commit is proper phase
2681 # set the new commit is proper phase
2677 targetphase = subrepoutil.newcommitphase(self.ui, ctx)
2682 targetphase = subrepoutil.newcommitphase(self.ui, ctx)
2678 if targetphase:
2683 if targetphase:
2679 # retract boundary do not alter parent changeset.
2684 # retract boundary do not alter parent changeset.
2680 # if a parent have higher the resulting phase will
2685 # if a parent have higher the resulting phase will
2681 # be compliant anyway
2686 # be compliant anyway
2682 #
2687 #
2683 # if minimal phase was 0 we don't need to retract anything
2688 # if minimal phase was 0 we don't need to retract anything
2684 phases.registernew(self, tr, targetphase, [n])
2689 phases.registernew(self, tr, targetphase, [n])
2685 return n
2690 return n
2686
2691
2687 @unfilteredmethod
2692 @unfilteredmethod
2688 def destroying(self):
2693 def destroying(self):
2689 '''Inform the repository that nodes are about to be destroyed.
2694 '''Inform the repository that nodes are about to be destroyed.
2690 Intended for use by strip and rollback, so there's a common
2695 Intended for use by strip and rollback, so there's a common
2691 place for anything that has to be done before destroying history.
2696 place for anything that has to be done before destroying history.
2692
2697
2693 This is mostly useful for saving state that is in memory and waiting
2698 This is mostly useful for saving state that is in memory and waiting
2694 to be flushed when the current lock is released. Because a call to
2699 to be flushed when the current lock is released. Because a call to
2695 destroyed is imminent, the repo will be invalidated causing those
2700 destroyed is imminent, the repo will be invalidated causing those
2696 changes to stay in memory (waiting for the next unlock), or vanish
2701 changes to stay in memory (waiting for the next unlock), or vanish
2697 completely.
2702 completely.
2698 '''
2703 '''
2699 # When using the same lock to commit and strip, the phasecache is left
2704 # When using the same lock to commit and strip, the phasecache is left
2700 # dirty after committing. Then when we strip, the repo is invalidated,
2705 # dirty after committing. Then when we strip, the repo is invalidated,
2701 # causing those changes to disappear.
2706 # causing those changes to disappear.
2702 if '_phasecache' in vars(self):
2707 if '_phasecache' in vars(self):
2703 self._phasecache.write()
2708 self._phasecache.write()
2704
2709
2705 @unfilteredmethod
2710 @unfilteredmethod
2706 def destroyed(self):
2711 def destroyed(self):
2707 '''Inform the repository that nodes have been destroyed.
2712 '''Inform the repository that nodes have been destroyed.
2708 Intended for use by strip and rollback, so there's a common
2713 Intended for use by strip and rollback, so there's a common
2709 place for anything that has to be done after destroying history.
2714 place for anything that has to be done after destroying history.
2710 '''
2715 '''
2711 # When one tries to:
2716 # When one tries to:
2712 # 1) destroy nodes thus calling this method (e.g. strip)
2717 # 1) destroy nodes thus calling this method (e.g. strip)
2713 # 2) use phasecache somewhere (e.g. commit)
2718 # 2) use phasecache somewhere (e.g. commit)
2714 #
2719 #
2715 # then 2) will fail because the phasecache contains nodes that were
2720 # then 2) will fail because the phasecache contains nodes that were
2716 # removed. We can either remove phasecache from the filecache,
2721 # removed. We can either remove phasecache from the filecache,
2717 # causing it to reload next time it is accessed, or simply filter
2722 # causing it to reload next time it is accessed, or simply filter
2718 # the removed nodes now and write the updated cache.
2723 # the removed nodes now and write the updated cache.
2719 self._phasecache.filterunknown(self)
2724 self._phasecache.filterunknown(self)
2720 self._phasecache.write()
2725 self._phasecache.write()
2721
2726
2722 # refresh all repository caches
2727 # refresh all repository caches
2723 self.updatecaches()
2728 self.updatecaches()
2724
2729
2725 # Ensure the persistent tag cache is updated. Doing it now
2730 # Ensure the persistent tag cache is updated. Doing it now
2726 # means that the tag cache only has to worry about destroyed
2731 # means that the tag cache only has to worry about destroyed
2727 # heads immediately after a strip/rollback. That in turn
2732 # heads immediately after a strip/rollback. That in turn
2728 # guarantees that "cachetip == currenttip" (comparing both rev
2733 # guarantees that "cachetip == currenttip" (comparing both rev
2729 # and node) always means no nodes have been added or destroyed.
2734 # and node) always means no nodes have been added or destroyed.
2730
2735
2731 # XXX this is suboptimal when qrefresh'ing: we strip the current
2736 # XXX this is suboptimal when qrefresh'ing: we strip the current
2732 # head, refresh the tag cache, then immediately add a new head.
2737 # head, refresh the tag cache, then immediately add a new head.
2733 # But I think doing it this way is necessary for the "instant
2738 # But I think doing it this way is necessary for the "instant
2734 # tag cache retrieval" case to work.
2739 # tag cache retrieval" case to work.
2735 self.invalidate()
2740 self.invalidate()
2736
2741
2737 def status(self, node1='.', node2=None, match=None,
2742 def status(self, node1='.', node2=None, match=None,
2738 ignored=False, clean=False, unknown=False,
2743 ignored=False, clean=False, unknown=False,
2739 listsubrepos=False):
2744 listsubrepos=False):
2740 '''a convenience method that calls node1.status(node2)'''
2745 '''a convenience method that calls node1.status(node2)'''
2741 return self[node1].status(node2, match, ignored, clean, unknown,
2746 return self[node1].status(node2, match, ignored, clean, unknown,
2742 listsubrepos)
2747 listsubrepos)
2743
2748
2744 def addpostdsstatus(self, ps):
2749 def addpostdsstatus(self, ps):
2745 """Add a callback to run within the wlock, at the point at which status
2750 """Add a callback to run within the wlock, at the point at which status
2746 fixups happen.
2751 fixups happen.
2747
2752
2748 On status completion, callback(wctx, status) will be called with the
2753 On status completion, callback(wctx, status) will be called with the
2749 wlock held, unless the dirstate has changed from underneath or the wlock
2754 wlock held, unless the dirstate has changed from underneath or the wlock
2750 couldn't be grabbed.
2755 couldn't be grabbed.
2751
2756
2752 Callbacks should not capture and use a cached copy of the dirstate --
2757 Callbacks should not capture and use a cached copy of the dirstate --
2753 it might change in the meanwhile. Instead, they should access the
2758 it might change in the meanwhile. Instead, they should access the
2754 dirstate via wctx.repo().dirstate.
2759 dirstate via wctx.repo().dirstate.
2755
2760
2756 This list is emptied out after each status run -- extensions should
2761 This list is emptied out after each status run -- extensions should
2757 make sure it adds to this list each time dirstate.status is called.
2762 make sure it adds to this list each time dirstate.status is called.
2758 Extensions should also make sure they don't call this for statuses
2763 Extensions should also make sure they don't call this for statuses
2759 that don't involve the dirstate.
2764 that don't involve the dirstate.
2760 """
2765 """
2761
2766
2762 # The list is located here for uniqueness reasons -- it is actually
2767 # The list is located here for uniqueness reasons -- it is actually
2763 # managed by the workingctx, but that isn't unique per-repo.
2768 # managed by the workingctx, but that isn't unique per-repo.
2764 self._postdsstatus.append(ps)
2769 self._postdsstatus.append(ps)
2765
2770
2766 def postdsstatus(self):
2771 def postdsstatus(self):
2767 """Used by workingctx to get the list of post-dirstate-status hooks."""
2772 """Used by workingctx to get the list of post-dirstate-status hooks."""
2768 return self._postdsstatus
2773 return self._postdsstatus
2769
2774
2770 def clearpostdsstatus(self):
2775 def clearpostdsstatus(self):
2771 """Used by workingctx to clear post-dirstate-status hooks."""
2776 """Used by workingctx to clear post-dirstate-status hooks."""
2772 del self._postdsstatus[:]
2777 del self._postdsstatus[:]
2773
2778
2774 def heads(self, start=None):
2779 def heads(self, start=None):
2775 if start is None:
2780 if start is None:
2776 cl = self.changelog
2781 cl = self.changelog
2777 headrevs = reversed(cl.headrevs())
2782 headrevs = reversed(cl.headrevs())
2778 return [cl.node(rev) for rev in headrevs]
2783 return [cl.node(rev) for rev in headrevs]
2779
2784
2780 heads = self.changelog.heads(start)
2785 heads = self.changelog.heads(start)
2781 # sort the output in rev descending order
2786 # sort the output in rev descending order
2782 return sorted(heads, key=self.changelog.rev, reverse=True)
2787 return sorted(heads, key=self.changelog.rev, reverse=True)
2783
2788
2784 def branchheads(self, branch=None, start=None, closed=False):
2789 def branchheads(self, branch=None, start=None, closed=False):
2785 '''return a (possibly filtered) list of heads for the given branch
2790 '''return a (possibly filtered) list of heads for the given branch
2786
2791
2787 Heads are returned in topological order, from newest to oldest.
2792 Heads are returned in topological order, from newest to oldest.
2788 If branch is None, use the dirstate branch.
2793 If branch is None, use the dirstate branch.
2789 If start is not None, return only heads reachable from start.
2794 If start is not None, return only heads reachable from start.
2790 If closed is True, return heads that are marked as closed as well.
2795 If closed is True, return heads that are marked as closed as well.
2791 '''
2796 '''
2792 if branch is None:
2797 if branch is None:
2793 branch = self[None].branch()
2798 branch = self[None].branch()
2794 branches = self.branchmap()
2799 branches = self.branchmap()
2795 if not branches.hasbranch(branch):
2800 if not branches.hasbranch(branch):
2796 return []
2801 return []
2797 # the cache returns heads ordered lowest to highest
2802 # the cache returns heads ordered lowest to highest
2798 bheads = list(reversed(branches.branchheads(branch, closed=closed)))
2803 bheads = list(reversed(branches.branchheads(branch, closed=closed)))
2799 if start is not None:
2804 if start is not None:
2800 # filter out the heads that cannot be reached from startrev
2805 # filter out the heads that cannot be reached from startrev
2801 fbheads = set(self.changelog.nodesbetween([start], bheads)[2])
2806 fbheads = set(self.changelog.nodesbetween([start], bheads)[2])
2802 bheads = [h for h in bheads if h in fbheads]
2807 bheads = [h for h in bheads if h in fbheads]
2803 return bheads
2808 return bheads
2804
2809
2805 def branches(self, nodes):
2810 def branches(self, nodes):
2806 if not nodes:
2811 if not nodes:
2807 nodes = [self.changelog.tip()]
2812 nodes = [self.changelog.tip()]
2808 b = []
2813 b = []
2809 for n in nodes:
2814 for n in nodes:
2810 t = n
2815 t = n
2811 while True:
2816 while True:
2812 p = self.changelog.parents(n)
2817 p = self.changelog.parents(n)
2813 if p[1] != nullid or p[0] == nullid:
2818 if p[1] != nullid or p[0] == nullid:
2814 b.append((t, n, p[0], p[1]))
2819 b.append((t, n, p[0], p[1]))
2815 break
2820 break
2816 n = p[0]
2821 n = p[0]
2817 return b
2822 return b
2818
2823
2819 def between(self, pairs):
2824 def between(self, pairs):
2820 r = []
2825 r = []
2821
2826
2822 for top, bottom in pairs:
2827 for top, bottom in pairs:
2823 n, l, i = top, [], 0
2828 n, l, i = top, [], 0
2824 f = 1
2829 f = 1
2825
2830
2826 while n != bottom and n != nullid:
2831 while n != bottom and n != nullid:
2827 p = self.changelog.parents(n)[0]
2832 p = self.changelog.parents(n)[0]
2828 if i == f:
2833 if i == f:
2829 l.append(n)
2834 l.append(n)
2830 f = f * 2
2835 f = f * 2
2831 n = p
2836 n = p
2832 i += 1
2837 i += 1
2833
2838
2834 r.append(l)
2839 r.append(l)
2835
2840
2836 return r
2841 return r
2837
2842
2838 def checkpush(self, pushop):
2843 def checkpush(self, pushop):
2839 """Extensions can override this function if additional checks have
2844 """Extensions can override this function if additional checks have
2840 to be performed before pushing, or call it if they override push
2845 to be performed before pushing, or call it if they override push
2841 command.
2846 command.
2842 """
2847 """
2843
2848
2844 @unfilteredpropertycache
2849 @unfilteredpropertycache
2845 def prepushoutgoinghooks(self):
2850 def prepushoutgoinghooks(self):
2846 """Return util.hooks consists of a pushop with repo, remote, outgoing
2851 """Return util.hooks consists of a pushop with repo, remote, outgoing
2847 methods, which are called before pushing changesets.
2852 methods, which are called before pushing changesets.
2848 """
2853 """
2849 return util.hooks()
2854 return util.hooks()
2850
2855
2851 def pushkey(self, namespace, key, old, new):
2856 def pushkey(self, namespace, key, old, new):
2852 try:
2857 try:
2853 tr = self.currenttransaction()
2858 tr = self.currenttransaction()
2854 hookargs = {}
2859 hookargs = {}
2855 if tr is not None:
2860 if tr is not None:
2856 hookargs.update(tr.hookargs)
2861 hookargs.update(tr.hookargs)
2857 hookargs = pycompat.strkwargs(hookargs)
2862 hookargs = pycompat.strkwargs(hookargs)
2858 hookargs[r'namespace'] = namespace
2863 hookargs[r'namespace'] = namespace
2859 hookargs[r'key'] = key
2864 hookargs[r'key'] = key
2860 hookargs[r'old'] = old
2865 hookargs[r'old'] = old
2861 hookargs[r'new'] = new
2866 hookargs[r'new'] = new
2862 self.hook('prepushkey', throw=True, **hookargs)
2867 self.hook('prepushkey', throw=True, **hookargs)
2863 except error.HookAbort as exc:
2868 except error.HookAbort as exc:
2864 self.ui.write_err(_("pushkey-abort: %s\n") % exc)
2869 self.ui.write_err(_("pushkey-abort: %s\n") % exc)
2865 if exc.hint:
2870 if exc.hint:
2866 self.ui.write_err(_("(%s)\n") % exc.hint)
2871 self.ui.write_err(_("(%s)\n") % exc.hint)
2867 return False
2872 return False
2868 self.ui.debug('pushing key for "%s:%s"\n' % (namespace, key))
2873 self.ui.debug('pushing key for "%s:%s"\n' % (namespace, key))
2869 ret = pushkey.push(self, namespace, key, old, new)
2874 ret = pushkey.push(self, namespace, key, old, new)
2870 def runhook():
2875 def runhook():
2871 self.hook('pushkey', namespace=namespace, key=key, old=old, new=new,
2876 self.hook('pushkey', namespace=namespace, key=key, old=old, new=new,
2872 ret=ret)
2877 ret=ret)
2873 self._afterlock(runhook)
2878 self._afterlock(runhook)
2874 return ret
2879 return ret
2875
2880
2876 def listkeys(self, namespace):
2881 def listkeys(self, namespace):
2877 self.hook('prelistkeys', throw=True, namespace=namespace)
2882 self.hook('prelistkeys', throw=True, namespace=namespace)
2878 self.ui.debug('listing keys for "%s"\n' % namespace)
2883 self.ui.debug('listing keys for "%s"\n' % namespace)
2879 values = pushkey.list(self, namespace)
2884 values = pushkey.list(self, namespace)
2880 self.hook('listkeys', namespace=namespace, values=values)
2885 self.hook('listkeys', namespace=namespace, values=values)
2881 return values
2886 return values
2882
2887
2883 def debugwireargs(self, one, two, three=None, four=None, five=None):
2888 def debugwireargs(self, one, two, three=None, four=None, five=None):
2884 '''used to test argument passing over the wire'''
2889 '''used to test argument passing over the wire'''
2885 return "%s %s %s %s %s" % (one, two, pycompat.bytestr(three),
2890 return "%s %s %s %s %s" % (one, two, pycompat.bytestr(three),
2886 pycompat.bytestr(four),
2891 pycompat.bytestr(four),
2887 pycompat.bytestr(five))
2892 pycompat.bytestr(five))
2888
2893
2889 def savecommitmessage(self, text):
2894 def savecommitmessage(self, text):
2890 fp = self.vfs('last-message.txt', 'wb')
2895 fp = self.vfs('last-message.txt', 'wb')
2891 try:
2896 try:
2892 fp.write(text)
2897 fp.write(text)
2893 finally:
2898 finally:
2894 fp.close()
2899 fp.close()
2895 return self.pathto(fp.name[len(self.root) + 1:])
2900 return self.pathto(fp.name[len(self.root) + 1:])
2896
2901
2897 # used to avoid circular references so destructors work
2902 # used to avoid circular references so destructors work
2898 def aftertrans(files):
2903 def aftertrans(files):
2899 renamefiles = [tuple(t) for t in files]
2904 renamefiles = [tuple(t) for t in files]
2900 def a():
2905 def a():
2901 for vfs, src, dest in renamefiles:
2906 for vfs, src, dest in renamefiles:
2902 # if src and dest refer to a same file, vfs.rename is a no-op,
2907 # if src and dest refer to a same file, vfs.rename is a no-op,
2903 # leaving both src and dest on disk. delete dest to make sure
2908 # leaving both src and dest on disk. delete dest to make sure
2904 # the rename couldn't be such a no-op.
2909 # the rename couldn't be such a no-op.
2905 vfs.tryunlink(dest)
2910 vfs.tryunlink(dest)
2906 try:
2911 try:
2907 vfs.rename(src, dest)
2912 vfs.rename(src, dest)
2908 except OSError: # journal file does not yet exist
2913 except OSError: # journal file does not yet exist
2909 pass
2914 pass
2910 return a
2915 return a
2911
2916
2912 def undoname(fn):
2917 def undoname(fn):
2913 base, name = os.path.split(fn)
2918 base, name = os.path.split(fn)
2914 assert name.startswith('journal')
2919 assert name.startswith('journal')
2915 return os.path.join(base, name.replace('journal', 'undo', 1))
2920 return os.path.join(base, name.replace('journal', 'undo', 1))
2916
2921
2917 def instance(ui, path, create, intents=None, createopts=None):
2922 def instance(ui, path, create, intents=None, createopts=None):
2918 localpath = util.urllocalpath(path)
2923 localpath = util.urllocalpath(path)
2919 if create:
2924 if create:
2920 createrepository(ui, localpath, createopts=createopts)
2925 createrepository(ui, localpath, createopts=createopts)
2921
2926
2922 return makelocalrepository(ui, localpath, intents=intents)
2927 return makelocalrepository(ui, localpath, intents=intents)
2923
2928
2924 def islocal(path):
2929 def islocal(path):
2925 return True
2930 return True
2926
2931
2927 def defaultcreateopts(ui, createopts=None):
2932 def defaultcreateopts(ui, createopts=None):
2928 """Populate the default creation options for a repository.
2933 """Populate the default creation options for a repository.
2929
2934
2930 A dictionary of explicitly requested creation options can be passed
2935 A dictionary of explicitly requested creation options can be passed
2931 in. Missing keys will be populated.
2936 in. Missing keys will be populated.
2932 """
2937 """
2933 createopts = dict(createopts or {})
2938 createopts = dict(createopts or {})
2934
2939
2935 if 'backend' not in createopts:
2940 if 'backend' not in createopts:
2936 # experimental config: storage.new-repo-backend
2941 # experimental config: storage.new-repo-backend
2937 createopts['backend'] = ui.config('storage', 'new-repo-backend')
2942 createopts['backend'] = ui.config('storage', 'new-repo-backend')
2938
2943
2939 return createopts
2944 return createopts
2940
2945
2941 def newreporequirements(ui, createopts):
2946 def newreporequirements(ui, createopts):
2942 """Determine the set of requirements for a new local repository.
2947 """Determine the set of requirements for a new local repository.
2943
2948
2944 Extensions can wrap this function to specify custom requirements for
2949 Extensions can wrap this function to specify custom requirements for
2945 new repositories.
2950 new repositories.
2946 """
2951 """
2947 # If the repo is being created from a shared repository, we copy
2952 # If the repo is being created from a shared repository, we copy
2948 # its requirements.
2953 # its requirements.
2949 if 'sharedrepo' in createopts:
2954 if 'sharedrepo' in createopts:
2950 requirements = set(createopts['sharedrepo'].requirements)
2955 requirements = set(createopts['sharedrepo'].requirements)
2951 if createopts.get('sharedrelative'):
2956 if createopts.get('sharedrelative'):
2952 requirements.add('relshared')
2957 requirements.add('relshared')
2953 else:
2958 else:
2954 requirements.add('shared')
2959 requirements.add('shared')
2955
2960
2956 return requirements
2961 return requirements
2957
2962
2958 if 'backend' not in createopts:
2963 if 'backend' not in createopts:
2959 raise error.ProgrammingError('backend key not present in createopts; '
2964 raise error.ProgrammingError('backend key not present in createopts; '
2960 'was defaultcreateopts() called?')
2965 'was defaultcreateopts() called?')
2961
2966
2962 if createopts['backend'] != 'revlogv1':
2967 if createopts['backend'] != 'revlogv1':
2963 raise error.Abort(_('unable to determine repository requirements for '
2968 raise error.Abort(_('unable to determine repository requirements for '
2964 'storage backend: %s') % createopts['backend'])
2969 'storage backend: %s') % createopts['backend'])
2965
2970
2966 requirements = {'revlogv1'}
2971 requirements = {'revlogv1'}
2967 if ui.configbool('format', 'usestore'):
2972 if ui.configbool('format', 'usestore'):
2968 requirements.add('store')
2973 requirements.add('store')
2969 if ui.configbool('format', 'usefncache'):
2974 if ui.configbool('format', 'usefncache'):
2970 requirements.add('fncache')
2975 requirements.add('fncache')
2971 if ui.configbool('format', 'dotencode'):
2976 if ui.configbool('format', 'dotencode'):
2972 requirements.add('dotencode')
2977 requirements.add('dotencode')
2973
2978
2974 compengine = ui.config('format', 'revlog-compression')
2979 compengine = ui.config('format', 'revlog-compression')
2975 if compengine not in util.compengines:
2980 if compengine not in util.compengines:
2976 raise error.Abort(_('compression engine %s defined by '
2981 raise error.Abort(_('compression engine %s defined by '
2977 'format.revlog-compression not available') %
2982 'format.revlog-compression not available') %
2978 compengine,
2983 compengine,
2979 hint=_('run "hg debuginstall" to list available '
2984 hint=_('run "hg debuginstall" to list available '
2980 'compression engines'))
2985 'compression engines'))
2981
2986
2982 # zlib is the historical default and doesn't need an explicit requirement.
2987 # zlib is the historical default and doesn't need an explicit requirement.
2983 elif compengine == 'zstd':
2988 elif compengine == 'zstd':
2984 requirements.add('revlog-compression-zstd')
2989 requirements.add('revlog-compression-zstd')
2985 elif compengine != 'zlib':
2990 elif compengine != 'zlib':
2986 requirements.add('exp-compression-%s' % compengine)
2991 requirements.add('exp-compression-%s' % compengine)
2987
2992
2988 if scmutil.gdinitconfig(ui):
2993 if scmutil.gdinitconfig(ui):
2989 requirements.add('generaldelta')
2994 requirements.add('generaldelta')
2990 if ui.configbool('format', 'sparse-revlog'):
2995 if ui.configbool('format', 'sparse-revlog'):
2991 requirements.add(SPARSEREVLOG_REQUIREMENT)
2996 requirements.add(SPARSEREVLOG_REQUIREMENT)
2992 if ui.configbool('experimental', 'treemanifest'):
2997 if ui.configbool('experimental', 'treemanifest'):
2993 requirements.add('treemanifest')
2998 requirements.add('treemanifest')
2994
2999
2995 revlogv2 = ui.config('experimental', 'revlogv2')
3000 revlogv2 = ui.config('experimental', 'revlogv2')
2996 if revlogv2 == 'enable-unstable-format-and-corrupt-my-data':
3001 if revlogv2 == 'enable-unstable-format-and-corrupt-my-data':
2997 requirements.remove('revlogv1')
3002 requirements.remove('revlogv1')
2998 # generaldelta is implied by revlogv2.
3003 # generaldelta is implied by revlogv2.
2999 requirements.discard('generaldelta')
3004 requirements.discard('generaldelta')
3000 requirements.add(REVLOGV2_REQUIREMENT)
3005 requirements.add(REVLOGV2_REQUIREMENT)
3001 # experimental config: format.internal-phase
3006 # experimental config: format.internal-phase
3002 if ui.configbool('format', 'internal-phase'):
3007 if ui.configbool('format', 'internal-phase'):
3003 requirements.add('internal-phase')
3008 requirements.add('internal-phase')
3004
3009
3005 if createopts.get('narrowfiles'):
3010 if createopts.get('narrowfiles'):
3006 requirements.add(repository.NARROW_REQUIREMENT)
3011 requirements.add(repository.NARROW_REQUIREMENT)
3007
3012
3008 if createopts.get('lfs'):
3013 if createopts.get('lfs'):
3009 requirements.add('lfs')
3014 requirements.add('lfs')
3010
3015
3011 return requirements
3016 return requirements
3012
3017
3013 def filterknowncreateopts(ui, createopts):
3018 def filterknowncreateopts(ui, createopts):
3014 """Filters a dict of repo creation options against options that are known.
3019 """Filters a dict of repo creation options against options that are known.
3015
3020
3016 Receives a dict of repo creation options and returns a dict of those
3021 Receives a dict of repo creation options and returns a dict of those
3017 options that we don't know how to handle.
3022 options that we don't know how to handle.
3018
3023
3019 This function is called as part of repository creation. If the
3024 This function is called as part of repository creation. If the
3020 returned dict contains any items, repository creation will not
3025 returned dict contains any items, repository creation will not
3021 be allowed, as it means there was a request to create a repository
3026 be allowed, as it means there was a request to create a repository
3022 with options not recognized by loaded code.
3027 with options not recognized by loaded code.
3023
3028
3024 Extensions can wrap this function to filter out creation options
3029 Extensions can wrap this function to filter out creation options
3025 they know how to handle.
3030 they know how to handle.
3026 """
3031 """
3027 known = {
3032 known = {
3028 'backend',
3033 'backend',
3029 'lfs',
3034 'lfs',
3030 'narrowfiles',
3035 'narrowfiles',
3031 'sharedrepo',
3036 'sharedrepo',
3032 'sharedrelative',
3037 'sharedrelative',
3033 'shareditems',
3038 'shareditems',
3034 'shallowfilestore',
3039 'shallowfilestore',
3035 }
3040 }
3036
3041
3037 return {k: v for k, v in createopts.items() if k not in known}
3042 return {k: v for k, v in createopts.items() if k not in known}
3038
3043
3039 def createrepository(ui, path, createopts=None):
3044 def createrepository(ui, path, createopts=None):
3040 """Create a new repository in a vfs.
3045 """Create a new repository in a vfs.
3041
3046
3042 ``path`` path to the new repo's working directory.
3047 ``path`` path to the new repo's working directory.
3043 ``createopts`` options for the new repository.
3048 ``createopts`` options for the new repository.
3044
3049
3045 The following keys for ``createopts`` are recognized:
3050 The following keys for ``createopts`` are recognized:
3046
3051
3047 backend
3052 backend
3048 The storage backend to use.
3053 The storage backend to use.
3049 lfs
3054 lfs
3050 Repository will be created with ``lfs`` requirement. The lfs extension
3055 Repository will be created with ``lfs`` requirement. The lfs extension
3051 will automatically be loaded when the repository is accessed.
3056 will automatically be loaded when the repository is accessed.
3052 narrowfiles
3057 narrowfiles
3053 Set up repository to support narrow file storage.
3058 Set up repository to support narrow file storage.
3054 sharedrepo
3059 sharedrepo
3055 Repository object from which storage should be shared.
3060 Repository object from which storage should be shared.
3056 sharedrelative
3061 sharedrelative
3057 Boolean indicating if the path to the shared repo should be
3062 Boolean indicating if the path to the shared repo should be
3058 stored as relative. By default, the pointer to the "parent" repo
3063 stored as relative. By default, the pointer to the "parent" repo
3059 is stored as an absolute path.
3064 is stored as an absolute path.
3060 shareditems
3065 shareditems
3061 Set of items to share to the new repository (in addition to storage).
3066 Set of items to share to the new repository (in addition to storage).
3062 shallowfilestore
3067 shallowfilestore
3063 Indicates that storage for files should be shallow (not all ancestor
3068 Indicates that storage for files should be shallow (not all ancestor
3064 revisions are known).
3069 revisions are known).
3065 """
3070 """
3066 createopts = defaultcreateopts(ui, createopts=createopts)
3071 createopts = defaultcreateopts(ui, createopts=createopts)
3067
3072
3068 unknownopts = filterknowncreateopts(ui, createopts)
3073 unknownopts = filterknowncreateopts(ui, createopts)
3069
3074
3070 if not isinstance(unknownopts, dict):
3075 if not isinstance(unknownopts, dict):
3071 raise error.ProgrammingError('filterknowncreateopts() did not return '
3076 raise error.ProgrammingError('filterknowncreateopts() did not return '
3072 'a dict')
3077 'a dict')
3073
3078
3074 if unknownopts:
3079 if unknownopts:
3075 raise error.Abort(_('unable to create repository because of unknown '
3080 raise error.Abort(_('unable to create repository because of unknown '
3076 'creation option: %s') %
3081 'creation option: %s') %
3077 ', '.join(sorted(unknownopts)),
3082 ', '.join(sorted(unknownopts)),
3078 hint=_('is a required extension not loaded?'))
3083 hint=_('is a required extension not loaded?'))
3079
3084
3080 requirements = newreporequirements(ui, createopts=createopts)
3085 requirements = newreporequirements(ui, createopts=createopts)
3081
3086
3082 wdirvfs = vfsmod.vfs(path, expandpath=True, realpath=True)
3087 wdirvfs = vfsmod.vfs(path, expandpath=True, realpath=True)
3083
3088
3084 hgvfs = vfsmod.vfs(wdirvfs.join(b'.hg'))
3089 hgvfs = vfsmod.vfs(wdirvfs.join(b'.hg'))
3085 if hgvfs.exists():
3090 if hgvfs.exists():
3086 raise error.RepoError(_('repository %s already exists') % path)
3091 raise error.RepoError(_('repository %s already exists') % path)
3087
3092
3088 if 'sharedrepo' in createopts:
3093 if 'sharedrepo' in createopts:
3089 sharedpath = createopts['sharedrepo'].sharedpath
3094 sharedpath = createopts['sharedrepo'].sharedpath
3090
3095
3091 if createopts.get('sharedrelative'):
3096 if createopts.get('sharedrelative'):
3092 try:
3097 try:
3093 sharedpath = os.path.relpath(sharedpath, hgvfs.base)
3098 sharedpath = os.path.relpath(sharedpath, hgvfs.base)
3094 except (IOError, ValueError) as e:
3099 except (IOError, ValueError) as e:
3095 # ValueError is raised on Windows if the drive letters differ
3100 # ValueError is raised on Windows if the drive letters differ
3096 # on each path.
3101 # on each path.
3097 raise error.Abort(_('cannot calculate relative path'),
3102 raise error.Abort(_('cannot calculate relative path'),
3098 hint=stringutil.forcebytestr(e))
3103 hint=stringutil.forcebytestr(e))
3099
3104
3100 if not wdirvfs.exists():
3105 if not wdirvfs.exists():
3101 wdirvfs.makedirs()
3106 wdirvfs.makedirs()
3102
3107
3103 hgvfs.makedir(notindexed=True)
3108 hgvfs.makedir(notindexed=True)
3104 if 'sharedrepo' not in createopts:
3109 if 'sharedrepo' not in createopts:
3105 hgvfs.mkdir(b'cache')
3110 hgvfs.mkdir(b'cache')
3106 hgvfs.mkdir(b'wcache')
3111 hgvfs.mkdir(b'wcache')
3107
3112
3108 if b'store' in requirements and 'sharedrepo' not in createopts:
3113 if b'store' in requirements and 'sharedrepo' not in createopts:
3109 hgvfs.mkdir(b'store')
3114 hgvfs.mkdir(b'store')
3110
3115
3111 # We create an invalid changelog outside the store so very old
3116 # We create an invalid changelog outside the store so very old
3112 # Mercurial versions (which didn't know about the requirements
3117 # Mercurial versions (which didn't know about the requirements
3113 # file) encounter an error on reading the changelog. This
3118 # file) encounter an error on reading the changelog. This
3114 # effectively locks out old clients and prevents them from
3119 # effectively locks out old clients and prevents them from
3115 # mucking with a repo in an unknown format.
3120 # mucking with a repo in an unknown format.
3116 #
3121 #
3117 # The revlog header has version 2, which won't be recognized by
3122 # The revlog header has version 2, which won't be recognized by
3118 # such old clients.
3123 # such old clients.
3119 hgvfs.append(b'00changelog.i',
3124 hgvfs.append(b'00changelog.i',
3120 b'\0\0\0\2 dummy changelog to prevent using the old repo '
3125 b'\0\0\0\2 dummy changelog to prevent using the old repo '
3121 b'layout')
3126 b'layout')
3122
3127
3123 scmutil.writerequires(hgvfs, requirements)
3128 scmutil.writerequires(hgvfs, requirements)
3124
3129
3125 # Write out file telling readers where to find the shared store.
3130 # Write out file telling readers where to find the shared store.
3126 if 'sharedrepo' in createopts:
3131 if 'sharedrepo' in createopts:
3127 hgvfs.write(b'sharedpath', sharedpath)
3132 hgvfs.write(b'sharedpath', sharedpath)
3128
3133
3129 if createopts.get('shareditems'):
3134 if createopts.get('shareditems'):
3130 shared = b'\n'.join(sorted(createopts['shareditems'])) + b'\n'
3135 shared = b'\n'.join(sorted(createopts['shareditems'])) + b'\n'
3131 hgvfs.write(b'shared', shared)
3136 hgvfs.write(b'shared', shared)
3132
3137
3133 def poisonrepository(repo):
3138 def poisonrepository(repo):
3134 """Poison a repository instance so it can no longer be used."""
3139 """Poison a repository instance so it can no longer be used."""
3135 # Perform any cleanup on the instance.
3140 # Perform any cleanup on the instance.
3136 repo.close()
3141 repo.close()
3137
3142
3138 # Our strategy is to replace the type of the object with one that
3143 # Our strategy is to replace the type of the object with one that
3139 # has all attribute lookups result in error.
3144 # has all attribute lookups result in error.
3140 #
3145 #
3141 # But we have to allow the close() method because some constructors
3146 # But we have to allow the close() method because some constructors
3142 # of repos call close() on repo references.
3147 # of repos call close() on repo references.
3143 class poisonedrepository(object):
3148 class poisonedrepository(object):
3144 def __getattribute__(self, item):
3149 def __getattribute__(self, item):
3145 if item == r'close':
3150 if item == r'close':
3146 return object.__getattribute__(self, item)
3151 return object.__getattribute__(self, item)
3147
3152
3148 raise error.ProgrammingError('repo instances should not be used '
3153 raise error.ProgrammingError('repo instances should not be used '
3149 'after unshare')
3154 'after unshare')
3150
3155
3151 def close(self):
3156 def close(self):
3152 pass
3157 pass
3153
3158
3154 # We may have a repoview, which intercepts __setattr__. So be sure
3159 # We may have a repoview, which intercepts __setattr__. So be sure
3155 # we operate at the lowest level possible.
3160 # we operate at the lowest level possible.
3156 object.__setattr__(repo, r'__class__', poisonedrepository)
3161 object.__setattr__(repo, r'__class__', poisonedrepository)
General Comments 0
You need to be logged in to leave comments. Login now