| stash |
| Restricted Project |
Previously, when serving the contents of a stored bundle, we would explicitly
pick out the changegroup and serve only that. Let's also send along all other
parts that are stored in the bundle.
At the moment the only other parts that are stored in the bundle are the ones in
the partforwardingwhitelist in processparts, which is only treemanifest packs
right now. Later we'll serve bookmarks using this same pattern.
| Automatic diff as part of commit; lint not applicable. |
| Automatic diff as part of commit; unit tests not applicable. |
| else: | else: | ||||
| newcaps.append(cap) | newcaps.append(cap) | ||||
| if not appended: | if not appended: | ||||
| # Not found excludepattern cap. Just append it | # Not found excludepattern cap. Just append it | ||||
| newcaps.append('excludepattern=' + changedfiles) | newcaps.append('excludepattern=' + changedfiles) | ||||
| return newcaps | return newcaps | ||||
| def _rebundle(bundlerepo, bundleroots, unknownhead, version): | def _rebundle(bundlerepo, bundleroots, unknownhead): | ||||
| ''' | ''' | ||||
| Bundle may include more revision then user requested. For example, | Bundle may include more revision then user requested. For example, | ||||
| if user asks for revision but bundle also consists its descendants. | if user asks for revision but bundle also consists its descendants. | ||||
| This function will filter out all revision that user is not requested. | This function will filter out all revision that user is not requested. | ||||
| ''' | ''' | ||||
| parts = [] | |||||
| version = '02' | |||||
| outgoing = discovery.outgoing(bundlerepo, commonheads=bundleroots, | outgoing = discovery.outgoing(bundlerepo, commonheads=bundleroots, | ||||
| missingheads=[unknownhead]) | missingheads=[unknownhead]) | ||||
| outputbundleraw = changegroup.makestream(bundlerepo, outgoing, version, | cgstream = changegroup.makestream(bundlerepo, outgoing, version, 'pull') | ||||
| 'pull') | cgstream = util.chunkbuffer(cgstream).read() | ||||
| return util.chunkbuffer(outputbundleraw).read() | cgpart = bundle2.bundlepart('changegroup', data=cgstream) | ||||
| cgpart.addparam('version', version) | |||||
| parts.append(cgpart) | |||||
| return parts | |||||
| def _getbundleroots(oldrepo, bundlerepo, bundlerevs): | def _getbundleroots(oldrepo, bundlerepo, bundlerevs): | ||||
| cl = bundlerepo.changelog | cl = bundlerepo.changelog | ||||
| bundleroots = [] | bundleroots = [] | ||||
| for rev in bundlerevs: | for rev in bundlerevs: | ||||
| node = cl.node(rev) | node = cl.node(rev) | ||||
| parents = cl.parents(node) | parents = cl.parents(node) | ||||
| for parent in parents: | for parent in parents: | ||||
| # include all revs that exist in the main repo | # include all revs that exist in the main repo | ||||
| # to make sure that bundle may apply client-side | # to make sure that bundle may apply client-side | ||||
| if parent in oldrepo: | if parent in oldrepo: | ||||
| bundleroots.append(parent) | bundleroots.append(parent) | ||||
| return bundleroots | return bundleroots | ||||
| def _needsrebundling(head, bundlerepo): | def _needsrebundling(head, bundlerepo): | ||||
| bundleheads = list(bundlerepo.revs('heads(bundle())')) | bundleheads = list(bundlerepo.revs('heads(bundle())')) | ||||
| return not (len(bundleheads) == 1 and | return not (len(bundleheads) == 1 and | ||||
| bundlerepo[bundleheads[0]].node() == head) | bundlerepo[bundleheads[0]].node() == head) | ||||
| def _generateoutputcgpart(head, bundlerepo, bundleroots, bundlefile): | def _generateoutputparts(head, bundlerepo, bundleroots, bundlefile): | ||||
| '''generates bundle that will be send to the user | '''generates bundle that will be send to the user | ||||
| returns tuple with raw bundle string and bundle type | returns tuple with raw bundle string and bundle type | ||||
| ''' | ''' | ||||
| parts = [] | |||||
| if not _needsrebundling(head, bundlerepo): | if not _needsrebundling(head, bundlerepo): | ||||
| with util.posixfile(bundlefile, "rb") as f: | with util.posixfile(bundlefile, "rb") as f: | ||||
| unbundler = exchange.readbundle(bundlerepo.ui, f, bundlefile) | unbundler = exchange.readbundle(bundlerepo.ui, f, bundlefile) | ||||
| if isinstance(unbundler, changegroup.cg1unpacker): | if isinstance(unbundler, changegroup.cg1unpacker): | ||||
| return (unbundler._stream.read(), '01') | part = bundle2.bundlepart('changegroup', | ||||
| data=unbundler._stream.read()) | |||||
| part.addparam('version', '01') | |||||
| parts.append(part) | |||||
| elif isinstance(unbundler, bundle2.unbundle20): | elif isinstance(unbundler, bundle2.unbundle20): | ||||
| haschangegroup = False | |||||
| for part in unbundler.iterparts(): | for part in unbundler.iterparts(): | ||||
| if part.type == 'changegroup': | if part.type == 'changegroup': | ||||
| version = part.params.get('version', '01') | haschangegroup = True | ||||
| return (part.read(), version) | newpart = bundle2.bundlepart(part.type, data=part.read()) | ||||
| else: | for key, value in part.params.iteritems(): | ||||
| newpart.addparam(key, value) | |||||
| parts.append(newpart) | |||||
| if not haschangegroup: | |||||
| raise error.Abort( | raise error.Abort( | ||||
| 'unexpected bundle without changegroup part, ' + | 'unexpected bundle without changegroup part, ' + | ||||
| 'head: %s' % hex(head), | 'head: %s' % hex(head), | ||||
| hint='report to administrator') | hint='report to administrator') | ||||
| else: | else: | ||||
| raise error.Abort('unknown bundle type') | raise error.Abort('unknown bundle type') | ||||
| else: | else: | ||||
| outputbundleraw = _rebundle(bundlerepo, bundleroots, | parts = _rebundle(bundlerepo, bundleroots, head) | ||||
| head, version='02') | |||||
| return (outputbundleraw, '02') | return parts | ||||
| def getbundlechunks(orig, repo, source, heads=None, bundlecaps=None, **kwargs): | def getbundlechunks(orig, repo, source, heads=None, bundlecaps=None, **kwargs): | ||||
| heads = heads or [] | heads = heads or [] | ||||
| # newheads are parents of roots of scratch bundles that were requested | # newheads are parents of roots of scratch bundles that were requested | ||||
| newphases = {} | newphases = {} | ||||
| scratchbundles = [] | scratchbundles = [] | ||||
| newheads = [] | newheads = [] | ||||
| scratchheads = [] | scratchheads = [] | ||||
| bundleroots = _getbundleroots(repo, bundlerepo, bundlerevs) | bundleroots = _getbundleroots(repo, bundlerepo, bundlerevs) | ||||
| for rev in bundlerevs: | for rev in bundlerevs: | ||||
| node = cl.node(rev) | node = cl.node(rev) | ||||
| newphases[hex(node)] = str(phases.draft) | newphases[hex(node)] = str(phases.draft) | ||||
| nodestobundle[node] = (bundlerepo, bundleroots, | nodestobundle[node] = (bundlerepo, bundleroots, | ||||
| newbundlefile) | newbundlefile) | ||||
| scratchbundles.append( | scratchbundles.append( | ||||
| _generateoutputcgpart(head, *nodestobundle[head])) | _generateoutputparts(head, *nodestobundle[head])) | ||||
| newheads.extend(bundleroots) | newheads.extend(bundleroots) | ||||
| scratchheads.append(head) | scratchheads.append(head) | ||||
| finally: | finally: | ||||
| for bundlerepo, bundlefile in allbundlestocleanup: | for bundlerepo, bundlefile in allbundlestocleanup: | ||||
| bundlerepo.close() | bundlerepo.close() | ||||
| try: | try: | ||||
| os.unlink(bundlefile) | os.unlink(bundlefile) | ||||
| except (IOError, OSError): | except (IOError, OSError): | ||||
| # if we can't cleanup the file then just ignore the error, | # if we can't cleanup the file then just ignore the error, | ||||
| # no need to fail | # no need to fail | ||||
| pass | pass | ||||
| pullfrombundlestore = bool(scratchbundles) | pullfrombundlestore = bool(scratchbundles) | ||||
| wrappedchangegrouppart = False | wrappedchangegrouppart = False | ||||
| wrappedlistkeys = False | wrappedlistkeys = False | ||||
| oldchangegrouppart = exchange.getbundle2partsmapping['changegroup'] | oldchangegrouppart = exchange.getbundle2partsmapping['changegroup'] | ||||
| try: | try: | ||||
| def _changegrouppart(bundler, *args, **kwargs): | def _changegrouppart(bundler, *args, **kwargs): | ||||
| # Order is important here. First add non-scratch part | # Order is important here. First add non-scratch part | ||||
| # and only then add parts with scratch bundles because | # and only then add parts with scratch bundles because | ||||
| # non-scratch part contains parents of roots of scratch bundles. | # non-scratch part contains parents of roots of scratch bundles. | ||||
| result = oldchangegrouppart(bundler, *args, **kwargs) | result = oldchangegrouppart(bundler, *args, **kwargs) | ||||
| for bundle, version in scratchbundles: | for bundle in scratchbundles: | ||||
| part = bundler.newpart('changegroup', data=bundle) | for part in bundle: | ||||
| part.addparam('version', version) | bundler.addpart(part) | ||||
| return result | return result | ||||
| exchange.getbundle2partsmapping['changegroup'] = _changegrouppart | exchange.getbundle2partsmapping['changegroup'] = _changegrouppart | ||||
| wrappedchangegrouppart = True | wrappedchangegrouppart = True | ||||
| def _listkeys(orig, self, namespace): | def _listkeys(orig, self, namespace): | ||||
| origvalues = orig(self, namespace) | origvalues = orig(self, namespace) | ||||
| if namespace == 'phases' and pullfrombundlestore: | if namespace == 'phases' and pullfrombundlestore: | ||||