##// END OF EJS Templates
pull: move bookmark pulling into its own function...
Pierre-Yves David -
r22654:02e0a574 default
parent child Browse files
Show More
@@ -1,1198 +1,1213 b''
1 # exchange.py - utility to exchange data between repos.
1 # exchange.py - utility to exchange data between repos.
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 i18n import _
8 from i18n import _
9 from node import hex, nullid
9 from node import hex, nullid
10 import errno, urllib
10 import errno, urllib
11 import util, scmutil, changegroup, base85, error
11 import util, scmutil, changegroup, base85, error
12 import discovery, phases, obsolete, bookmarks as bookmod, bundle2, pushkey
12 import discovery, phases, obsolete, bookmarks as bookmod, bundle2, pushkey
13
13
14 def readbundle(ui, fh, fname, vfs=None):
14 def readbundle(ui, fh, fname, vfs=None):
15 header = changegroup.readexactly(fh, 4)
15 header = changegroup.readexactly(fh, 4)
16
16
17 alg = None
17 alg = None
18 if not fname:
18 if not fname:
19 fname = "stream"
19 fname = "stream"
20 if not header.startswith('HG') and header.startswith('\0'):
20 if not header.startswith('HG') and header.startswith('\0'):
21 fh = changegroup.headerlessfixup(fh, header)
21 fh = changegroup.headerlessfixup(fh, header)
22 header = "HG10"
22 header = "HG10"
23 alg = 'UN'
23 alg = 'UN'
24 elif vfs:
24 elif vfs:
25 fname = vfs.join(fname)
25 fname = vfs.join(fname)
26
26
27 magic, version = header[0:2], header[2:4]
27 magic, version = header[0:2], header[2:4]
28
28
29 if magic != 'HG':
29 if magic != 'HG':
30 raise util.Abort(_('%s: not a Mercurial bundle') % fname)
30 raise util.Abort(_('%s: not a Mercurial bundle') % fname)
31 if version == '10':
31 if version == '10':
32 if alg is None:
32 if alg is None:
33 alg = changegroup.readexactly(fh, 2)
33 alg = changegroup.readexactly(fh, 2)
34 return changegroup.cg1unpacker(fh, alg)
34 return changegroup.cg1unpacker(fh, alg)
35 elif version == '2X':
35 elif version == '2X':
36 return bundle2.unbundle20(ui, fh, header=magic + version)
36 return bundle2.unbundle20(ui, fh, header=magic + version)
37 else:
37 else:
38 raise util.Abort(_('%s: unknown bundle version %s') % (fname, version))
38 raise util.Abort(_('%s: unknown bundle version %s') % (fname, version))
39
39
40 def buildobsmarkerspart(bundler, markers):
40 def buildobsmarkerspart(bundler, markers):
41 """add an obsmarker part to the bundler with <markers>
41 """add an obsmarker part to the bundler with <markers>
42
42
43 No part is created if markers is empty.
43 No part is created if markers is empty.
44 Raises ValueError if the bundler doesn't support any known obsmarker format.
44 Raises ValueError if the bundler doesn't support any known obsmarker format.
45 """
45 """
46 if markers:
46 if markers:
47 remoteversions = bundle2.obsmarkersversion(bundler.capabilities)
47 remoteversions = bundle2.obsmarkersversion(bundler.capabilities)
48 version = obsolete.commonversion(remoteversions)
48 version = obsolete.commonversion(remoteversions)
49 if version is None:
49 if version is None:
50 raise ValueError('bundler do not support common obsmarker format')
50 raise ValueError('bundler do not support common obsmarker format')
51 stream = obsolete.encodemarkers(markers, True, version=version)
51 stream = obsolete.encodemarkers(markers, True, version=version)
52 return bundler.newpart('B2X:OBSMARKERS', data=stream)
52 return bundler.newpart('B2X:OBSMARKERS', data=stream)
53 return None
53 return None
54
54
55 class pushoperation(object):
55 class pushoperation(object):
56 """A object that represent a single push operation
56 """A object that represent a single push operation
57
57
58 It purpose is to carry push related state and very common operation.
58 It purpose is to carry push related state and very common operation.
59
59
60 A new should be created at the beginning of each push and discarded
60 A new should be created at the beginning of each push and discarded
61 afterward.
61 afterward.
62 """
62 """
63
63
64 def __init__(self, repo, remote, force=False, revs=None, newbranch=False,
64 def __init__(self, repo, remote, force=False, revs=None, newbranch=False,
65 bookmarks=()):
65 bookmarks=()):
66 # repo we push from
66 # repo we push from
67 self.repo = repo
67 self.repo = repo
68 self.ui = repo.ui
68 self.ui = repo.ui
69 # repo we push to
69 # repo we push to
70 self.remote = remote
70 self.remote = remote
71 # force option provided
71 # force option provided
72 self.force = force
72 self.force = force
73 # revs to be pushed (None is "all")
73 # revs to be pushed (None is "all")
74 self.revs = revs
74 self.revs = revs
75 # bookmark explicitly pushed
75 # bookmark explicitly pushed
76 self.bookmarks = bookmarks
76 self.bookmarks = bookmarks
77 # allow push of new branch
77 # allow push of new branch
78 self.newbranch = newbranch
78 self.newbranch = newbranch
79 # did a local lock get acquired?
79 # did a local lock get acquired?
80 self.locallocked = None
80 self.locallocked = None
81 # step already performed
81 # step already performed
82 # (used to check what steps have been already performed through bundle2)
82 # (used to check what steps have been already performed through bundle2)
83 self.stepsdone = set()
83 self.stepsdone = set()
84 # Integer version of the changegroup push result
84 # Integer version of the changegroup push result
85 # - None means nothing to push
85 # - None means nothing to push
86 # - 0 means HTTP error
86 # - 0 means HTTP error
87 # - 1 means we pushed and remote head count is unchanged *or*
87 # - 1 means we pushed and remote head count is unchanged *or*
88 # we have outgoing changesets but refused to push
88 # we have outgoing changesets but refused to push
89 # - other values as described by addchangegroup()
89 # - other values as described by addchangegroup()
90 self.cgresult = None
90 self.cgresult = None
91 # Boolean value for the bookmark push
91 # Boolean value for the bookmark push
92 self.bkresult = None
92 self.bkresult = None
93 # discover.outgoing object (contains common and outgoing data)
93 # discover.outgoing object (contains common and outgoing data)
94 self.outgoing = None
94 self.outgoing = None
95 # all remote heads before the push
95 # all remote heads before the push
96 self.remoteheads = None
96 self.remoteheads = None
97 # testable as a boolean indicating if any nodes are missing locally.
97 # testable as a boolean indicating if any nodes are missing locally.
98 self.incoming = None
98 self.incoming = None
99 # phases changes that must be pushed along side the changesets
99 # phases changes that must be pushed along side the changesets
100 self.outdatedphases = None
100 self.outdatedphases = None
101 # phases changes that must be pushed if changeset push fails
101 # phases changes that must be pushed if changeset push fails
102 self.fallbackoutdatedphases = None
102 self.fallbackoutdatedphases = None
103 # outgoing obsmarkers
103 # outgoing obsmarkers
104 self.outobsmarkers = set()
104 self.outobsmarkers = set()
105 # outgoing bookmarks
105 # outgoing bookmarks
106 self.outbookmarks = []
106 self.outbookmarks = []
107
107
108 @util.propertycache
108 @util.propertycache
109 def futureheads(self):
109 def futureheads(self):
110 """future remote heads if the changeset push succeeds"""
110 """future remote heads if the changeset push succeeds"""
111 return self.outgoing.missingheads
111 return self.outgoing.missingheads
112
112
113 @util.propertycache
113 @util.propertycache
114 def fallbackheads(self):
114 def fallbackheads(self):
115 """future remote heads if the changeset push fails"""
115 """future remote heads if the changeset push fails"""
116 if self.revs is None:
116 if self.revs is None:
117 # not target to push, all common are relevant
117 # not target to push, all common are relevant
118 return self.outgoing.commonheads
118 return self.outgoing.commonheads
119 unfi = self.repo.unfiltered()
119 unfi = self.repo.unfiltered()
120 # I want cheads = heads(::missingheads and ::commonheads)
120 # I want cheads = heads(::missingheads and ::commonheads)
121 # (missingheads is revs with secret changeset filtered out)
121 # (missingheads is revs with secret changeset filtered out)
122 #
122 #
123 # This can be expressed as:
123 # This can be expressed as:
124 # cheads = ( (missingheads and ::commonheads)
124 # cheads = ( (missingheads and ::commonheads)
125 # + (commonheads and ::missingheads))"
125 # + (commonheads and ::missingheads))"
126 # )
126 # )
127 #
127 #
128 # while trying to push we already computed the following:
128 # while trying to push we already computed the following:
129 # common = (::commonheads)
129 # common = (::commonheads)
130 # missing = ((commonheads::missingheads) - commonheads)
130 # missing = ((commonheads::missingheads) - commonheads)
131 #
131 #
132 # We can pick:
132 # We can pick:
133 # * missingheads part of common (::commonheads)
133 # * missingheads part of common (::commonheads)
134 common = set(self.outgoing.common)
134 common = set(self.outgoing.common)
135 nm = self.repo.changelog.nodemap
135 nm = self.repo.changelog.nodemap
136 cheads = [node for node in self.revs if nm[node] in common]
136 cheads = [node for node in self.revs if nm[node] in common]
137 # and
137 # and
138 # * commonheads parents on missing
138 # * commonheads parents on missing
139 revset = unfi.set('%ln and parents(roots(%ln))',
139 revset = unfi.set('%ln and parents(roots(%ln))',
140 self.outgoing.commonheads,
140 self.outgoing.commonheads,
141 self.outgoing.missing)
141 self.outgoing.missing)
142 cheads.extend(c.node() for c in revset)
142 cheads.extend(c.node() for c in revset)
143 return cheads
143 return cheads
144
144
145 @property
145 @property
146 def commonheads(self):
146 def commonheads(self):
147 """set of all common heads after changeset bundle push"""
147 """set of all common heads after changeset bundle push"""
148 if self.cgresult:
148 if self.cgresult:
149 return self.futureheads
149 return self.futureheads
150 else:
150 else:
151 return self.fallbackheads
151 return self.fallbackheads
152
152
153 # mapping of message used when pushing bookmark
153 # mapping of message used when pushing bookmark
154 bookmsgmap = {'update': (_("updating bookmark %s\n"),
154 bookmsgmap = {'update': (_("updating bookmark %s\n"),
155 _('updating bookmark %s failed!\n')),
155 _('updating bookmark %s failed!\n')),
156 'export': (_("exporting bookmark %s\n"),
156 'export': (_("exporting bookmark %s\n"),
157 _('exporting bookmark %s failed!\n')),
157 _('exporting bookmark %s failed!\n')),
158 'delete': (_("deleting remote bookmark %s\n"),
158 'delete': (_("deleting remote bookmark %s\n"),
159 _('deleting remote bookmark %s failed!\n')),
159 _('deleting remote bookmark %s failed!\n')),
160 }
160 }
161
161
162
162
163 def push(repo, remote, force=False, revs=None, newbranch=False, bookmarks=()):
163 def push(repo, remote, force=False, revs=None, newbranch=False, bookmarks=()):
164 '''Push outgoing changesets (limited by revs) from a local
164 '''Push outgoing changesets (limited by revs) from a local
165 repository to remote. Return an integer:
165 repository to remote. Return an integer:
166 - None means nothing to push
166 - None means nothing to push
167 - 0 means HTTP error
167 - 0 means HTTP error
168 - 1 means we pushed and remote head count is unchanged *or*
168 - 1 means we pushed and remote head count is unchanged *or*
169 we have outgoing changesets but refused to push
169 we have outgoing changesets but refused to push
170 - other values as described by addchangegroup()
170 - other values as described by addchangegroup()
171 '''
171 '''
172 pushop = pushoperation(repo, remote, force, revs, newbranch, bookmarks)
172 pushop = pushoperation(repo, remote, force, revs, newbranch, bookmarks)
173 if pushop.remote.local():
173 if pushop.remote.local():
174 missing = (set(pushop.repo.requirements)
174 missing = (set(pushop.repo.requirements)
175 - pushop.remote.local().supported)
175 - pushop.remote.local().supported)
176 if missing:
176 if missing:
177 msg = _("required features are not"
177 msg = _("required features are not"
178 " supported in the destination:"
178 " supported in the destination:"
179 " %s") % (', '.join(sorted(missing)))
179 " %s") % (', '.join(sorted(missing)))
180 raise util.Abort(msg)
180 raise util.Abort(msg)
181
181
182 # there are two ways to push to remote repo:
182 # there are two ways to push to remote repo:
183 #
183 #
184 # addchangegroup assumes local user can lock remote
184 # addchangegroup assumes local user can lock remote
185 # repo (local filesystem, old ssh servers).
185 # repo (local filesystem, old ssh servers).
186 #
186 #
187 # unbundle assumes local user cannot lock remote repo (new ssh
187 # unbundle assumes local user cannot lock remote repo (new ssh
188 # servers, http servers).
188 # servers, http servers).
189
189
190 if not pushop.remote.canpush():
190 if not pushop.remote.canpush():
191 raise util.Abort(_("destination does not support push"))
191 raise util.Abort(_("destination does not support push"))
192 # get local lock as we might write phase data
192 # get local lock as we might write phase data
193 locallock = None
193 locallock = None
194 try:
194 try:
195 locallock = pushop.repo.lock()
195 locallock = pushop.repo.lock()
196 pushop.locallocked = True
196 pushop.locallocked = True
197 except IOError, err:
197 except IOError, err:
198 pushop.locallocked = False
198 pushop.locallocked = False
199 if err.errno != errno.EACCES:
199 if err.errno != errno.EACCES:
200 raise
200 raise
201 # source repo cannot be locked.
201 # source repo cannot be locked.
202 # We do not abort the push, but just disable the local phase
202 # We do not abort the push, but just disable the local phase
203 # synchronisation.
203 # synchronisation.
204 msg = 'cannot lock source repository: %s\n' % err
204 msg = 'cannot lock source repository: %s\n' % err
205 pushop.ui.debug(msg)
205 pushop.ui.debug(msg)
206 try:
206 try:
207 pushop.repo.checkpush(pushop)
207 pushop.repo.checkpush(pushop)
208 lock = None
208 lock = None
209 unbundle = pushop.remote.capable('unbundle')
209 unbundle = pushop.remote.capable('unbundle')
210 if not unbundle:
210 if not unbundle:
211 lock = pushop.remote.lock()
211 lock = pushop.remote.lock()
212 try:
212 try:
213 _pushdiscovery(pushop)
213 _pushdiscovery(pushop)
214 if (pushop.repo.ui.configbool('experimental', 'bundle2-exp',
214 if (pushop.repo.ui.configbool('experimental', 'bundle2-exp',
215 False)
215 False)
216 and pushop.remote.capable('bundle2-exp')):
216 and pushop.remote.capable('bundle2-exp')):
217 _pushbundle2(pushop)
217 _pushbundle2(pushop)
218 _pushchangeset(pushop)
218 _pushchangeset(pushop)
219 _pushsyncphase(pushop)
219 _pushsyncphase(pushop)
220 _pushobsolete(pushop)
220 _pushobsolete(pushop)
221 _pushbookmark(pushop)
221 _pushbookmark(pushop)
222 finally:
222 finally:
223 if lock is not None:
223 if lock is not None:
224 lock.release()
224 lock.release()
225 finally:
225 finally:
226 if locallock is not None:
226 if locallock is not None:
227 locallock.release()
227 locallock.release()
228
228
229 return pushop
229 return pushop
230
230
231 # list of steps to perform discovery before push
231 # list of steps to perform discovery before push
232 pushdiscoveryorder = []
232 pushdiscoveryorder = []
233
233
234 # Mapping between step name and function
234 # Mapping between step name and function
235 #
235 #
236 # This exists to help extensions wrap steps if necessary
236 # This exists to help extensions wrap steps if necessary
237 pushdiscoverymapping = {}
237 pushdiscoverymapping = {}
238
238
239 def pushdiscovery(stepname):
239 def pushdiscovery(stepname):
240 """decorator for function performing discovery before push
240 """decorator for function performing discovery before push
241
241
242 The function is added to the step -> function mapping and appended to the
242 The function is added to the step -> function mapping and appended to the
243 list of steps. Beware that decorated function will be added in order (this
243 list of steps. Beware that decorated function will be added in order (this
244 may matter).
244 may matter).
245
245
246 You can only use this decorator for a new step, if you want to wrap a step
246 You can only use this decorator for a new step, if you want to wrap a step
247 from an extension, change the pushdiscovery dictionary directly."""
247 from an extension, change the pushdiscovery dictionary directly."""
248 def dec(func):
248 def dec(func):
249 assert stepname not in pushdiscoverymapping
249 assert stepname not in pushdiscoverymapping
250 pushdiscoverymapping[stepname] = func
250 pushdiscoverymapping[stepname] = func
251 pushdiscoveryorder.append(stepname)
251 pushdiscoveryorder.append(stepname)
252 return func
252 return func
253 return dec
253 return dec
254
254
255 def _pushdiscovery(pushop):
255 def _pushdiscovery(pushop):
256 """Run all discovery steps"""
256 """Run all discovery steps"""
257 for stepname in pushdiscoveryorder:
257 for stepname in pushdiscoveryorder:
258 step = pushdiscoverymapping[stepname]
258 step = pushdiscoverymapping[stepname]
259 step(pushop)
259 step(pushop)
260
260
261 @pushdiscovery('changeset')
261 @pushdiscovery('changeset')
262 def _pushdiscoverychangeset(pushop):
262 def _pushdiscoverychangeset(pushop):
263 """discover the changeset that need to be pushed"""
263 """discover the changeset that need to be pushed"""
264 unfi = pushop.repo.unfiltered()
264 unfi = pushop.repo.unfiltered()
265 fci = discovery.findcommonincoming
265 fci = discovery.findcommonincoming
266 commoninc = fci(unfi, pushop.remote, force=pushop.force)
266 commoninc = fci(unfi, pushop.remote, force=pushop.force)
267 common, inc, remoteheads = commoninc
267 common, inc, remoteheads = commoninc
268 fco = discovery.findcommonoutgoing
268 fco = discovery.findcommonoutgoing
269 outgoing = fco(unfi, pushop.remote, onlyheads=pushop.revs,
269 outgoing = fco(unfi, pushop.remote, onlyheads=pushop.revs,
270 commoninc=commoninc, force=pushop.force)
270 commoninc=commoninc, force=pushop.force)
271 pushop.outgoing = outgoing
271 pushop.outgoing = outgoing
272 pushop.remoteheads = remoteheads
272 pushop.remoteheads = remoteheads
273 pushop.incoming = inc
273 pushop.incoming = inc
274
274
275 @pushdiscovery('phase')
275 @pushdiscovery('phase')
276 def _pushdiscoveryphase(pushop):
276 def _pushdiscoveryphase(pushop):
277 """discover the phase that needs to be pushed
277 """discover the phase that needs to be pushed
278
278
279 (computed for both success and failure case for changesets push)"""
279 (computed for both success and failure case for changesets push)"""
280 outgoing = pushop.outgoing
280 outgoing = pushop.outgoing
281 unfi = pushop.repo.unfiltered()
281 unfi = pushop.repo.unfiltered()
282 remotephases = pushop.remote.listkeys('phases')
282 remotephases = pushop.remote.listkeys('phases')
283 publishing = remotephases.get('publishing', False)
283 publishing = remotephases.get('publishing', False)
284 ana = phases.analyzeremotephases(pushop.repo,
284 ana = phases.analyzeremotephases(pushop.repo,
285 pushop.fallbackheads,
285 pushop.fallbackheads,
286 remotephases)
286 remotephases)
287 pheads, droots = ana
287 pheads, droots = ana
288 extracond = ''
288 extracond = ''
289 if not publishing:
289 if not publishing:
290 extracond = ' and public()'
290 extracond = ' and public()'
291 revset = 'heads((%%ln::%%ln) %s)' % extracond
291 revset = 'heads((%%ln::%%ln) %s)' % extracond
292 # Get the list of all revs draft on remote by public here.
292 # Get the list of all revs draft on remote by public here.
293 # XXX Beware that revset break if droots is not strictly
293 # XXX Beware that revset break if droots is not strictly
294 # XXX root we may want to ensure it is but it is costly
294 # XXX root we may want to ensure it is but it is costly
295 fallback = list(unfi.set(revset, droots, pushop.fallbackheads))
295 fallback = list(unfi.set(revset, droots, pushop.fallbackheads))
296 if not outgoing.missing:
296 if not outgoing.missing:
297 future = fallback
297 future = fallback
298 else:
298 else:
299 # adds changeset we are going to push as draft
299 # adds changeset we are going to push as draft
300 #
300 #
301 # should not be necessary for pushblishing server, but because of an
301 # should not be necessary for pushblishing server, but because of an
302 # issue fixed in xxxxx we have to do it anyway.
302 # issue fixed in xxxxx we have to do it anyway.
303 fdroots = list(unfi.set('roots(%ln + %ln::)',
303 fdroots = list(unfi.set('roots(%ln + %ln::)',
304 outgoing.missing, droots))
304 outgoing.missing, droots))
305 fdroots = [f.node() for f in fdroots]
305 fdroots = [f.node() for f in fdroots]
306 future = list(unfi.set(revset, fdroots, pushop.futureheads))
306 future = list(unfi.set(revset, fdroots, pushop.futureheads))
307 pushop.outdatedphases = future
307 pushop.outdatedphases = future
308 pushop.fallbackoutdatedphases = fallback
308 pushop.fallbackoutdatedphases = fallback
309
309
310 @pushdiscovery('obsmarker')
310 @pushdiscovery('obsmarker')
311 def _pushdiscoveryobsmarkers(pushop):
311 def _pushdiscoveryobsmarkers(pushop):
312 if (obsolete._enabled
312 if (obsolete._enabled
313 and pushop.repo.obsstore
313 and pushop.repo.obsstore
314 and 'obsolete' in pushop.remote.listkeys('namespaces')):
314 and 'obsolete' in pushop.remote.listkeys('namespaces')):
315 repo = pushop.repo
315 repo = pushop.repo
316 # very naive computation, that can be quite expensive on big repo.
316 # very naive computation, that can be quite expensive on big repo.
317 # However: evolution is currently slow on them anyway.
317 # However: evolution is currently slow on them anyway.
318 nodes = (c.node() for c in repo.set('::%ln', pushop.futureheads))
318 nodes = (c.node() for c in repo.set('::%ln', pushop.futureheads))
319 pushop.outobsmarkers = pushop.repo.obsstore.relevantmarkers(nodes)
319 pushop.outobsmarkers = pushop.repo.obsstore.relevantmarkers(nodes)
320
320
321 @pushdiscovery('bookmarks')
321 @pushdiscovery('bookmarks')
322 def _pushdiscoverybookmarks(pushop):
322 def _pushdiscoverybookmarks(pushop):
323 ui = pushop.ui
323 ui = pushop.ui
324 repo = pushop.repo.unfiltered()
324 repo = pushop.repo.unfiltered()
325 remote = pushop.remote
325 remote = pushop.remote
326 ui.debug("checking for updated bookmarks\n")
326 ui.debug("checking for updated bookmarks\n")
327 ancestors = ()
327 ancestors = ()
328 if pushop.revs:
328 if pushop.revs:
329 revnums = map(repo.changelog.rev, pushop.revs)
329 revnums = map(repo.changelog.rev, pushop.revs)
330 ancestors = repo.changelog.ancestors(revnums, inclusive=True)
330 ancestors = repo.changelog.ancestors(revnums, inclusive=True)
331 remotebookmark = remote.listkeys('bookmarks')
331 remotebookmark = remote.listkeys('bookmarks')
332
332
333 explicit = set(pushop.bookmarks)
333 explicit = set(pushop.bookmarks)
334
334
335 comp = bookmod.compare(repo, repo._bookmarks, remotebookmark, srchex=hex)
335 comp = bookmod.compare(repo, repo._bookmarks, remotebookmark, srchex=hex)
336 addsrc, adddst, advsrc, advdst, diverge, differ, invalid = comp
336 addsrc, adddst, advsrc, advdst, diverge, differ, invalid = comp
337 for b, scid, dcid in advsrc:
337 for b, scid, dcid in advsrc:
338 if b in explicit:
338 if b in explicit:
339 explicit.remove(b)
339 explicit.remove(b)
340 if not ancestors or repo[scid].rev() in ancestors:
340 if not ancestors or repo[scid].rev() in ancestors:
341 pushop.outbookmarks.append((b, dcid, scid))
341 pushop.outbookmarks.append((b, dcid, scid))
342 # search added bookmark
342 # search added bookmark
343 for b, scid, dcid in addsrc:
343 for b, scid, dcid in addsrc:
344 if b in explicit:
344 if b in explicit:
345 explicit.remove(b)
345 explicit.remove(b)
346 pushop.outbookmarks.append((b, '', scid))
346 pushop.outbookmarks.append((b, '', scid))
347 # search for overwritten bookmark
347 # search for overwritten bookmark
348 for b, scid, dcid in advdst + diverge + differ:
348 for b, scid, dcid in advdst + diverge + differ:
349 if b in explicit:
349 if b in explicit:
350 explicit.remove(b)
350 explicit.remove(b)
351 pushop.outbookmarks.append((b, dcid, scid))
351 pushop.outbookmarks.append((b, dcid, scid))
352 # search for bookmark to delete
352 # search for bookmark to delete
353 for b, scid, dcid in adddst:
353 for b, scid, dcid in adddst:
354 if b in explicit:
354 if b in explicit:
355 explicit.remove(b)
355 explicit.remove(b)
356 # treat as "deleted locally"
356 # treat as "deleted locally"
357 pushop.outbookmarks.append((b, dcid, ''))
357 pushop.outbookmarks.append((b, dcid, ''))
358
358
359 if explicit:
359 if explicit:
360 explicit = sorted(explicit)
360 explicit = sorted(explicit)
361 # we should probably list all of them
361 # we should probably list all of them
362 ui.warn(_('bookmark %s does not exist on the local '
362 ui.warn(_('bookmark %s does not exist on the local '
363 'or remote repository!\n') % explicit[0])
363 'or remote repository!\n') % explicit[0])
364 pushop.bkresult = 2
364 pushop.bkresult = 2
365
365
366 pushop.outbookmarks.sort()
366 pushop.outbookmarks.sort()
367
367
368 def _pushcheckoutgoing(pushop):
368 def _pushcheckoutgoing(pushop):
369 outgoing = pushop.outgoing
369 outgoing = pushop.outgoing
370 unfi = pushop.repo.unfiltered()
370 unfi = pushop.repo.unfiltered()
371 if not outgoing.missing:
371 if not outgoing.missing:
372 # nothing to push
372 # nothing to push
373 scmutil.nochangesfound(unfi.ui, unfi, outgoing.excluded)
373 scmutil.nochangesfound(unfi.ui, unfi, outgoing.excluded)
374 return False
374 return False
375 # something to push
375 # something to push
376 if not pushop.force:
376 if not pushop.force:
377 # if repo.obsstore == False --> no obsolete
377 # if repo.obsstore == False --> no obsolete
378 # then, save the iteration
378 # then, save the iteration
379 if unfi.obsstore:
379 if unfi.obsstore:
380 # this message are here for 80 char limit reason
380 # this message are here for 80 char limit reason
381 mso = _("push includes obsolete changeset: %s!")
381 mso = _("push includes obsolete changeset: %s!")
382 mst = {"unstable": _("push includes unstable changeset: %s!"),
382 mst = {"unstable": _("push includes unstable changeset: %s!"),
383 "bumped": _("push includes bumped changeset: %s!"),
383 "bumped": _("push includes bumped changeset: %s!"),
384 "divergent": _("push includes divergent changeset: %s!")}
384 "divergent": _("push includes divergent changeset: %s!")}
385 # If we are to push if there is at least one
385 # If we are to push if there is at least one
386 # obsolete or unstable changeset in missing, at
386 # obsolete or unstable changeset in missing, at
387 # least one of the missinghead will be obsolete or
387 # least one of the missinghead will be obsolete or
388 # unstable. So checking heads only is ok
388 # unstable. So checking heads only is ok
389 for node in outgoing.missingheads:
389 for node in outgoing.missingheads:
390 ctx = unfi[node]
390 ctx = unfi[node]
391 if ctx.obsolete():
391 if ctx.obsolete():
392 raise util.Abort(mso % ctx)
392 raise util.Abort(mso % ctx)
393 elif ctx.troubled():
393 elif ctx.troubled():
394 raise util.Abort(mst[ctx.troubles()[0]] % ctx)
394 raise util.Abort(mst[ctx.troubles()[0]] % ctx)
395 newbm = pushop.ui.configlist('bookmarks', 'pushing')
395 newbm = pushop.ui.configlist('bookmarks', 'pushing')
396 discovery.checkheads(unfi, pushop.remote, outgoing,
396 discovery.checkheads(unfi, pushop.remote, outgoing,
397 pushop.remoteheads,
397 pushop.remoteheads,
398 pushop.newbranch,
398 pushop.newbranch,
399 bool(pushop.incoming),
399 bool(pushop.incoming),
400 newbm)
400 newbm)
401 return True
401 return True
402
402
403 # List of names of steps to perform for an outgoing bundle2, order matters.
403 # List of names of steps to perform for an outgoing bundle2, order matters.
404 b2partsgenorder = []
404 b2partsgenorder = []
405
405
406 # Mapping between step name and function
406 # Mapping between step name and function
407 #
407 #
408 # This exists to help extensions wrap steps if necessary
408 # This exists to help extensions wrap steps if necessary
409 b2partsgenmapping = {}
409 b2partsgenmapping = {}
410
410
411 def b2partsgenerator(stepname):
411 def b2partsgenerator(stepname):
412 """decorator for function generating bundle2 part
412 """decorator for function generating bundle2 part
413
413
414 The function is added to the step -> function mapping and appended to the
414 The function is added to the step -> function mapping and appended to the
415 list of steps. Beware that decorated functions will be added in order
415 list of steps. Beware that decorated functions will be added in order
416 (this may matter).
416 (this may matter).
417
417
418 You can only use this decorator for new steps, if you want to wrap a step
418 You can only use this decorator for new steps, if you want to wrap a step
419 from an extension, attack the b2partsgenmapping dictionary directly."""
419 from an extension, attack the b2partsgenmapping dictionary directly."""
420 def dec(func):
420 def dec(func):
421 assert stepname not in b2partsgenmapping
421 assert stepname not in b2partsgenmapping
422 b2partsgenmapping[stepname] = func
422 b2partsgenmapping[stepname] = func
423 b2partsgenorder.append(stepname)
423 b2partsgenorder.append(stepname)
424 return func
424 return func
425 return dec
425 return dec
426
426
427 @b2partsgenerator('changeset')
427 @b2partsgenerator('changeset')
428 def _pushb2ctx(pushop, bundler):
428 def _pushb2ctx(pushop, bundler):
429 """handle changegroup push through bundle2
429 """handle changegroup push through bundle2
430
430
431 addchangegroup result is stored in the ``pushop.cgresult`` attribute.
431 addchangegroup result is stored in the ``pushop.cgresult`` attribute.
432 """
432 """
433 if 'changesets' in pushop.stepsdone:
433 if 'changesets' in pushop.stepsdone:
434 return
434 return
435 pushop.stepsdone.add('changesets')
435 pushop.stepsdone.add('changesets')
436 # Send known heads to the server for race detection.
436 # Send known heads to the server for race detection.
437 if not _pushcheckoutgoing(pushop):
437 if not _pushcheckoutgoing(pushop):
438 return
438 return
439 pushop.repo.prepushoutgoinghooks(pushop.repo,
439 pushop.repo.prepushoutgoinghooks(pushop.repo,
440 pushop.remote,
440 pushop.remote,
441 pushop.outgoing)
441 pushop.outgoing)
442 if not pushop.force:
442 if not pushop.force:
443 bundler.newpart('B2X:CHECK:HEADS', data=iter(pushop.remoteheads))
443 bundler.newpart('B2X:CHECK:HEADS', data=iter(pushop.remoteheads))
444 cg = changegroup.getlocalchangegroup(pushop.repo, 'push', pushop.outgoing)
444 cg = changegroup.getlocalchangegroup(pushop.repo, 'push', pushop.outgoing)
445 cgpart = bundler.newpart('B2X:CHANGEGROUP', data=cg.getchunks())
445 cgpart = bundler.newpart('B2X:CHANGEGROUP', data=cg.getchunks())
446 def handlereply(op):
446 def handlereply(op):
447 """extract addchangroup returns from server reply"""
447 """extract addchangroup returns from server reply"""
448 cgreplies = op.records.getreplies(cgpart.id)
448 cgreplies = op.records.getreplies(cgpart.id)
449 assert len(cgreplies['changegroup']) == 1
449 assert len(cgreplies['changegroup']) == 1
450 pushop.cgresult = cgreplies['changegroup'][0]['return']
450 pushop.cgresult = cgreplies['changegroup'][0]['return']
451 return handlereply
451 return handlereply
452
452
453 @b2partsgenerator('phase')
453 @b2partsgenerator('phase')
454 def _pushb2phases(pushop, bundler):
454 def _pushb2phases(pushop, bundler):
455 """handle phase push through bundle2"""
455 """handle phase push through bundle2"""
456 if 'phases' in pushop.stepsdone:
456 if 'phases' in pushop.stepsdone:
457 return
457 return
458 b2caps = bundle2.bundle2caps(pushop.remote)
458 b2caps = bundle2.bundle2caps(pushop.remote)
459 if not 'b2x:pushkey' in b2caps:
459 if not 'b2x:pushkey' in b2caps:
460 return
460 return
461 pushop.stepsdone.add('phases')
461 pushop.stepsdone.add('phases')
462 part2node = []
462 part2node = []
463 enc = pushkey.encode
463 enc = pushkey.encode
464 for newremotehead in pushop.outdatedphases:
464 for newremotehead in pushop.outdatedphases:
465 part = bundler.newpart('b2x:pushkey')
465 part = bundler.newpart('b2x:pushkey')
466 part.addparam('namespace', enc('phases'))
466 part.addparam('namespace', enc('phases'))
467 part.addparam('key', enc(newremotehead.hex()))
467 part.addparam('key', enc(newremotehead.hex()))
468 part.addparam('old', enc(str(phases.draft)))
468 part.addparam('old', enc(str(phases.draft)))
469 part.addparam('new', enc(str(phases.public)))
469 part.addparam('new', enc(str(phases.public)))
470 part2node.append((part.id, newremotehead))
470 part2node.append((part.id, newremotehead))
471 def handlereply(op):
471 def handlereply(op):
472 for partid, node in part2node:
472 for partid, node in part2node:
473 partrep = op.records.getreplies(partid)
473 partrep = op.records.getreplies(partid)
474 results = partrep['pushkey']
474 results = partrep['pushkey']
475 assert len(results) <= 1
475 assert len(results) <= 1
476 msg = None
476 msg = None
477 if not results:
477 if not results:
478 msg = _('server ignored update of %s to public!\n') % node
478 msg = _('server ignored update of %s to public!\n') % node
479 elif not int(results[0]['return']):
479 elif not int(results[0]['return']):
480 msg = _('updating %s to public failed!\n') % node
480 msg = _('updating %s to public failed!\n') % node
481 if msg is not None:
481 if msg is not None:
482 pushop.ui.warn(msg)
482 pushop.ui.warn(msg)
483 return handlereply
483 return handlereply
484
484
485 @b2partsgenerator('obsmarkers')
485 @b2partsgenerator('obsmarkers')
486 def _pushb2obsmarkers(pushop, bundler):
486 def _pushb2obsmarkers(pushop, bundler):
487 if 'obsmarkers' in pushop.stepsdone:
487 if 'obsmarkers' in pushop.stepsdone:
488 return
488 return
489 remoteversions = bundle2.obsmarkersversion(bundler.capabilities)
489 remoteversions = bundle2.obsmarkersversion(bundler.capabilities)
490 if obsolete.commonversion(remoteversions) is None:
490 if obsolete.commonversion(remoteversions) is None:
491 return
491 return
492 pushop.stepsdone.add('obsmarkers')
492 pushop.stepsdone.add('obsmarkers')
493 if pushop.outobsmarkers:
493 if pushop.outobsmarkers:
494 buildobsmarkerspart(bundler, pushop.outobsmarkers)
494 buildobsmarkerspart(bundler, pushop.outobsmarkers)
495
495
496 @b2partsgenerator('bookmarks')
496 @b2partsgenerator('bookmarks')
497 def _pushb2bookmarks(pushop, bundler):
497 def _pushb2bookmarks(pushop, bundler):
498 """handle phase push through bundle2"""
498 """handle phase push through bundle2"""
499 if 'bookmarks' in pushop.stepsdone:
499 if 'bookmarks' in pushop.stepsdone:
500 return
500 return
501 b2caps = bundle2.bundle2caps(pushop.remote)
501 b2caps = bundle2.bundle2caps(pushop.remote)
502 if 'b2x:pushkey' not in b2caps:
502 if 'b2x:pushkey' not in b2caps:
503 return
503 return
504 pushop.stepsdone.add('bookmarks')
504 pushop.stepsdone.add('bookmarks')
505 part2book = []
505 part2book = []
506 enc = pushkey.encode
506 enc = pushkey.encode
507 for book, old, new in pushop.outbookmarks:
507 for book, old, new in pushop.outbookmarks:
508 part = bundler.newpart('b2x:pushkey')
508 part = bundler.newpart('b2x:pushkey')
509 part.addparam('namespace', enc('bookmarks'))
509 part.addparam('namespace', enc('bookmarks'))
510 part.addparam('key', enc(book))
510 part.addparam('key', enc(book))
511 part.addparam('old', enc(old))
511 part.addparam('old', enc(old))
512 part.addparam('new', enc(new))
512 part.addparam('new', enc(new))
513 action = 'update'
513 action = 'update'
514 if not old:
514 if not old:
515 action = 'export'
515 action = 'export'
516 elif not new:
516 elif not new:
517 action = 'delete'
517 action = 'delete'
518 part2book.append((part.id, book, action))
518 part2book.append((part.id, book, action))
519
519
520
520
521 def handlereply(op):
521 def handlereply(op):
522 ui = pushop.ui
522 ui = pushop.ui
523 for partid, book, action in part2book:
523 for partid, book, action in part2book:
524 partrep = op.records.getreplies(partid)
524 partrep = op.records.getreplies(partid)
525 results = partrep['pushkey']
525 results = partrep['pushkey']
526 assert len(results) <= 1
526 assert len(results) <= 1
527 if not results:
527 if not results:
528 pushop.ui.warn(_('server ignored bookmark %s update\n') % book)
528 pushop.ui.warn(_('server ignored bookmark %s update\n') % book)
529 else:
529 else:
530 ret = int(results[0]['return'])
530 ret = int(results[0]['return'])
531 if ret:
531 if ret:
532 ui.status(bookmsgmap[action][0] % book)
532 ui.status(bookmsgmap[action][0] % book)
533 else:
533 else:
534 ui.warn(bookmsgmap[action][1] % book)
534 ui.warn(bookmsgmap[action][1] % book)
535 if pushop.bkresult is not None:
535 if pushop.bkresult is not None:
536 pushop.bkresult = 1
536 pushop.bkresult = 1
537 return handlereply
537 return handlereply
538
538
539
539
540 def _pushbundle2(pushop):
540 def _pushbundle2(pushop):
541 """push data to the remote using bundle2
541 """push data to the remote using bundle2
542
542
543 The only currently supported type of data is changegroup but this will
543 The only currently supported type of data is changegroup but this will
544 evolve in the future."""
544 evolve in the future."""
545 bundler = bundle2.bundle20(pushop.ui, bundle2.bundle2caps(pushop.remote))
545 bundler = bundle2.bundle20(pushop.ui, bundle2.bundle2caps(pushop.remote))
546 # create reply capability
546 # create reply capability
547 capsblob = bundle2.encodecaps(bundle2.getrepocaps(pushop.repo))
547 capsblob = bundle2.encodecaps(bundle2.getrepocaps(pushop.repo))
548 bundler.newpart('b2x:replycaps', data=capsblob)
548 bundler.newpart('b2x:replycaps', data=capsblob)
549 replyhandlers = []
549 replyhandlers = []
550 for partgenname in b2partsgenorder:
550 for partgenname in b2partsgenorder:
551 partgen = b2partsgenmapping[partgenname]
551 partgen = b2partsgenmapping[partgenname]
552 ret = partgen(pushop, bundler)
552 ret = partgen(pushop, bundler)
553 if callable(ret):
553 if callable(ret):
554 replyhandlers.append(ret)
554 replyhandlers.append(ret)
555 # do not push if nothing to push
555 # do not push if nothing to push
556 if bundler.nbparts <= 1:
556 if bundler.nbparts <= 1:
557 return
557 return
558 stream = util.chunkbuffer(bundler.getchunks())
558 stream = util.chunkbuffer(bundler.getchunks())
559 try:
559 try:
560 reply = pushop.remote.unbundle(stream, ['force'], 'push')
560 reply = pushop.remote.unbundle(stream, ['force'], 'push')
561 except error.BundleValueError, exc:
561 except error.BundleValueError, exc:
562 raise util.Abort('missing support for %s' % exc)
562 raise util.Abort('missing support for %s' % exc)
563 try:
563 try:
564 op = bundle2.processbundle(pushop.repo, reply)
564 op = bundle2.processbundle(pushop.repo, reply)
565 except error.BundleValueError, exc:
565 except error.BundleValueError, exc:
566 raise util.Abort('missing support for %s' % exc)
566 raise util.Abort('missing support for %s' % exc)
567 for rephand in replyhandlers:
567 for rephand in replyhandlers:
568 rephand(op)
568 rephand(op)
569
569
570 def _pushchangeset(pushop):
570 def _pushchangeset(pushop):
571 """Make the actual push of changeset bundle to remote repo"""
571 """Make the actual push of changeset bundle to remote repo"""
572 if 'changesets' in pushop.stepsdone:
572 if 'changesets' in pushop.stepsdone:
573 return
573 return
574 pushop.stepsdone.add('changesets')
574 pushop.stepsdone.add('changesets')
575 if not _pushcheckoutgoing(pushop):
575 if not _pushcheckoutgoing(pushop):
576 return
576 return
577 pushop.repo.prepushoutgoinghooks(pushop.repo,
577 pushop.repo.prepushoutgoinghooks(pushop.repo,
578 pushop.remote,
578 pushop.remote,
579 pushop.outgoing)
579 pushop.outgoing)
580 outgoing = pushop.outgoing
580 outgoing = pushop.outgoing
581 unbundle = pushop.remote.capable('unbundle')
581 unbundle = pushop.remote.capable('unbundle')
582 # TODO: get bundlecaps from remote
582 # TODO: get bundlecaps from remote
583 bundlecaps = None
583 bundlecaps = None
584 # create a changegroup from local
584 # create a changegroup from local
585 if pushop.revs is None and not (outgoing.excluded
585 if pushop.revs is None and not (outgoing.excluded
586 or pushop.repo.changelog.filteredrevs):
586 or pushop.repo.changelog.filteredrevs):
587 # push everything,
587 # push everything,
588 # use the fast path, no race possible on push
588 # use the fast path, no race possible on push
589 bundler = changegroup.cg1packer(pushop.repo, bundlecaps)
589 bundler = changegroup.cg1packer(pushop.repo, bundlecaps)
590 cg = changegroup.getsubset(pushop.repo,
590 cg = changegroup.getsubset(pushop.repo,
591 outgoing,
591 outgoing,
592 bundler,
592 bundler,
593 'push',
593 'push',
594 fastpath=True)
594 fastpath=True)
595 else:
595 else:
596 cg = changegroup.getlocalchangegroup(pushop.repo, 'push', outgoing,
596 cg = changegroup.getlocalchangegroup(pushop.repo, 'push', outgoing,
597 bundlecaps)
597 bundlecaps)
598
598
599 # apply changegroup to remote
599 # apply changegroup to remote
600 if unbundle:
600 if unbundle:
601 # local repo finds heads on server, finds out what
601 # local repo finds heads on server, finds out what
602 # revs it must push. once revs transferred, if server
602 # revs it must push. once revs transferred, if server
603 # finds it has different heads (someone else won
603 # finds it has different heads (someone else won
604 # commit/push race), server aborts.
604 # commit/push race), server aborts.
605 if pushop.force:
605 if pushop.force:
606 remoteheads = ['force']
606 remoteheads = ['force']
607 else:
607 else:
608 remoteheads = pushop.remoteheads
608 remoteheads = pushop.remoteheads
609 # ssh: return remote's addchangegroup()
609 # ssh: return remote's addchangegroup()
610 # http: return remote's addchangegroup() or 0 for error
610 # http: return remote's addchangegroup() or 0 for error
611 pushop.cgresult = pushop.remote.unbundle(cg, remoteheads,
611 pushop.cgresult = pushop.remote.unbundle(cg, remoteheads,
612 pushop.repo.url())
612 pushop.repo.url())
613 else:
613 else:
614 # we return an integer indicating remote head count
614 # we return an integer indicating remote head count
615 # change
615 # change
616 pushop.cgresult = pushop.remote.addchangegroup(cg, 'push',
616 pushop.cgresult = pushop.remote.addchangegroup(cg, 'push',
617 pushop.repo.url())
617 pushop.repo.url())
618
618
619 def _pushsyncphase(pushop):
619 def _pushsyncphase(pushop):
620 """synchronise phase information locally and remotely"""
620 """synchronise phase information locally and remotely"""
621 cheads = pushop.commonheads
621 cheads = pushop.commonheads
622 # even when we don't push, exchanging phase data is useful
622 # even when we don't push, exchanging phase data is useful
623 remotephases = pushop.remote.listkeys('phases')
623 remotephases = pushop.remote.listkeys('phases')
624 if (pushop.ui.configbool('ui', '_usedassubrepo', False)
624 if (pushop.ui.configbool('ui', '_usedassubrepo', False)
625 and remotephases # server supports phases
625 and remotephases # server supports phases
626 and pushop.cgresult is None # nothing was pushed
626 and pushop.cgresult is None # nothing was pushed
627 and remotephases.get('publishing', False)):
627 and remotephases.get('publishing', False)):
628 # When:
628 # When:
629 # - this is a subrepo push
629 # - this is a subrepo push
630 # - and remote support phase
630 # - and remote support phase
631 # - and no changeset was pushed
631 # - and no changeset was pushed
632 # - and remote is publishing
632 # - and remote is publishing
633 # We may be in issue 3871 case!
633 # We may be in issue 3871 case!
634 # We drop the possible phase synchronisation done by
634 # We drop the possible phase synchronisation done by
635 # courtesy to publish changesets possibly locally draft
635 # courtesy to publish changesets possibly locally draft
636 # on the remote.
636 # on the remote.
637 remotephases = {'publishing': 'True'}
637 remotephases = {'publishing': 'True'}
638 if not remotephases: # old server or public only reply from non-publishing
638 if not remotephases: # old server or public only reply from non-publishing
639 _localphasemove(pushop, cheads)
639 _localphasemove(pushop, cheads)
640 # don't push any phase data as there is nothing to push
640 # don't push any phase data as there is nothing to push
641 else:
641 else:
642 ana = phases.analyzeremotephases(pushop.repo, cheads,
642 ana = phases.analyzeremotephases(pushop.repo, cheads,
643 remotephases)
643 remotephases)
644 pheads, droots = ana
644 pheads, droots = ana
645 ### Apply remote phase on local
645 ### Apply remote phase on local
646 if remotephases.get('publishing', False):
646 if remotephases.get('publishing', False):
647 _localphasemove(pushop, cheads)
647 _localphasemove(pushop, cheads)
648 else: # publish = False
648 else: # publish = False
649 _localphasemove(pushop, pheads)
649 _localphasemove(pushop, pheads)
650 _localphasemove(pushop, cheads, phases.draft)
650 _localphasemove(pushop, cheads, phases.draft)
651 ### Apply local phase on remote
651 ### Apply local phase on remote
652
652
653 if pushop.cgresult:
653 if pushop.cgresult:
654 if 'phases' in pushop.stepsdone:
654 if 'phases' in pushop.stepsdone:
655 # phases already pushed though bundle2
655 # phases already pushed though bundle2
656 return
656 return
657 outdated = pushop.outdatedphases
657 outdated = pushop.outdatedphases
658 else:
658 else:
659 outdated = pushop.fallbackoutdatedphases
659 outdated = pushop.fallbackoutdatedphases
660
660
661 pushop.stepsdone.add('phases')
661 pushop.stepsdone.add('phases')
662
662
663 # filter heads already turned public by the push
663 # filter heads already turned public by the push
664 outdated = [c for c in outdated if c.node() not in pheads]
664 outdated = [c for c in outdated if c.node() not in pheads]
665 b2caps = bundle2.bundle2caps(pushop.remote)
665 b2caps = bundle2.bundle2caps(pushop.remote)
666 if 'b2x:pushkey' in b2caps:
666 if 'b2x:pushkey' in b2caps:
667 # server supports bundle2, let's do a batched push through it
667 # server supports bundle2, let's do a batched push through it
668 #
668 #
669 # This will eventually be unified with the changesets bundle2 push
669 # This will eventually be unified with the changesets bundle2 push
670 bundler = bundle2.bundle20(pushop.ui, b2caps)
670 bundler = bundle2.bundle20(pushop.ui, b2caps)
671 capsblob = bundle2.encodecaps(bundle2.getrepocaps(pushop.repo))
671 capsblob = bundle2.encodecaps(bundle2.getrepocaps(pushop.repo))
672 bundler.newpart('b2x:replycaps', data=capsblob)
672 bundler.newpart('b2x:replycaps', data=capsblob)
673 part2node = []
673 part2node = []
674 enc = pushkey.encode
674 enc = pushkey.encode
675 for newremotehead in outdated:
675 for newremotehead in outdated:
676 part = bundler.newpart('b2x:pushkey')
676 part = bundler.newpart('b2x:pushkey')
677 part.addparam('namespace', enc('phases'))
677 part.addparam('namespace', enc('phases'))
678 part.addparam('key', enc(newremotehead.hex()))
678 part.addparam('key', enc(newremotehead.hex()))
679 part.addparam('old', enc(str(phases.draft)))
679 part.addparam('old', enc(str(phases.draft)))
680 part.addparam('new', enc(str(phases.public)))
680 part.addparam('new', enc(str(phases.public)))
681 part2node.append((part.id, newremotehead))
681 part2node.append((part.id, newremotehead))
682 stream = util.chunkbuffer(bundler.getchunks())
682 stream = util.chunkbuffer(bundler.getchunks())
683 try:
683 try:
684 reply = pushop.remote.unbundle(stream, ['force'], 'push')
684 reply = pushop.remote.unbundle(stream, ['force'], 'push')
685 op = bundle2.processbundle(pushop.repo, reply)
685 op = bundle2.processbundle(pushop.repo, reply)
686 except error.BundleValueError, exc:
686 except error.BundleValueError, exc:
687 raise util.Abort('missing support for %s' % exc)
687 raise util.Abort('missing support for %s' % exc)
688 for partid, node in part2node:
688 for partid, node in part2node:
689 partrep = op.records.getreplies(partid)
689 partrep = op.records.getreplies(partid)
690 results = partrep['pushkey']
690 results = partrep['pushkey']
691 assert len(results) <= 1
691 assert len(results) <= 1
692 msg = None
692 msg = None
693 if not results:
693 if not results:
694 msg = _('server ignored update of %s to public!\n') % node
694 msg = _('server ignored update of %s to public!\n') % node
695 elif not int(results[0]['return']):
695 elif not int(results[0]['return']):
696 msg = _('updating %s to public failed!\n') % node
696 msg = _('updating %s to public failed!\n') % node
697 if msg is not None:
697 if msg is not None:
698 pushop.ui.warn(msg)
698 pushop.ui.warn(msg)
699
699
700 else:
700 else:
701 # fallback to independant pushkey command
701 # fallback to independant pushkey command
702 for newremotehead in outdated:
702 for newremotehead in outdated:
703 r = pushop.remote.pushkey('phases',
703 r = pushop.remote.pushkey('phases',
704 newremotehead.hex(),
704 newremotehead.hex(),
705 str(phases.draft),
705 str(phases.draft),
706 str(phases.public))
706 str(phases.public))
707 if not r:
707 if not r:
708 pushop.ui.warn(_('updating %s to public failed!\n')
708 pushop.ui.warn(_('updating %s to public failed!\n')
709 % newremotehead)
709 % newremotehead)
710
710
711 def _localphasemove(pushop, nodes, phase=phases.public):
711 def _localphasemove(pushop, nodes, phase=phases.public):
712 """move <nodes> to <phase> in the local source repo"""
712 """move <nodes> to <phase> in the local source repo"""
713 if pushop.locallocked:
713 if pushop.locallocked:
714 tr = pushop.repo.transaction('push-phase-sync')
714 tr = pushop.repo.transaction('push-phase-sync')
715 try:
715 try:
716 phases.advanceboundary(pushop.repo, tr, phase, nodes)
716 phases.advanceboundary(pushop.repo, tr, phase, nodes)
717 tr.close()
717 tr.close()
718 finally:
718 finally:
719 tr.release()
719 tr.release()
720 else:
720 else:
721 # repo is not locked, do not change any phases!
721 # repo is not locked, do not change any phases!
722 # Informs the user that phases should have been moved when
722 # Informs the user that phases should have been moved when
723 # applicable.
723 # applicable.
724 actualmoves = [n for n in nodes if phase < pushop.repo[n].phase()]
724 actualmoves = [n for n in nodes if phase < pushop.repo[n].phase()]
725 phasestr = phases.phasenames[phase]
725 phasestr = phases.phasenames[phase]
726 if actualmoves:
726 if actualmoves:
727 pushop.ui.status(_('cannot lock source repo, skipping '
727 pushop.ui.status(_('cannot lock source repo, skipping '
728 'local %s phase update\n') % phasestr)
728 'local %s phase update\n') % phasestr)
729
729
730 def _pushobsolete(pushop):
730 def _pushobsolete(pushop):
731 """utility function to push obsolete markers to a remote"""
731 """utility function to push obsolete markers to a remote"""
732 if 'obsmarkers' in pushop.stepsdone:
732 if 'obsmarkers' in pushop.stepsdone:
733 return
733 return
734 pushop.ui.debug('try to push obsolete markers to remote\n')
734 pushop.ui.debug('try to push obsolete markers to remote\n')
735 repo = pushop.repo
735 repo = pushop.repo
736 remote = pushop.remote
736 remote = pushop.remote
737 pushop.stepsdone.add('obsmarkers')
737 pushop.stepsdone.add('obsmarkers')
738 if pushop.outobsmarkers:
738 if pushop.outobsmarkers:
739 rslts = []
739 rslts = []
740 remotedata = obsolete._pushkeyescape(pushop.outobsmarkers)
740 remotedata = obsolete._pushkeyescape(pushop.outobsmarkers)
741 for key in sorted(remotedata, reverse=True):
741 for key in sorted(remotedata, reverse=True):
742 # reverse sort to ensure we end with dump0
742 # reverse sort to ensure we end with dump0
743 data = remotedata[key]
743 data = remotedata[key]
744 rslts.append(remote.pushkey('obsolete', key, '', data))
744 rslts.append(remote.pushkey('obsolete', key, '', data))
745 if [r for r in rslts if not r]:
745 if [r for r in rslts if not r]:
746 msg = _('failed to push some obsolete markers!\n')
746 msg = _('failed to push some obsolete markers!\n')
747 repo.ui.warn(msg)
747 repo.ui.warn(msg)
748
748
749 def _pushbookmark(pushop):
749 def _pushbookmark(pushop):
750 """Update bookmark position on remote"""
750 """Update bookmark position on remote"""
751 if pushop.cgresult == 0 or 'bookmarks' in pushop.stepsdone:
751 if pushop.cgresult == 0 or 'bookmarks' in pushop.stepsdone:
752 return
752 return
753 pushop.stepsdone.add('bookmarks')
753 pushop.stepsdone.add('bookmarks')
754 ui = pushop.ui
754 ui = pushop.ui
755 remote = pushop.remote
755 remote = pushop.remote
756
756
757 for b, old, new in pushop.outbookmarks:
757 for b, old, new in pushop.outbookmarks:
758 action = 'update'
758 action = 'update'
759 if not old:
759 if not old:
760 action = 'export'
760 action = 'export'
761 elif not new:
761 elif not new:
762 action = 'delete'
762 action = 'delete'
763 if remote.pushkey('bookmarks', b, old, new):
763 if remote.pushkey('bookmarks', b, old, new):
764 ui.status(bookmsgmap[action][0] % b)
764 ui.status(bookmsgmap[action][0] % b)
765 else:
765 else:
766 ui.warn(bookmsgmap[action][1] % b)
766 ui.warn(bookmsgmap[action][1] % b)
767 # discovery can have set the value form invalid entry
767 # discovery can have set the value form invalid entry
768 if pushop.bkresult is not None:
768 if pushop.bkresult is not None:
769 pushop.bkresult = 1
769 pushop.bkresult = 1
770
770
771 class pulloperation(object):
771 class pulloperation(object):
772 """A object that represent a single pull operation
772 """A object that represent a single pull operation
773
773
774 It purpose is to carry push related state and very common operation.
774 It purpose is to carry push related state and very common operation.
775
775
776 A new should be created at the beginning of each pull and discarded
776 A new should be created at the beginning of each pull and discarded
777 afterward.
777 afterward.
778 """
778 """
779
779
780 def __init__(self, repo, remote, heads=None, force=False):
780 def __init__(self, repo, remote, heads=None, force=False, bookmarks=()):
781 # repo we pull into
781 # repo we pull into
782 self.repo = repo
782 self.repo = repo
783 # repo we pull from
783 # repo we pull from
784 self.remote = remote
784 self.remote = remote
785 # revision we try to pull (None is "all")
785 # revision we try to pull (None is "all")
786 self.heads = heads
786 self.heads = heads
787 # bookmark pulled explicitly
788 self.explicitbookmarks = bookmarks
787 # do we force pull?
789 # do we force pull?
788 self.force = force
790 self.force = force
789 # the name the pull transaction
791 # the name the pull transaction
790 self._trname = 'pull\n' + util.hidepassword(remote.url())
792 self._trname = 'pull\n' + util.hidepassword(remote.url())
791 # hold the transaction once created
793 # hold the transaction once created
792 self._tr = None
794 self._tr = None
793 # set of common changeset between local and remote before pull
795 # set of common changeset between local and remote before pull
794 self.common = None
796 self.common = None
795 # set of pulled head
797 # set of pulled head
796 self.rheads = None
798 self.rheads = None
797 # list of missing changeset to fetch remotely
799 # list of missing changeset to fetch remotely
798 self.fetch = None
800 self.fetch = None
801 # remote bookmarks data
802 self.remotebookmarks = None
799 # result of changegroup pulling (used as return code by pull)
803 # result of changegroup pulling (used as return code by pull)
800 self.cgresult = None
804 self.cgresult = None
801 # list of step remaining todo (related to future bundle2 usage)
805 # list of step remaining todo (related to future bundle2 usage)
802 self.todosteps = set(['changegroup', 'phases', 'obsmarkers'])
806 self.todosteps = set(['changegroup', 'phases', 'obsmarkers',
807 'bookmarks'])
803
808
804 @util.propertycache
809 @util.propertycache
805 def pulledsubset(self):
810 def pulledsubset(self):
806 """heads of the set of changeset target by the pull"""
811 """heads of the set of changeset target by the pull"""
807 # compute target subset
812 # compute target subset
808 if self.heads is None:
813 if self.heads is None:
809 # We pulled every thing possible
814 # We pulled every thing possible
810 # sync on everything common
815 # sync on everything common
811 c = set(self.common)
816 c = set(self.common)
812 ret = list(self.common)
817 ret = list(self.common)
813 for n in self.rheads:
818 for n in self.rheads:
814 if n not in c:
819 if n not in c:
815 ret.append(n)
820 ret.append(n)
816 return ret
821 return ret
817 else:
822 else:
818 # We pulled a specific subset
823 # We pulled a specific subset
819 # sync on this subset
824 # sync on this subset
820 return self.heads
825 return self.heads
821
826
822 def gettransaction(self):
827 def gettransaction(self):
823 """get appropriate pull transaction, creating it if needed"""
828 """get appropriate pull transaction, creating it if needed"""
824 if self._tr is None:
829 if self._tr is None:
825 self._tr = self.repo.transaction(self._trname)
830 self._tr = self.repo.transaction(self._trname)
826 return self._tr
831 return self._tr
827
832
828 def closetransaction(self):
833 def closetransaction(self):
829 """close transaction if created"""
834 """close transaction if created"""
830 if self._tr is not None:
835 if self._tr is not None:
831 self._tr.close()
836 self._tr.close()
832
837
833 def releasetransaction(self):
838 def releasetransaction(self):
834 """release transaction if created"""
839 """release transaction if created"""
835 if self._tr is not None:
840 if self._tr is not None:
836 self._tr.release()
841 self._tr.release()
837
842
838 def pull(repo, remote, heads=None, force=False, bookmarks=()):
843 def pull(repo, remote, heads=None, force=False, bookmarks=()):
839 pullop = pulloperation(repo, remote, heads, force)
844 pullop = pulloperation(repo, remote, heads, force, bookmarks=bookmarks)
840 if pullop.remote.local():
845 if pullop.remote.local():
841 missing = set(pullop.remote.requirements) - pullop.repo.supported
846 missing = set(pullop.remote.requirements) - pullop.repo.supported
842 if missing:
847 if missing:
843 msg = _("required features are not"
848 msg = _("required features are not"
844 " supported in the destination:"
849 " supported in the destination:"
845 " %s") % (', '.join(sorted(missing)))
850 " %s") % (', '.join(sorted(missing)))
846 raise util.Abort(msg)
851 raise util.Abort(msg)
847
852
848 remotebookmarks = remote.listkeys('bookmarks')
853 pullop.remotebookmarks = remote.listkeys('bookmarks')
849 lock = pullop.repo.lock()
854 lock = pullop.repo.lock()
850 try:
855 try:
851 _pulldiscovery(pullop)
856 _pulldiscovery(pullop)
852 if (pullop.repo.ui.configbool('experimental', 'bundle2-exp', False)
857 if (pullop.repo.ui.configbool('experimental', 'bundle2-exp', False)
853 and pullop.remote.capable('bundle2-exp')):
858 and pullop.remote.capable('bundle2-exp')):
854 _pullbundle2(pullop)
859 _pullbundle2(pullop)
855 _pullchangeset(pullop)
860 _pullchangeset(pullop)
856 _pullphase(pullop)
861 _pullphase(pullop)
857 _pullobsolete(pullop)
862 _pullobsolete(pullop)
863 _pullbookmarks(pullop)
858 pullop.closetransaction()
864 pullop.closetransaction()
859 finally:
865 finally:
860 pullop.releasetransaction()
866 pullop.releasetransaction()
861 lock.release()
867 lock.release()
862 bookmod.updatefromremote(repo.ui, repo, remotebookmarks, remote.url())
863 # update specified bookmarks
864 if bookmarks:
865 marks = repo._bookmarks
866 writer = repo.ui.status
867 if repo.ui.configbool('ui', 'quietbookmarkmove', False):
868 writer = repo.ui.debug
869 for b in bookmarks:
870 # explicit pull overrides local bookmark if any
871 writer(_("importing bookmark %s\n") % b)
872 marks[b] = repo[remotebookmarks[b]].node()
873 marks.write()
874
868
875 return pullop.cgresult
869 return pullop.cgresult
876
870
877 def _pulldiscovery(pullop):
871 def _pulldiscovery(pullop):
878 """discovery phase for the pull
872 """discovery phase for the pull
879
873
880 Current handle changeset discovery only, will change handle all discovery
874 Current handle changeset discovery only, will change handle all discovery
881 at some point."""
875 at some point."""
882 tmp = discovery.findcommonincoming(pullop.repo.unfiltered(),
876 tmp = discovery.findcommonincoming(pullop.repo.unfiltered(),
883 pullop.remote,
877 pullop.remote,
884 heads=pullop.heads,
878 heads=pullop.heads,
885 force=pullop.force)
879 force=pullop.force)
886 pullop.common, pullop.fetch, pullop.rheads = tmp
880 pullop.common, pullop.fetch, pullop.rheads = tmp
887
881
888 def _pullbundle2(pullop):
882 def _pullbundle2(pullop):
889 """pull data using bundle2
883 """pull data using bundle2
890
884
891 For now, the only supported data are changegroup."""
885 For now, the only supported data are changegroup."""
892 remotecaps = bundle2.bundle2caps(pullop.remote)
886 remotecaps = bundle2.bundle2caps(pullop.remote)
893 kwargs = {'bundlecaps': caps20to10(pullop.repo)}
887 kwargs = {'bundlecaps': caps20to10(pullop.repo)}
894 # pulling changegroup
888 # pulling changegroup
895 pullop.todosteps.remove('changegroup')
889 pullop.todosteps.remove('changegroup')
896
890
897 kwargs['common'] = pullop.common
891 kwargs['common'] = pullop.common
898 kwargs['heads'] = pullop.heads or pullop.rheads
892 kwargs['heads'] = pullop.heads or pullop.rheads
899 kwargs['cg'] = pullop.fetch
893 kwargs['cg'] = pullop.fetch
900 if 'b2x:listkeys' in remotecaps:
894 if 'b2x:listkeys' in remotecaps:
901 kwargs['listkeys'] = ['phase']
895 kwargs['listkeys'] = ['phase']
902 if not pullop.fetch:
896 if not pullop.fetch:
903 pullop.repo.ui.status(_("no changes found\n"))
897 pullop.repo.ui.status(_("no changes found\n"))
904 pullop.cgresult = 0
898 pullop.cgresult = 0
905 else:
899 else:
906 if pullop.heads is None and list(pullop.common) == [nullid]:
900 if pullop.heads is None and list(pullop.common) == [nullid]:
907 pullop.repo.ui.status(_("requesting all changes\n"))
901 pullop.repo.ui.status(_("requesting all changes\n"))
908 if obsolete._enabled:
902 if obsolete._enabled:
909 remoteversions = bundle2.obsmarkersversion(remotecaps)
903 remoteversions = bundle2.obsmarkersversion(remotecaps)
910 if obsolete.commonversion(remoteversions) is not None:
904 if obsolete.commonversion(remoteversions) is not None:
911 kwargs['obsmarkers'] = True
905 kwargs['obsmarkers'] = True
912 pullop.todosteps.remove('obsmarkers')
906 pullop.todosteps.remove('obsmarkers')
913 _pullbundle2extraprepare(pullop, kwargs)
907 _pullbundle2extraprepare(pullop, kwargs)
914 if kwargs.keys() == ['format']:
908 if kwargs.keys() == ['format']:
915 return # nothing to pull
909 return # nothing to pull
916 bundle = pullop.remote.getbundle('pull', **kwargs)
910 bundle = pullop.remote.getbundle('pull', **kwargs)
917 try:
911 try:
918 op = bundle2.processbundle(pullop.repo, bundle, pullop.gettransaction)
912 op = bundle2.processbundle(pullop.repo, bundle, pullop.gettransaction)
919 except error.BundleValueError, exc:
913 except error.BundleValueError, exc:
920 raise util.Abort('missing support for %s' % exc)
914 raise util.Abort('missing support for %s' % exc)
921
915
922 if pullop.fetch:
916 if pullop.fetch:
923 assert len(op.records['changegroup']) == 1
917 assert len(op.records['changegroup']) == 1
924 pullop.cgresult = op.records['changegroup'][0]['return']
918 pullop.cgresult = op.records['changegroup'][0]['return']
925
919
926 # processing phases change
920 # processing phases change
927 for namespace, value in op.records['listkeys']:
921 for namespace, value in op.records['listkeys']:
928 if namespace == 'phases':
922 if namespace == 'phases':
929 _pullapplyphases(pullop, value)
923 _pullapplyphases(pullop, value)
930
924
931 def _pullbundle2extraprepare(pullop, kwargs):
925 def _pullbundle2extraprepare(pullop, kwargs):
932 """hook function so that extensions can extend the getbundle call"""
926 """hook function so that extensions can extend the getbundle call"""
933 pass
927 pass
934
928
935 def _pullchangeset(pullop):
929 def _pullchangeset(pullop):
936 """pull changeset from unbundle into the local repo"""
930 """pull changeset from unbundle into the local repo"""
937 # We delay the open of the transaction as late as possible so we
931 # We delay the open of the transaction as late as possible so we
938 # don't open transaction for nothing or you break future useful
932 # don't open transaction for nothing or you break future useful
939 # rollback call
933 # rollback call
940 if 'changegroup' not in pullop.todosteps:
934 if 'changegroup' not in pullop.todosteps:
941 return
935 return
942 pullop.todosteps.remove('changegroup')
936 pullop.todosteps.remove('changegroup')
943 if not pullop.fetch:
937 if not pullop.fetch:
944 pullop.repo.ui.status(_("no changes found\n"))
938 pullop.repo.ui.status(_("no changes found\n"))
945 pullop.cgresult = 0
939 pullop.cgresult = 0
946 return
940 return
947 pullop.gettransaction()
941 pullop.gettransaction()
948 if pullop.heads is None and list(pullop.common) == [nullid]:
942 if pullop.heads is None and list(pullop.common) == [nullid]:
949 pullop.repo.ui.status(_("requesting all changes\n"))
943 pullop.repo.ui.status(_("requesting all changes\n"))
950 elif pullop.heads is None and pullop.remote.capable('changegroupsubset'):
944 elif pullop.heads is None and pullop.remote.capable('changegroupsubset'):
951 # issue1320, avoid a race if remote changed after discovery
945 # issue1320, avoid a race if remote changed after discovery
952 pullop.heads = pullop.rheads
946 pullop.heads = pullop.rheads
953
947
954 if pullop.remote.capable('getbundle'):
948 if pullop.remote.capable('getbundle'):
955 # TODO: get bundlecaps from remote
949 # TODO: get bundlecaps from remote
956 cg = pullop.remote.getbundle('pull', common=pullop.common,
950 cg = pullop.remote.getbundle('pull', common=pullop.common,
957 heads=pullop.heads or pullop.rheads)
951 heads=pullop.heads or pullop.rheads)
958 elif pullop.heads is None:
952 elif pullop.heads is None:
959 cg = pullop.remote.changegroup(pullop.fetch, 'pull')
953 cg = pullop.remote.changegroup(pullop.fetch, 'pull')
960 elif not pullop.remote.capable('changegroupsubset'):
954 elif not pullop.remote.capable('changegroupsubset'):
961 raise util.Abort(_("partial pull cannot be done because "
955 raise util.Abort(_("partial pull cannot be done because "
962 "other repository doesn't support "
956 "other repository doesn't support "
963 "changegroupsubset."))
957 "changegroupsubset."))
964 else:
958 else:
965 cg = pullop.remote.changegroupsubset(pullop.fetch, pullop.heads, 'pull')
959 cg = pullop.remote.changegroupsubset(pullop.fetch, pullop.heads, 'pull')
966 pullop.cgresult = changegroup.addchangegroup(pullop.repo, cg, 'pull',
960 pullop.cgresult = changegroup.addchangegroup(pullop.repo, cg, 'pull',
967 pullop.remote.url())
961 pullop.remote.url())
968
962
969 def _pullphase(pullop):
963 def _pullphase(pullop):
970 # Get remote phases data from remote
964 # Get remote phases data from remote
971 if 'phases' not in pullop.todosteps:
965 if 'phases' not in pullop.todosteps:
972 return
966 return
973 remotephases = pullop.remote.listkeys('phases')
967 remotephases = pullop.remote.listkeys('phases')
974 _pullapplyphases(pullop, remotephases)
968 _pullapplyphases(pullop, remotephases)
975
969
976 def _pullapplyphases(pullop, remotephases):
970 def _pullapplyphases(pullop, remotephases):
977 """apply phase movement from observed remote state"""
971 """apply phase movement from observed remote state"""
978 pullop.todosteps.remove('phases')
972 pullop.todosteps.remove('phases')
979 publishing = bool(remotephases.get('publishing', False))
973 publishing = bool(remotephases.get('publishing', False))
980 if remotephases and not publishing:
974 if remotephases and not publishing:
981 # remote is new and unpublishing
975 # remote is new and unpublishing
982 pheads, _dr = phases.analyzeremotephases(pullop.repo,
976 pheads, _dr = phases.analyzeremotephases(pullop.repo,
983 pullop.pulledsubset,
977 pullop.pulledsubset,
984 remotephases)
978 remotephases)
985 dheads = pullop.pulledsubset
979 dheads = pullop.pulledsubset
986 else:
980 else:
987 # Remote is old or publishing all common changesets
981 # Remote is old or publishing all common changesets
988 # should be seen as public
982 # should be seen as public
989 pheads = pullop.pulledsubset
983 pheads = pullop.pulledsubset
990 dheads = []
984 dheads = []
991 unfi = pullop.repo.unfiltered()
985 unfi = pullop.repo.unfiltered()
992 phase = unfi._phasecache.phase
986 phase = unfi._phasecache.phase
993 rev = unfi.changelog.nodemap.get
987 rev = unfi.changelog.nodemap.get
994 public = phases.public
988 public = phases.public
995 draft = phases.draft
989 draft = phases.draft
996
990
997 # exclude changesets already public locally and update the others
991 # exclude changesets already public locally and update the others
998 pheads = [pn for pn in pheads if phase(unfi, rev(pn)) > public]
992 pheads = [pn for pn in pheads if phase(unfi, rev(pn)) > public]
999 if pheads:
993 if pheads:
1000 tr = pullop.gettransaction()
994 tr = pullop.gettransaction()
1001 phases.advanceboundary(pullop.repo, tr, public, pheads)
995 phases.advanceboundary(pullop.repo, tr, public, pheads)
1002
996
1003 # exclude changesets already draft locally and update the others
997 # exclude changesets already draft locally and update the others
1004 dheads = [pn for pn in dheads if phase(unfi, rev(pn)) > draft]
998 dheads = [pn for pn in dheads if phase(unfi, rev(pn)) > draft]
1005 if dheads:
999 if dheads:
1006 tr = pullop.gettransaction()
1000 tr = pullop.gettransaction()
1007 phases.advanceboundary(pullop.repo, tr, draft, dheads)
1001 phases.advanceboundary(pullop.repo, tr, draft, dheads)
1008
1002
1003 def _pullbookmarks(pullop):
1004 """process the remote bookmark information to update the local one"""
1005 if 'bookmarks' not in pullop.todosteps:
1006 return
1007 pullop.todosteps.remove('bookmarks')
1008 repo = pullop.repo
1009 remotebookmarks = pullop.remotebookmarks
1010 bookmod.updatefromremote(repo.ui, repo, remotebookmarks,
1011 pullop.remote.url())
1012 # update specified bookmarks
1013 if pullop.explicitbookmarks:
1014 marks = repo._bookmarks
1015 writer = repo.ui.status
1016 if repo.ui.configbool('ui', 'quietbookmarkmove', False):
1017 writer = repo.ui.debug
1018 for b in pullop.explicitbookmarks:
1019 # explicit pull overrides local bookmark if any
1020 writer(_("importing bookmark %s\n") % b)
1021 marks[b] = repo[remotebookmarks[b]].node()
1022 marks.write()
1023
1009 def _pullobsolete(pullop):
1024 def _pullobsolete(pullop):
1010 """utility function to pull obsolete markers from a remote
1025 """utility function to pull obsolete markers from a remote
1011
1026
1012 The `gettransaction` is function that return the pull transaction, creating
1027 The `gettransaction` is function that return the pull transaction, creating
1013 one if necessary. We return the transaction to inform the calling code that
1028 one if necessary. We return the transaction to inform the calling code that
1014 a new transaction have been created (when applicable).
1029 a new transaction have been created (when applicable).
1015
1030
1016 Exists mostly to allow overriding for experimentation purpose"""
1031 Exists mostly to allow overriding for experimentation purpose"""
1017 if 'obsmarkers' not in pullop.todosteps:
1032 if 'obsmarkers' not in pullop.todosteps:
1018 return
1033 return
1019 pullop.todosteps.remove('obsmarkers')
1034 pullop.todosteps.remove('obsmarkers')
1020 tr = None
1035 tr = None
1021 if obsolete._enabled:
1036 if obsolete._enabled:
1022 pullop.repo.ui.debug('fetching remote obsolete markers\n')
1037 pullop.repo.ui.debug('fetching remote obsolete markers\n')
1023 remoteobs = pullop.remote.listkeys('obsolete')
1038 remoteobs = pullop.remote.listkeys('obsolete')
1024 if 'dump0' in remoteobs:
1039 if 'dump0' in remoteobs:
1025 tr = pullop.gettransaction()
1040 tr = pullop.gettransaction()
1026 for key in sorted(remoteobs, reverse=True):
1041 for key in sorted(remoteobs, reverse=True):
1027 if key.startswith('dump'):
1042 if key.startswith('dump'):
1028 data = base85.b85decode(remoteobs[key])
1043 data = base85.b85decode(remoteobs[key])
1029 pullop.repo.obsstore.mergemarkers(tr, data)
1044 pullop.repo.obsstore.mergemarkers(tr, data)
1030 pullop.repo.invalidatevolatilesets()
1045 pullop.repo.invalidatevolatilesets()
1031 return tr
1046 return tr
1032
1047
1033 def caps20to10(repo):
1048 def caps20to10(repo):
1034 """return a set with appropriate options to use bundle20 during getbundle"""
1049 """return a set with appropriate options to use bundle20 during getbundle"""
1035 caps = set(['HG2X'])
1050 caps = set(['HG2X'])
1036 capsblob = bundle2.encodecaps(bundle2.getrepocaps(repo))
1051 capsblob = bundle2.encodecaps(bundle2.getrepocaps(repo))
1037 caps.add('bundle2=' + urllib.quote(capsblob))
1052 caps.add('bundle2=' + urllib.quote(capsblob))
1038 return caps
1053 return caps
1039
1054
1040 # List of names of steps to perform for a bundle2 for getbundle, order matters.
1055 # List of names of steps to perform for a bundle2 for getbundle, order matters.
1041 getbundle2partsorder = []
1056 getbundle2partsorder = []
1042
1057
1043 # Mapping between step name and function
1058 # Mapping between step name and function
1044 #
1059 #
1045 # This exists to help extensions wrap steps if necessary
1060 # This exists to help extensions wrap steps if necessary
1046 getbundle2partsmapping = {}
1061 getbundle2partsmapping = {}
1047
1062
1048 def getbundle2partsgenerator(stepname):
1063 def getbundle2partsgenerator(stepname):
1049 """decorator for function generating bundle2 part for getbundle
1064 """decorator for function generating bundle2 part for getbundle
1050
1065
1051 The function is added to the step -> function mapping and appended to the
1066 The function is added to the step -> function mapping and appended to the
1052 list of steps. Beware that decorated functions will be added in order
1067 list of steps. Beware that decorated functions will be added in order
1053 (this may matter).
1068 (this may matter).
1054
1069
1055 You can only use this decorator for new steps, if you want to wrap a step
1070 You can only use this decorator for new steps, if you want to wrap a step
1056 from an extension, attack the getbundle2partsmapping dictionary directly."""
1071 from an extension, attack the getbundle2partsmapping dictionary directly."""
1057 def dec(func):
1072 def dec(func):
1058 assert stepname not in getbundle2partsmapping
1073 assert stepname not in getbundle2partsmapping
1059 getbundle2partsmapping[stepname] = func
1074 getbundle2partsmapping[stepname] = func
1060 getbundle2partsorder.append(stepname)
1075 getbundle2partsorder.append(stepname)
1061 return func
1076 return func
1062 return dec
1077 return dec
1063
1078
1064 def getbundle(repo, source, heads=None, common=None, bundlecaps=None,
1079 def getbundle(repo, source, heads=None, common=None, bundlecaps=None,
1065 **kwargs):
1080 **kwargs):
1066 """return a full bundle (with potentially multiple kind of parts)
1081 """return a full bundle (with potentially multiple kind of parts)
1067
1082
1068 Could be a bundle HG10 or a bundle HG2X depending on bundlecaps
1083 Could be a bundle HG10 or a bundle HG2X depending on bundlecaps
1069 passed. For now, the bundle can contain only changegroup, but this will
1084 passed. For now, the bundle can contain only changegroup, but this will
1070 changes when more part type will be available for bundle2.
1085 changes when more part type will be available for bundle2.
1071
1086
1072 This is different from changegroup.getchangegroup that only returns an HG10
1087 This is different from changegroup.getchangegroup that only returns an HG10
1073 changegroup bundle. They may eventually get reunited in the future when we
1088 changegroup bundle. They may eventually get reunited in the future when we
1074 have a clearer idea of the API we what to query different data.
1089 have a clearer idea of the API we what to query different data.
1075
1090
1076 The implementation is at a very early stage and will get massive rework
1091 The implementation is at a very early stage and will get massive rework
1077 when the API of bundle is refined.
1092 when the API of bundle is refined.
1078 """
1093 """
1079 # bundle10 case
1094 # bundle10 case
1080 if bundlecaps is None or 'HG2X' not in bundlecaps:
1095 if bundlecaps is None or 'HG2X' not in bundlecaps:
1081 if bundlecaps and not kwargs.get('cg', True):
1096 if bundlecaps and not kwargs.get('cg', True):
1082 raise ValueError(_('request for bundle10 must include changegroup'))
1097 raise ValueError(_('request for bundle10 must include changegroup'))
1083
1098
1084 if kwargs:
1099 if kwargs:
1085 raise ValueError(_('unsupported getbundle arguments: %s')
1100 raise ValueError(_('unsupported getbundle arguments: %s')
1086 % ', '.join(sorted(kwargs.keys())))
1101 % ', '.join(sorted(kwargs.keys())))
1087 return changegroup.getchangegroup(repo, source, heads=heads,
1102 return changegroup.getchangegroup(repo, source, heads=heads,
1088 common=common, bundlecaps=bundlecaps)
1103 common=common, bundlecaps=bundlecaps)
1089
1104
1090 # bundle20 case
1105 # bundle20 case
1091 b2caps = {}
1106 b2caps = {}
1092 for bcaps in bundlecaps:
1107 for bcaps in bundlecaps:
1093 if bcaps.startswith('bundle2='):
1108 if bcaps.startswith('bundle2='):
1094 blob = urllib.unquote(bcaps[len('bundle2='):])
1109 blob = urllib.unquote(bcaps[len('bundle2='):])
1095 b2caps.update(bundle2.decodecaps(blob))
1110 b2caps.update(bundle2.decodecaps(blob))
1096 bundler = bundle2.bundle20(repo.ui, b2caps)
1111 bundler = bundle2.bundle20(repo.ui, b2caps)
1097
1112
1098 for name in getbundle2partsorder:
1113 for name in getbundle2partsorder:
1099 func = getbundle2partsmapping[name]
1114 func = getbundle2partsmapping[name]
1100 kwargs['heads'] = heads
1115 kwargs['heads'] = heads
1101 kwargs['common'] = common
1116 kwargs['common'] = common
1102 func(bundler, repo, source, bundlecaps=bundlecaps, b2caps=b2caps,
1117 func(bundler, repo, source, bundlecaps=bundlecaps, b2caps=b2caps,
1103 **kwargs)
1118 **kwargs)
1104
1119
1105 return util.chunkbuffer(bundler.getchunks())
1120 return util.chunkbuffer(bundler.getchunks())
1106
1121
1107 @getbundle2partsgenerator('changegroup')
1122 @getbundle2partsgenerator('changegroup')
1108 def _getbundlechangegrouppart(bundler, repo, source, bundlecaps=None,
1123 def _getbundlechangegrouppart(bundler, repo, source, bundlecaps=None,
1109 b2caps=None, heads=None, common=None, **kwargs):
1124 b2caps=None, heads=None, common=None, **kwargs):
1110 """add a changegroup part to the requested bundle"""
1125 """add a changegroup part to the requested bundle"""
1111 cg = None
1126 cg = None
1112 if kwargs.get('cg', True):
1127 if kwargs.get('cg', True):
1113 # build changegroup bundle here.
1128 # build changegroup bundle here.
1114 cg = changegroup.getchangegroup(repo, source, heads=heads,
1129 cg = changegroup.getchangegroup(repo, source, heads=heads,
1115 common=common, bundlecaps=bundlecaps)
1130 common=common, bundlecaps=bundlecaps)
1116
1131
1117 if cg:
1132 if cg:
1118 bundler.newpart('b2x:changegroup', data=cg.getchunks())
1133 bundler.newpart('b2x:changegroup', data=cg.getchunks())
1119
1134
1120 @getbundle2partsgenerator('listkeys')
1135 @getbundle2partsgenerator('listkeys')
1121 def _getbundlelistkeysparts(bundler, repo, source, bundlecaps=None,
1136 def _getbundlelistkeysparts(bundler, repo, source, bundlecaps=None,
1122 b2caps=None, **kwargs):
1137 b2caps=None, **kwargs):
1123 """add parts containing listkeys namespaces to the requested bundle"""
1138 """add parts containing listkeys namespaces to the requested bundle"""
1124 listkeys = kwargs.get('listkeys', ())
1139 listkeys = kwargs.get('listkeys', ())
1125 for namespace in listkeys:
1140 for namespace in listkeys:
1126 part = bundler.newpart('b2x:listkeys')
1141 part = bundler.newpart('b2x:listkeys')
1127 part.addparam('namespace', namespace)
1142 part.addparam('namespace', namespace)
1128 keys = repo.listkeys(namespace).items()
1143 keys = repo.listkeys(namespace).items()
1129 part.data = pushkey.encodekeys(keys)
1144 part.data = pushkey.encodekeys(keys)
1130
1145
1131 @getbundle2partsgenerator('obsmarkers')
1146 @getbundle2partsgenerator('obsmarkers')
1132 def _getbundleobsmarkerpart(bundler, repo, source, bundlecaps=None,
1147 def _getbundleobsmarkerpart(bundler, repo, source, bundlecaps=None,
1133 b2caps=None, heads=None, **kwargs):
1148 b2caps=None, heads=None, **kwargs):
1134 """add an obsolescence markers part to the requested bundle"""
1149 """add an obsolescence markers part to the requested bundle"""
1135 if kwargs.get('obsmarkers', False):
1150 if kwargs.get('obsmarkers', False):
1136 if heads is None:
1151 if heads is None:
1137 heads = repo.heads()
1152 heads = repo.heads()
1138 subset = [c.node() for c in repo.set('::%ln', heads)]
1153 subset = [c.node() for c in repo.set('::%ln', heads)]
1139 markers = repo.obsstore.relevantmarkers(subset)
1154 markers = repo.obsstore.relevantmarkers(subset)
1140 buildobsmarkerspart(bundler, markers)
1155 buildobsmarkerspart(bundler, markers)
1141
1156
1142 @getbundle2partsgenerator('extra')
1157 @getbundle2partsgenerator('extra')
1143 def _getbundleextrapart(bundler, repo, source, bundlecaps=None,
1158 def _getbundleextrapart(bundler, repo, source, bundlecaps=None,
1144 b2caps=None, **kwargs):
1159 b2caps=None, **kwargs):
1145 """hook function to let extensions add parts to the requested bundle"""
1160 """hook function to let extensions add parts to the requested bundle"""
1146 pass
1161 pass
1147
1162
1148 def check_heads(repo, their_heads, context):
1163 def check_heads(repo, their_heads, context):
1149 """check if the heads of a repo have been modified
1164 """check if the heads of a repo have been modified
1150
1165
1151 Used by peer for unbundling.
1166 Used by peer for unbundling.
1152 """
1167 """
1153 heads = repo.heads()
1168 heads = repo.heads()
1154 heads_hash = util.sha1(''.join(sorted(heads))).digest()
1169 heads_hash = util.sha1(''.join(sorted(heads))).digest()
1155 if not (their_heads == ['force'] or their_heads == heads or
1170 if not (their_heads == ['force'] or their_heads == heads or
1156 their_heads == ['hashed', heads_hash]):
1171 their_heads == ['hashed', heads_hash]):
1157 # someone else committed/pushed/unbundled while we
1172 # someone else committed/pushed/unbundled while we
1158 # were transferring data
1173 # were transferring data
1159 raise error.PushRaced('repository changed while %s - '
1174 raise error.PushRaced('repository changed while %s - '
1160 'please try again' % context)
1175 'please try again' % context)
1161
1176
1162 def unbundle(repo, cg, heads, source, url):
1177 def unbundle(repo, cg, heads, source, url):
1163 """Apply a bundle to a repo.
1178 """Apply a bundle to a repo.
1164
1179
1165 this function makes sure the repo is locked during the application and have
1180 this function makes sure the repo is locked during the application and have
1166 mechanism to check that no push race occurred between the creation of the
1181 mechanism to check that no push race occurred between the creation of the
1167 bundle and its application.
1182 bundle and its application.
1168
1183
1169 If the push was raced as PushRaced exception is raised."""
1184 If the push was raced as PushRaced exception is raised."""
1170 r = 0
1185 r = 0
1171 # need a transaction when processing a bundle2 stream
1186 # need a transaction when processing a bundle2 stream
1172 tr = None
1187 tr = None
1173 lock = repo.lock()
1188 lock = repo.lock()
1174 try:
1189 try:
1175 check_heads(repo, heads, 'uploading changes')
1190 check_heads(repo, heads, 'uploading changes')
1176 # push can proceed
1191 # push can proceed
1177 if util.safehasattr(cg, 'params'):
1192 if util.safehasattr(cg, 'params'):
1178 try:
1193 try:
1179 tr = repo.transaction('unbundle')
1194 tr = repo.transaction('unbundle')
1180 tr.hookargs['bundle2-exp'] = '1'
1195 tr.hookargs['bundle2-exp'] = '1'
1181 r = bundle2.processbundle(repo, cg, lambda: tr).reply
1196 r = bundle2.processbundle(repo, cg, lambda: tr).reply
1182 cl = repo.unfiltered().changelog
1197 cl = repo.unfiltered().changelog
1183 p = cl.writepending() and repo.root or ""
1198 p = cl.writepending() and repo.root or ""
1184 repo.hook('b2x-pretransactionclose', throw=True, source=source,
1199 repo.hook('b2x-pretransactionclose', throw=True, source=source,
1185 url=url, pending=p, **tr.hookargs)
1200 url=url, pending=p, **tr.hookargs)
1186 tr.close()
1201 tr.close()
1187 repo.hook('b2x-transactionclose', source=source, url=url,
1202 repo.hook('b2x-transactionclose', source=source, url=url,
1188 **tr.hookargs)
1203 **tr.hookargs)
1189 except Exception, exc:
1204 except Exception, exc:
1190 exc.duringunbundle2 = True
1205 exc.duringunbundle2 = True
1191 raise
1206 raise
1192 else:
1207 else:
1193 r = changegroup.addchangegroup(repo, cg, source, url)
1208 r = changegroup.addchangegroup(repo, cg, source, url)
1194 finally:
1209 finally:
1195 if tr is not None:
1210 if tr is not None:
1196 tr.release()
1211 tr.release()
1197 lock.release()
1212 lock.release()
1198 return r
1213 return r
General Comments 0
You need to be logged in to leave comments. Login now