| hg-reviewers |
These were found by IntelliJ. There are many more, but these seemed
pretty safe.
| Lint Skipped |
| Unit Tests Skipped |
| Commit | Parents | Author | Summary | Date |
|---|---|---|---|---|
| Martin von Zweigbergk | Jan 17 2019, 12:17 PM |
| if a2 == a and b2 == b: | if a2 == a and b2 == b: | ||||
| continue | continue | ||||
| if a2 == b2: | if a2 == b2: | ||||
| continue | continue | ||||
| tries += 1 | tries += 1 | ||||
| try: | try: | ||||
| test1(a, b) | test1(a, b) | ||||
| except Exception as inst: | except Exception: | ||||
| reductions += 1 | reductions += 1 | ||||
| tries = 0 | tries = 0 | ||||
| a = a2 | a = a2 | ||||
| b = b2 | b = b2 | ||||
| print("reduced:", reductions, len(a) + len(b), | print("reduced:", reductions, len(a) + len(b), | ||||
| repr(a), repr(b)) | repr(a), repr(b)) | ||||
| try: | try: | ||||
| return True if no error is found, False otherwise. | return True if no error is found, False otherwise. | ||||
| """ | """ | ||||
| blamecache = None | blamecache = None | ||||
| result = True | result = True | ||||
| try: | try: | ||||
| with opentext(f) as fp: | with opentext(f) as fp: | ||||
| try: | try: | ||||
| pre = post = fp.read() | pre = fp.read() | ||||
| except UnicodeDecodeError as e: | except UnicodeDecodeError as e: | ||||
| print("%s while reading %s" % (e, f)) | print("%s while reading %s" % (e, f)) | ||||
| return result | return result | ||||
| except IOError as e: | except IOError as e: | ||||
| print("Skipping %s, %s" % (f, str(e).split(':', 1)[0])) | print("Skipping %s, %s" % (f, str(e).split(':', 1)[0])) | ||||
| return result | return result | ||||
| for name, match, magic, filters, pats in checks: | for name, match, magic, filters, pats in checks: | ||||
| opts = _byteskwargs(opts) | opts = _byteskwargs(opts) | ||||
| timer, fm = gettimer(ui, opts) | timer, fm = gettimer(ui, opts) | ||||
| path = ui.paths.getpath(dest, default=(b'default-push', b'default')) | path = ui.paths.getpath(dest, default=(b'default-push', b'default')) | ||||
| if not path: | if not path: | ||||
| raise error.Abort((b'default repository not configured!'), | raise error.Abort((b'default repository not configured!'), | ||||
| hint=(b"see 'hg help config.paths'")) | hint=(b"see 'hg help config.paths'")) | ||||
| dest = path.pushloc or path.loc | dest = path.pushloc or path.loc | ||||
| branches = (path.branch, opts.get(b'branch') or []) | |||||
| ui.status((b'analysing phase of %s\n') % util.hidepassword(dest)) | ui.status((b'analysing phase of %s\n') % util.hidepassword(dest)) | ||||
| revs, checkout = hg.addbranchrevs(repo, repo, branches, opts.get(b'rev')) | |||||
| other = hg.peer(repo, opts, dest) | other = hg.peer(repo, opts, dest) | ||||
| # easier to perform discovery through the operation | # easier to perform discovery through the operation | ||||
| op = exchange.pushoperation(repo, other) | op = exchange.pushoperation(repo, other) | ||||
| exchange._pushdiscoverychangeset(op) | exchange._pushdiscoverychangeset(op) | ||||
| remotesubset = op.fallbackheads | remotesubset = op.fallbackheads | ||||
| if not lines: | if not lines: | ||||
| break | break | ||||
| del lines[random.randrange(0, len(lines))] | del lines[random.randrange(0, len(lines))] | ||||
| for __ in xrange(add): | for __ in xrange(add): | ||||
| lines.insert(random.randint(0, len(lines)), makeline()) | lines.insert(random.randint(0, len(lines)), makeline()) | ||||
| path = fctx.path() | path = fctx.path() | ||||
| changes[path] = '\n'.join(lines) + '\n' | changes[path] = '\n'.join(lines) + '\n' | ||||
| for __ in xrange(pick(filesremoved)): | for __ in xrange(pick(filesremoved)): | ||||
| path = random.choice(mfk) | |||||
| for __ in xrange(10): | for __ in xrange(10): | ||||
| path = random.choice(mfk) | path = random.choice(mfk) | ||||
| if path not in changes: | if path not in changes: | ||||
| break | break | ||||
| if filesadded: | if filesadded: | ||||
| dirs = list(pctx.dirs()) | dirs = list(pctx.dirs()) | ||||
| dirs.insert(0, '') | dirs.insert(0, '') | ||||
| for __ in xrange(pick(filesadded)): | for __ in xrange(pick(filesadded)): | ||||
| # the original parent unchanged | # the original parent unchanged | ||||
| nextp1 = None | nextp1 = None | ||||
| for ctx in self.stack: | for ctx in self.stack: | ||||
| memworkingcopy = self._getnewfilecontents(ctx) | memworkingcopy = self._getnewfilecontents(ctx) | ||||
| if not memworkingcopy and not lastcommitted: | if not memworkingcopy and not lastcommitted: | ||||
| # nothing changed, nothing commited | # nothing changed, nothing commited | ||||
| nextp1 = ctx | nextp1 = ctx | ||||
| continue | continue | ||||
| msg = '' | |||||
| if self._willbecomenoop(memworkingcopy, ctx, nextp1): | if self._willbecomenoop(memworkingcopy, ctx, nextp1): | ||||
| # changeset is no longer necessary | # changeset is no longer necessary | ||||
| self.replacemap[ctx.node()] = None | self.replacemap[ctx.node()] = None | ||||
| msg = _('became empty and was dropped') | msg = _('became empty and was dropped') | ||||
| else: | else: | ||||
| # changeset needs re-commit | # changeset needs re-commit | ||||
| nodestr = self._commitsingle(memworkingcopy, ctx, p1=nextp1) | nodestr = self._commitsingle(memworkingcopy, ctx, p1=nextp1) | ||||
| lastcommitted = self.repo[nodestr] | lastcommitted = self.repo[nodestr] | ||||
| finally: | finally: | ||||
| self._inlog = False | self._inlog = False | ||||
| def _log(self, ui, event, msg, opts): | def _log(self, ui, event, msg, opts): | ||||
| default = ui.configdate('devel', 'default-date') | default = ui.configdate('devel', 'default-date') | ||||
| date = dateutil.datestr(default, ui.config('blackbox', 'date-format')) | date = dateutil.datestr(default, ui.config('blackbox', 'date-format')) | ||||
| user = procutil.getuser() | user = procutil.getuser() | ||||
| pid = '%d' % procutil.getpid() | pid = '%d' % procutil.getpid() | ||||
| rev = '(unknown)' | |||||
| changed = '' | changed = '' | ||||
| ctx = self._repo[None] | ctx = self._repo[None] | ||||
| parents = ctx.parents() | parents = ctx.parents() | ||||
| rev = ('+'.join([hex(p.node()) for p in parents])) | rev = ('+'.join([hex(p.node()) for p in parents])) | ||||
| if (ui.configbool('blackbox', 'dirty') and | if (ui.configbool('blackbox', 'dirty') and | ||||
| ctx.dirty(missing=True, merge=False, branch=False)): | ctx.dirty(missing=True, merge=False, branch=False)): | ||||
| changed = '+' | changed = '+' | ||||
| if ui.configbool('blackbox', 'logsource'): | if ui.configbool('blackbox', 'logsource'): | ||||
| maxrev = int(self.revs[0]) | maxrev = int(self.revs[0]) | ||||
| except ValueError: | except ValueError: | ||||
| raise error.Abort(_('revision %s is not a patchset number') | raise error.Abort(_('revision %s is not a patchset number') | ||||
| % self.revs[0]) | % self.revs[0]) | ||||
| d = encoding.getcwd() | d = encoding.getcwd() | ||||
| try: | try: | ||||
| os.chdir(self.path) | os.chdir(self.path) | ||||
| id = None | |||||
| cache = 'update' | cache = 'update' | ||||
| if not self.ui.configbool('convert', 'cvsps.cache'): | if not self.ui.configbool('convert', 'cvsps.cache'): | ||||
| cache = None | cache = None | ||||
| db = cvsps.createlog(self.ui, cache=cache) | db = cvsps.createlog(self.ui, cache=cache) | ||||
| db = cvsps.createchangeset(self.ui, db, | db = cvsps.createchangeset(self.ui, db, | ||||
| fuzz=int(self.ui.config('convert', 'cvsps.fuzz')), | fuzz=int(self.ui.config('convert', 'cvsps.fuzz')), | ||||
| mergeto=self.ui.config('convert', 'cvsps.mergeto'), | mergeto=self.ui.config('convert', 'cvsps.mergeto'), | ||||
| r = self.readp.readline() | r = self.readp.readline() | ||||
| if not r.startswith("Valid-requests"): | if not r.startswith("Valid-requests"): | ||||
| raise error.Abort(_('unexpected response from CVS server ' | raise error.Abort(_('unexpected response from CVS server ' | ||||
| '(expected "Valid-requests", but got %r)') | '(expected "Valid-requests", but got %r)') | ||||
| % r) | % r) | ||||
| if "UseUnchanged" in r: | if "UseUnchanged" in r: | ||||
| self.writep.write("UseUnchanged\n") | self.writep.write("UseUnchanged\n") | ||||
| self.writep.flush() | self.writep.flush() | ||||
| r = self.readp.readline() | self.readp.readline() | ||||
| def getheads(self): | def getheads(self): | ||||
| self._parse() | self._parse() | ||||
| return self.heads | return self.heads | ||||
| def getfile(self, name, rev): | def getfile(self, name, rev): | ||||
| def chunkedread(fp, count): | def chunkedread(fp, count): | ||||
| def getchangedfiles(self, rev, i): | def getchangedfiles(self, rev, i): | ||||
| # This function is only needed to support --filemap | # This function is only needed to support --filemap | ||||
| # ... and we don't support that | # ... and we don't support that | ||||
| raise NotImplementedError | raise NotImplementedError | ||||
| def before(self): | def before(self): | ||||
| # Check if we have a new enough version to use automate stdio | # Check if we have a new enough version to use automate stdio | ||||
| version = 0.0 | |||||
| try: | try: | ||||
| versionstr = self.mtnrunsingle("interface_version") | versionstr = self.mtnrunsingle("interface_version") | ||||
| version = float(versionstr) | version = float(versionstr) | ||||
| except Exception: | except Exception: | ||||
| raise error.Abort(_("unable to determine mtn automate interface " | raise error.Abort(_("unable to determine mtn automate interface " | ||||
| "version")) | "version")) | ||||
| if version >= 12.0: | if version >= 12.0: | ||||
| raise error.Abort(_('svn: branch has no revision %s') | raise error.Abort(_('svn: branch has no revision %s') | ||||
| % to_revnum) | % to_revnum) | ||||
| raise | raise | ||||
| def getfile(self, file, rev): | def getfile(self, file, rev): | ||||
| # TODO: ra.get_file transmits the whole file instead of diffs. | # TODO: ra.get_file transmits the whole file instead of diffs. | ||||
| if file in self.removed: | if file in self.removed: | ||||
| return None, None | return None, None | ||||
| mode = '' | |||||
| try: | try: | ||||
| new_module, revnum = revsplit(rev)[1:] | new_module, revnum = revsplit(rev)[1:] | ||||
| if self.module != new_module: | if self.module != new_module: | ||||
| self.module = new_module | self.module = new_module | ||||
| self.reparent(self.module) | self.reparent(self.module) | ||||
| io = stringio() | io = stringio() | ||||
| info = svn.ra.get_file(self.ra, file, revnum, io) | info = svn.ra.get_file(self.ra, file, revnum, io) | ||||
| data = io.getvalue() | data = io.getvalue() | ||||
| # send back the full content of revmap and linelog, in the future we | # send back the full content of revmap and linelog, in the future we | ||||
| # may want to do some rsync-like fancy updating. | # may want to do some rsync-like fancy updating. | ||||
| # the lastnode check is not necessary if the client and the server | # the lastnode check is not necessary if the client and the server | ||||
| # agree where the main branch is. | # agree where the main branch is. | ||||
| if actx.lastnode != lastnode: | if actx.lastnode != lastnode: | ||||
| for p in [actx.revmappath, actx.linelogpath]: | for p in [actx.revmappath, actx.linelogpath]: | ||||
| if not os.path.exists(p): | if not os.path.exists(p): | ||||
| continue | continue | ||||
| content = '' | |||||
| with open(p, 'rb') as f: | with open(p, 'rb') as f: | ||||
| content = f.read() | content = f.read() | ||||
| vfsbaselen = len(repo.vfs.base + '/') | vfsbaselen = len(repo.vfs.base + '/') | ||||
| relpath = p[vfsbaselen:] | relpath = p[vfsbaselen:] | ||||
| result += '%s\0%d\0%s' % (relpath, len(content), content) | result += '%s\0%d\0%s' % (relpath, len(content), content) | ||||
| return result | return result | ||||
| def _registerwireprotocommand(): | def _registerwireprotocommand(): | ||||
| except Exception as ex: | except Exception as ex: | ||||
| self._repo.ui.debug('fastannotate: falling back to the vanilla ' | self._repo.ui.debug('fastannotate: falling back to the vanilla ' | ||||
| 'annotate: %r\n' % ex) | 'annotate: %r\n' % ex) | ||||
| return orig(self, follow=follow, skiprevs=skiprevs, | return orig(self, follow=follow, skiprevs=skiprevs, | ||||
| diffopts=diffopts) | diffopts=diffopts) | ||||
| def _remotefctxannotate(orig, self, follow=False, skiprevs=None, diffopts=None): | def _remotefctxannotate(orig, self, follow=False, skiprevs=None, diffopts=None): | ||||
| # skipset: a set-like used to test if a fctx needs to be downloaded | # skipset: a set-like used to test if a fctx needs to be downloaded | ||||
| skipset = None | |||||
| with context.fctxannotatecontext(self, follow, diffopts) as ac: | with context.fctxannotatecontext(self, follow, diffopts) as ac: | ||||
| skipset = revmap.revmap(ac.revmappath) | skipset = revmap.revmap(ac.revmappath) | ||||
| return orig(self, follow, skiprevs=skiprevs, diffopts=diffopts, | return orig(self, follow, skiprevs=skiprevs, diffopts=diffopts, | ||||
| prefetchskip=skipset) | prefetchskip=skipset) | ||||
| def replacehgwebannotate(): | def replacehgwebannotate(): | ||||
| extensions.wrapfunction(hgweb.webutil, 'annotate', _hgwebannotate) | extensions.wrapfunction(hgweb.webutil, 'annotate', _hgwebannotate) | ||||
| def replacefctxannotate(): | def replacefctxannotate(): | ||||
| extensions.wrapfunction(hgcontext.basefilectx, 'annotate', _fctxannotate) | extensions.wrapfunction(hgcontext.basefilectx, 'annotate', _fctxannotate) | ||||
| if not clock: | if not clock: | ||||
| if state.walk_on_invalidate: | if state.walk_on_invalidate: | ||||
| return bail('no clock') | return bail('no clock') | ||||
| # Initial NULL clock value, see | # Initial NULL clock value, see | ||||
| # https://facebook.github.io/watchman/docs/clockspec.html | # https://facebook.github.io/watchman/docs/clockspec.html | ||||
| clock = 'c:0:0' | clock = 'c:0:0' | ||||
| notefiles = [] | notefiles = [] | ||||
| def fwarn(f, msg): | |||||
| self._ui.warn('%s: %s\n' % (self.pathto(f), msg)) | |||||
| return False | |||||
| def badtype(mode): | |||||
| kind = _('unknown') | |||||
| if stat.S_ISCHR(mode): | |||||
| kind = _('character device') | |||||
| elif stat.S_ISBLK(mode): | |||||
| kind = _('block device') | |||||
| elif stat.S_ISFIFO(mode): | |||||
| kind = _('fifo') | |||||
| elif stat.S_ISSOCK(mode): | |||||
| kind = _('socket') | |||||
| elif stat.S_ISDIR(mode): | |||||
| kind = _('directory') | |||||
| return _('unsupported file type (type is %s)') % kind | |||||
| ignore = self._ignore | ignore = self._ignore | ||||
| dirignore = self._dirignore | dirignore = self._dirignore | ||||
| if unknown: | if unknown: | ||||
| if _hashignore(ignore) != ignorehash and clock != 'c:0:0': | if _hashignore(ignore) != ignorehash and clock != 'c:0:0': | ||||
| # ignore list changed -- can't rely on Watchman state any more | # ignore list changed -- can't rely on Watchman state any more | ||||
| if state.walk_on_invalidate: | if state.walk_on_invalidate: | ||||
| return bail('ignore rules changed') | return bail('ignore rules changed') | ||||
| notefiles = [] | notefiles = [] | ||||
| def synthesize(vers, opts): | def synthesize(vers, opts): | ||||
| """ Synthesize a capability enabled version response | """ Synthesize a capability enabled version response | ||||
| This is a very limited emulation for relatively recent feature sets | This is a very limited emulation for relatively recent feature sets | ||||
| """ | """ | ||||
| parsed_version = parse_version(vers['version']) | parsed_version = parse_version(vers['version']) | ||||
| vers['capabilities'] = {} | vers['capabilities'] = {} | ||||
| for name in opts['optional']: | for name in opts['optional']: | ||||
| vers['capabilities'][name] = check(parsed_version, name) | vers['capabilities'][name] = check(parsed_version, name) | ||||
| failed = False | |||||
| for name in opts['required']: | for name in opts['required']: | ||||
| have = check(parsed_version, name) | have = check(parsed_version, name) | ||||
| vers['capabilities'][name] = have | vers['capabilities'][name] = have | ||||
| if not have: | if not have: | ||||
| vers['error'] = 'client required capability `' + name + \ | vers['error'] = 'client required capability `' + name + \ | ||||
| '` is not supported by this server' | '` is not supported by this server' | ||||
| return vers | return vers | ||||
| if isinstance(key, (int, long)): | if isinstance(key, (int, long)): | ||||
| return self._values[key] | return self._values[key] | ||||
| elif key.startswith('st_'): | elif key.startswith('st_'): | ||||
| # hack^Wfeature to allow mercurial to use "st_size" to | # hack^Wfeature to allow mercurial to use "st_size" to | ||||
| # reference "size" | # reference "size" | ||||
| key = key[3:] | key = key[3:] | ||||
| try: | try: | ||||
| return self._values[self._keys.index(key)] | return self._values[self._keys.index(key)] | ||||
| except ValueError as ex: | except ValueError: | ||||
| raise KeyError('_BunserDict has no key %s' % key) | raise KeyError('_BunserDict has no key %s' % key) | ||||
| def __len__(self): | def __len__(self): | ||||
| return len(self._keys) | return len(self._keys) | ||||
| class Bunser(object): | class Bunser(object): | ||||
| def __init__(self, mutable=True, value_encoding=None, value_errors=None): | def __init__(self, mutable=True, value_encoding=None, value_errors=None): | ||||
| self.mutable = mutable | self.mutable = mutable | ||||
| elif val_type == BSER_TEMPLATE: | elif val_type == BSER_TEMPLATE: | ||||
| return self.unser_template(buf, pos) | return self.unser_template(buf, pos) | ||||
| else: | else: | ||||
| raise ValueError('unhandled bser opcode 0x%s' % | raise ValueError('unhandled bser opcode 0x%s' % | ||||
| binascii.hexlify(val_type).decode('ascii')) | binascii.hexlify(val_type).decode('ascii')) | ||||
| def _pdu_info_helper(buf): | def _pdu_info_helper(buf): | ||||
| bser_version = -1 | |||||
| if buf[0:2] == EMPTY_HEADER[0:2]: | if buf[0:2] == EMPTY_HEADER[0:2]: | ||||
| bser_version = 1 | bser_version = 1 | ||||
| bser_capabilities = 0 | bser_capabilities = 0 | ||||
| expected_len, pos2 = Bunser.unser_int(buf, 2) | expected_len, pos2 = Bunser.unser_int(buf, 2) | ||||
| elif buf[0:2] == EMPTY_HEADER_V2[0:2]: | elif buf[0:2] == EMPTY_HEADER_V2[0:2]: | ||||
| if len(buf) < 8: | if len(buf) < 8: | ||||
| raise ValueError('Invalid BSER header') | raise ValueError('Invalid BSER header') | ||||
| bser_version = 2 | bser_version = 2 | ||||
| cmdoptions = list(cmdoptions) | cmdoptions = list(cmdoptions) | ||||
| opts = {} | opts = {} | ||||
| args = list(args) | args = list(args) | ||||
| while True: | while True: | ||||
| try: | try: | ||||
| args = fancyopts.fancyopts(list(args), cmdoptions, opts, True) | args = fancyopts.fancyopts(list(args), cmdoptions, opts, True) | ||||
| break | break | ||||
| except getopt.GetoptError as ex: | except getopt.GetoptError as ex: | ||||
| flag = None | |||||
| if "requires argument" in ex.msg: | if "requires argument" in ex.msg: | ||||
| raise | raise | ||||
| if ('--' + ex.opt) in ex.msg: | if ('--' + ex.opt) in ex.msg: | ||||
| flag = '--' + ex.opt | flag = '--' + ex.opt | ||||
| elif ('-' + ex.opt) in ex.msg: | elif ('-' + ex.opt) in ex.msg: | ||||
| flag = '-' + ex.opt | flag = '-' + ex.opt | ||||
| else: | else: | ||||
| raise error.Abort(_("unknown option %s") % ex.opt) | raise error.Abort(_("unknown option %s") % ex.opt) | ||||
| # shared between working copies. | # shared between working copies. | ||||
| if sharednamespaces.get(namespace) in self.sharedfeatures: | if sharednamespaces.get(namespace) in self.sharedfeatures: | ||||
| vfs = self.sharedvfs | vfs = self.sharedvfs | ||||
| self._write(vfs, entry) | self._write(vfs, entry) | ||||
| def _write(self, vfs, entry): | def _write(self, vfs, entry): | ||||
| with self.jlock(vfs): | with self.jlock(vfs): | ||||
| version = None | |||||
| # open file in amend mode to ensure it is created if missing | # open file in amend mode to ensure it is created if missing | ||||
| with vfs('namejournal', mode='a+b') as f: | with vfs('namejournal', mode='a+b') as f: | ||||
| f.seek(0, os.SEEK_SET) | f.seek(0, os.SEEK_SET) | ||||
| # Read just enough bytes to get a version number (up to 2 | # Read just enough bytes to get a version number (up to 2 | ||||
| # digits plus separator) | # digits plus separator) | ||||
| version = f.read(3).partition('\0')[0] | version = f.read(3).partition('\0')[0] | ||||
| if version and version != "%d" % storageversion: | if version and version != "%d" % storageversion: | ||||
| # different version of the storage. Exit early (and not | # different version of the storage. Exit early (and not | ||||
| for list in (s.modified, s.added, | for list in (s.modified, s.added, | ||||
| s.deleted, s.clean)] | s.deleted, s.clean)] | ||||
| def warn(files, msg): | def warn(files, msg): | ||||
| for f in files: | for f in files: | ||||
| ui.warn(msg % m.rel(f)) | ui.warn(msg % m.rel(f)) | ||||
| return int(len(files) > 0) | return int(len(files) > 0) | ||||
| result = 0 | |||||
| if after: | if after: | ||||
| remove = deleted | remove = deleted | ||||
| result = warn(modified + added + clean, | result = warn(modified + added + clean, | ||||
| _('not removing %s: file still exists\n')) | _('not removing %s: file still exists\n')) | ||||
| else: | else: | ||||
| remove = deleted + clean | remove = deleted + clean | ||||
| result = warn(modified, _('not removing %s: file is modified (use -f' | result = warn(modified, _('not removing %s: file is modified (use -f' | ||||
| ' to force removal)\n')) | ' to force removal)\n')) | ||||
| # ui.expandpath() leaves 'default-push' and 'default' alone if | # ui.expandpath() leaves 'default-push' and 'default' alone if | ||||
| # they cannot be expanded: fallback to the empty string, | # they cannot be expanded: fallback to the empty string, | ||||
| # meaning the current directory. | # meaning the current directory. | ||||
| if repo is None: | if repo is None: | ||||
| path = ui.expandpath('default') | path = ui.expandpath('default') | ||||
| path, _branches = hg.parseurl(path) | path, _branches = hg.parseurl(path) | ||||
| remote = hg.peer(repo or ui, {}, path) | remote = hg.peer(repo or ui, {}, path) | ||||
| elif path == 'default-push' or path == 'default': | elif path == 'default-push' or path == 'default': | ||||
| path = '' | |||||
| remote = repo | remote = repo | ||||
| else: | else: | ||||
| path, _branches = hg.parseurl(path) | path, _branches = hg.parseurl(path) | ||||
| remote = hg.peer(repo or ui, {}, path) | remote = hg.peer(repo or ui, {}, path) | ||||
| # The path could be a scheme so use Mercurial's normal functionality | # The path could be a scheme so use Mercurial's normal functionality | ||||
| # to resolve the scheme to a repository and use its path | # to resolve the scheme to a repository and use its path | ||||
| path = util.safehasattr(remote, 'url') and remote.url() or remote.path | path = util.safehasattr(remote, 'url') and remote.url() or remote.path | ||||
| If such commit message line is not found, examines all precursors and their | If such commit message line is not found, examines all precursors and their | ||||
| tags. Tags with format like "D1234" are considered a match and the node | tags. Tags with format like "D1234" are considered a match and the node | ||||
| with that tag, and the number after "D" (ex. 1234) will be returned. | with that tag, and the number after "D" (ex. 1234) will be returned. | ||||
| The ``old node``, if not None, is guaranteed to be the last diff of | The ``old node``, if not None, is guaranteed to be the last diff of | ||||
| corresponding Differential Revision, and exist in the repo. | corresponding Differential Revision, and exist in the repo. | ||||
| """ | """ | ||||
| url, token = readurltoken(repo) | |||||
| unfi = repo.unfiltered() | unfi = repo.unfiltered() | ||||
| nodemap = unfi.changelog.nodemap | nodemap = unfi.changelog.nodemap | ||||
| result = {} # {node: (oldnode?, lastdiff?, drev)} | result = {} # {node: (oldnode?, lastdiff?, drev)} | ||||
| toconfirm = {} # {node: (force, {precnode}, drev)} | toconfirm = {} # {node: (force, {precnode}, drev)} | ||||
| for node in nodelist: | for node in nodelist: | ||||
| ctx = unfi[node] | ctx = unfi[node] | ||||
| # For tags like "D123", put them into "toconfirm" to verify later | # For tags like "D123", put them into "toconfirm" to verify later | ||||
| for oldns, newn in replacements.iteritems(): | for oldns, newn in replacements.iteritems(): | ||||
| for oldn in oldns: | for oldn in oldns: | ||||
| changes[hf(oldn)] = fl([hf(n) for n in newn], name='node') | changes[hf(oldn)] = fl([hf(n) for n in newn], name='node') | ||||
| nodechanges = fd(changes, key="oldnode", value="newnodes") | nodechanges = fd(changes, key="oldnode", value="newnodes") | ||||
| fm.data(nodechanges=nodechanges) | fm.data(nodechanges=nodechanges) | ||||
| def pullrebase(orig, ui, repo, *args, **opts): | def pullrebase(orig, ui, repo, *args, **opts): | ||||
| 'Call rebase after pull if the latter has been invoked with --rebase' | 'Call rebase after pull if the latter has been invoked with --rebase' | ||||
| ret = None | |||||
| if opts.get(r'rebase'): | if opts.get(r'rebase'): | ||||
| if ui.configbool('commands', 'rebase.requiredest'): | if ui.configbool('commands', 'rebase.requiredest'): | ||||
| msg = _('rebase destination required by configuration') | msg = _('rebase destination required by configuration') | ||||
| hint = _('use hg pull followed by hg rebase -d DEST') | hint = _('use hg pull followed by hg rebase -d DEST') | ||||
| raise error.Abort(msg, hint=hint) | raise error.Abort(msg, hint=hint) | ||||
| with repo.wlock(), repo.lock(): | with repo.wlock(), repo.lock(): | ||||
| if opts.get(r'update'): | if opts.get(r'update'): | ||||
| except Exception: | except Exception: | ||||
| pass | pass | ||||
| try: | try: | ||||
| self.opener.unlink(self.idxpath) | self.opener.unlink(self.idxpath) | ||||
| except Exception: | except Exception: | ||||
| pass | pass | ||||
| def writeindex(self): | def writeindex(self): | ||||
| rawindex = '' | |||||
| largefanout = len(self.entries) > SMALLFANOUTCUTOFF | largefanout = len(self.entries) > SMALLFANOUTCUTOFF | ||||
| if largefanout: | if largefanout: | ||||
| params = indexparams(LARGEFANOUTPREFIX, self.VERSION) | params = indexparams(LARGEFANOUTPREFIX, self.VERSION) | ||||
| else: | else: | ||||
| params = indexparams(SMALLFANOUTPREFIX, self.VERSION) | params = indexparams(SMALLFANOUTPREFIX, self.VERSION) | ||||
| fanouttable = [EMPTYFANOUT] * params.fanoutcount | fanouttable = [EMPTYFANOUT] * params.fanoutcount | ||||
| mid = start + (end - start) / 2 | mid = start + (end - start) / 2 | ||||
| mid = mid - ((mid - params.indexstart) % entrylen) | mid = mid - ((mid - params.indexstart) % entrylen) | ||||
| midnode = index[mid:mid + NODELENGTH] | midnode = index[mid:mid + NODELENGTH] | ||||
| if midnode == node: | if midnode == node: | ||||
| entry = index[mid:mid + entrylen] | entry = index[mid:mid + entrylen] | ||||
| break | break | ||||
| if node > midnode: | if node > midnode: | ||||
| start = mid | start = mid | ||||
| startnode = midnode | |||||
| elif node < midnode: | elif node < midnode: | ||||
| end = mid | end = mid | ||||
| endnode = midnode | |||||
| else: | else: | ||||
| return None | return None | ||||
| return struct.unpack(self.INDEXFORMAT, entry) | return struct.unpack(self.INDEXFORMAT, entry) | ||||
| def markledger(self, ledger, options=None): | def markledger(self, ledger, options=None): | ||||
| for filename, node in self: | for filename, node in self: | ||||
| ledger.markdataentry(self, filename, node) | ledger.markdataentry(self, filename, node) | ||||
| file) | file) | ||||
| ui.status("%s %s\n" % (key, os.path.relpath(filepath, | ui.status("%s %s\n" % (key, os.path.relpath(filepath, | ||||
| path))) | path))) | ||||
| def _decompressblob(raw): | def _decompressblob(raw): | ||||
| return zlib.decompress(raw) | return zlib.decompress(raw) | ||||
| def parsefileblob(path, decompress): | def parsefileblob(path, decompress): | ||||
| raw = None | |||||
| f = open(path, "rb") | f = open(path, "rb") | ||||
| try: | try: | ||||
| raw = f.read() | raw = f.read() | ||||
| finally: | finally: | ||||
| f.close() | f.close() | ||||
| if decompress: | if decompress: | ||||
| raw = _decompressblob(raw) | raw = _decompressblob(raw) | ||||
| while start < end - entrylen: | while start < end - entrylen: | ||||
| mid = start + (end - start) // 2 | mid = start + (end - start) // 2 | ||||
| mid = mid - ((mid - origstart) % entrylen) | mid = mid - ((mid - origstart) % entrylen) | ||||
| midnode = self._index[mid:mid + NODELENGTH] | midnode = self._index[mid:mid + NODELENGTH] | ||||
| if midnode == node: | if midnode == node: | ||||
| return self._index[mid:mid + entrylen] | return self._index[mid:mid + entrylen] | ||||
| if node > midnode: | if node > midnode: | ||||
| start = mid | start = mid | ||||
| startnode = midnode | |||||
| elif node < midnode: | elif node < midnode: | ||||
| end = mid | end = mid | ||||
| endnode = midnode | |||||
| return None | return None | ||||
| def markledger(self, ledger, options=None): | def markledger(self, ledger, options=None): | ||||
| for filename, node in self: | for filename, node in self: | ||||
| ledger.markhistoryentry(self, filename, node) | ledger.markhistoryentry(self, filename, node) | ||||
| def cleanup(self, ledger): | def cleanup(self, ledger): | ||||
| entries = ledger.sources.get(self, []) | entries = ledger.sources.get(self, []) | ||||
| nodeindexentries.append(struct.pack(nodeindexformat, node, | nodeindexentries.append(struct.pack(nodeindexformat, node, | ||||
| location)) | location)) | ||||
| nodecount += 1 | nodecount += 1 | ||||
| nodeindexoffset += len(nodelocations) * nodeindexlength | nodeindexoffset += len(nodelocations) * nodeindexlength | ||||
| fileindexentries.append(rawentry) | fileindexentries.append(rawentry) | ||||
| nodecountraw = '' | |||||
| nodecountraw = struct.pack('!Q', nodecount) | nodecountraw = struct.pack('!Q', nodecount) | ||||
| return (''.join(fileindexentries) + nodecountraw + | return (''.join(fileindexentries) + nodecountraw + | ||||
| ''.join(nodeindexentries)) | ''.join(nodeindexentries)) | ||||
| """returns the file contents at this node""" | """returns the file contents at this node""" | ||||
| t = self.revision(node) | t = self.revision(node) | ||||
| if not t.startswith('\1\n'): | if not t.startswith('\1\n'): | ||||
| return t | return t | ||||
| s = t.index('\1\n', 2) | s = t.index('\1\n', 2) | ||||
| return t[s + 2:] | return t[s + 2:] | ||||
| def add(self, text, meta, transaction, linknode, p1=None, p2=None): | def add(self, text, meta, transaction, linknode, p1=None, p2=None): | ||||
| hashtext = text | |||||
| # hash with the metadata, like in vanilla filelogs | # hash with the metadata, like in vanilla filelogs | ||||
| hashtext = shallowutil.createrevlogtext(text, meta.get('copy'), | hashtext = shallowutil.createrevlogtext(text, meta.get('copy'), | ||||
| meta.get('copyrev')) | meta.get('copyrev')) | ||||
| node = storageutil.hashrevisionsha1(hashtext, p1, p2) | node = storageutil.hashrevisionsha1(hashtext, p1, p2) | ||||
| return self.addrevision(hashtext, transaction, linknode, p1, p2, | return self.addrevision(hashtext, transaction, linknode, p1, p2, | ||||
| node=node) | node=node) | ||||
| def _createfileblob(self, text, meta, flags, p1, p2, node, linknode): | def _createfileblob(self, text, meta, flags, p1, p2, node, linknode): | ||||
| # Compute deltas and write to the pack | # Compute deltas and write to the pack | ||||
| for i, node in enumerate(orderednodes): | for i, node in enumerate(orderednodes): | ||||
| deltabase, chainlen = deltabases[node] | deltabase, chainlen = deltabases[node] | ||||
| # Compute delta | # Compute delta | ||||
| # TODO: Optimize the deltachain fetching. Since we're | # TODO: Optimize the deltachain fetching. Since we're | ||||
| # iterating over the different version of the file, we may | # iterating over the different version of the file, we may | ||||
| # be fetching the same deltachain over and over again. | # be fetching the same deltachain over and over again. | ||||
| meta = None | |||||
| if deltabase != nullid: | if deltabase != nullid: | ||||
| deltaentry = self.data.getdelta(filename, node) | deltaentry = self.data.getdelta(filename, node) | ||||
| delta, deltabasename, origdeltabase, meta = deltaentry | delta, deltabasename, origdeltabase, meta = deltaentry | ||||
| size = meta.get(constants.METAKEYSIZE) | size = meta.get(constants.METAKEYSIZE) | ||||
| if (deltabasename != filename or origdeltabase != deltabase | if (deltabasename != filename or origdeltabase != deltabase | ||||
| or size is None): | or size is None): | ||||
| deltabasetext = self.data.get(filename, deltabase) | deltabasetext = self.data.get(filename, deltabase) | ||||
| original = self.data.get(filename, node) | original = self.data.get(filename, node) | ||||
| It requires registration with an Engine object in order to have | It requires registration with an Engine object in order to have | ||||
| the read() method called when a socket is available for reading.""" | the read() method called when a socket is available for reading.""" | ||||
| def __init__(self, zeroconf): | def __init__(self, zeroconf): | ||||
| self.zeroconf = zeroconf | self.zeroconf = zeroconf | ||||
| self.zeroconf.engine.addReader(self, self.zeroconf.socket) | self.zeroconf.engine.addReader(self, self.zeroconf.socket) | ||||
| def handle_read(self): | def handle_read(self): | ||||
| data = addr = port = None | |||||
| sock = self.zeroconf.socket | sock = self.zeroconf.socket | ||||
| try: | try: | ||||
| data, (addr, port) = sock.recvfrom(_MAX_MSG_ABSOLUTE) | data, (addr, port) = sock.recvfrom(_MAX_MSG_ABSOLUTE) | ||||
| except socket.error as e: | except socket.error as e: | ||||
| if e.errno == errno.EBADF: | if e.errno == errno.EBADF: | ||||
| # some other thread may close the socket | # some other thread may close the socket | ||||
| return | return | ||||
| else: | else: | ||||
| def request(self, zeroconf, timeout): | def request(self, zeroconf, timeout): | ||||
| """Returns true if the service could be discovered on the | """Returns true if the service could be discovered on the | ||||
| network, and updates this object with details discovered. | network, and updates this object with details discovered. | ||||
| """ | """ | ||||
| now = currentTimeMillis() | now = currentTimeMillis() | ||||
| delay = _LISTENER_TIME | delay = _LISTENER_TIME | ||||
| next = now + delay | next = now + delay | ||||
| last = now + timeout | last = now + timeout | ||||
| result = 0 | |||||
| try: | try: | ||||
| zeroconf.addListener(self, DNSQuestion(self.name, _TYPE_ANY, | zeroconf.addListener(self, DNSQuestion(self.name, _TYPE_ANY, | ||||
| _CLASS_IN)) | _CLASS_IN)) | ||||
| while (self.server is None or self.address is None or | while (self.server is None or self.address is None or | ||||
| self.text is None): | self.text is None): | ||||
| if last <= now: | if last <= now: | ||||
| return 0 | return 0 | ||||
| if next <= now: | if next <= now: | ||||
| return [] | return [] | ||||
| def _readactive(repo, marks): | def _readactive(repo, marks): | ||||
| """ | """ | ||||
| Get the active bookmark. We can have an active bookmark that updates | Get the active bookmark. We can have an active bookmark that updates | ||||
| itself as we commit. This function returns the name of that bookmark. | itself as we commit. This function returns the name of that bookmark. | ||||
| It is stored in .hg/bookmarks.current | It is stored in .hg/bookmarks.current | ||||
| """ | """ | ||||
| mark = None | |||||
| try: | try: | ||||
| file = repo.vfs('bookmarks.current') | file = repo.vfs('bookmarks.current') | ||||
| except IOError as inst: | except IOError as inst: | ||||
| if inst.errno != errno.ENOENT: | if inst.errno != errno.ENOENT: | ||||
| raise | raise | ||||
| return None | return None | ||||
| try: | try: | ||||
| # No readline() in osutil.posixfile, reading everything is | # No readline() in osutil.posixfile, reading everything is | ||||
| changesets = files = revisions = 0 | changesets = files = revisions = 0 | ||||
| try: | try: | ||||
| # The transaction may already carry source information. In this | # The transaction may already carry source information. In this | ||||
| # case we use the top level data. We overwrite the argument | # case we use the top level data. We overwrite the argument | ||||
| # because we need to use the top level value (if they exist) | # because we need to use the top level value (if they exist) | ||||
| # in this function. | # in this function. | ||||
| srctype = tr.hookargs.setdefault('source', srctype) | srctype = tr.hookargs.setdefault('source', srctype) | ||||
| url = tr.hookargs.setdefault('url', url) | tr.hookargs.setdefault('url', url) | ||||
| repo.hook('prechangegroup', | repo.hook('prechangegroup', | ||||
| throw=True, **pycompat.strkwargs(tr.hookargs)) | throw=True, **pycompat.strkwargs(tr.hookargs)) | ||||
| # write changelog data to temp files so concurrent readers | # write changelog data to temp files so concurrent readers | ||||
| # will not see an inconsistent view | # will not see an inconsistent view | ||||
| cl = repo.changelog | cl = repo.changelog | ||||
| cl.delayupdate(tr) | cl.delayupdate(tr) | ||||
| oldheads = set(cl.heads()) | oldheads = set(cl.heads()) | ||||
| srcexists = True | srcexists = True | ||||
| except IOError as inst: | except IOError as inst: | ||||
| if inst.errno == errno.ENOENT: | if inst.errno == errno.ENOENT: | ||||
| ui.warn(_('%s: deleted in working directory\n') % relsrc) | ui.warn(_('%s: deleted in working directory\n') % relsrc) | ||||
| srcexists = False | srcexists = False | ||||
| else: | else: | ||||
| ui.warn(_('%s: cannot copy - %s\n') % | ui.warn(_('%s: cannot copy - %s\n') % | ||||
| (relsrc, encoding.strtolocal(inst.strerror))) | (relsrc, encoding.strtolocal(inst.strerror))) | ||||
| if rename: | |||||
| hint = _("('hg rename --after' to record the rename)\n") | |||||
| else: | |||||
| hint = _("('hg copy --after' to record the copy)\n") | |||||
| return True # report a failure | return True # report a failure | ||||
| if ui.verbose or not exact: | if ui.verbose or not exact: | ||||
| if rename: | if rename: | ||||
| ui.status(_('moving %s to %s\n') % (relsrc, reltarget)) | ui.status(_('moving %s to %s\n') % (relsrc, reltarget)) | ||||
| else: | else: | ||||
| ui.status(_('copying %s to %s\n') % (relsrc, reltarget)) | ui.status(_('copying %s to %s\n') % (relsrc, reltarget)) | ||||
| if key.startswith('color.'): | if key.startswith('color.'): | ||||
| newval = (False, int(val), '') | newval = (False, int(val), '') | ||||
| ui._terminfoparams[key[6:]] = newval | ui._terminfoparams[key[6:]] = newval | ||||
| elif key.startswith('terminfo.'): | elif key.startswith('terminfo.'): | ||||
| newval = (True, '', val.replace('\\E', '\x1b')) | newval = (True, '', val.replace('\\E', '\x1b')) | ||||
| ui._terminfoparams[key[9:]] = newval | ui._terminfoparams[key[9:]] = newval | ||||
| try: | try: | ||||
| curses.setupterm() | curses.setupterm() | ||||
| except curses.error as e: | except curses.error: | ||||
| ui._terminfoparams.clear() | ui._terminfoparams.clear() | ||||
| return | return | ||||
| for key, (b, e, c) in ui._terminfoparams.copy().items(): | for key, (b, e, c) in ui._terminfoparams.copy().items(): | ||||
| if not b: | if not b: | ||||
| continue | continue | ||||
| if not c and not curses.tigetstr(pycompat.sysstr(e)): | if not c and not curses.tigetstr(pycompat.sysstr(e)): | ||||
| # Most terminals don't support dim, invis, etc, so don't be | # Most terminals don't support dim, invis, etc, so don't be | ||||
| statedata = _readgraftstate(repo, graftstate) | statedata = _readgraftstate(repo, graftstate) | ||||
| newnodes = statedata.get('newnodes') | newnodes = statedata.get('newnodes') | ||||
| if newnodes is None: | if newnodes is None: | ||||
| # and old graft state which does not have all the data required to abort | # and old graft state which does not have all the data required to abort | ||||
| # the graft | # the graft | ||||
| raise error.Abort(_("cannot abort using an old graftstate")) | raise error.Abort(_("cannot abort using an old graftstate")) | ||||
| # changeset from which graft operation was started | # changeset from which graft operation was started | ||||
| startctx = None | |||||
| if len(newnodes) > 0: | if len(newnodes) > 0: | ||||
| startctx = repo[newnodes[0]].p1() | startctx = repo[newnodes[0]].p1() | ||||
| else: | else: | ||||
| startctx = repo['.'] | startctx = repo['.'] | ||||
| # whether to strip or not | # whether to strip or not | ||||
| cleanup = False | cleanup = False | ||||
| if newnodes: | if newnodes: | ||||
| newnodes = [repo[r].rev() for r in newnodes] | newnodes = [repo[r].rev() for r in newnodes] | ||||
| opts = pycompat.byteskwargs(opts) | opts = pycompat.byteskwargs(opts) | ||||
| ui.pager('summary') | ui.pager('summary') | ||||
| ctx = repo[None] | ctx = repo[None] | ||||
| parents = ctx.parents() | parents = ctx.parents() | ||||
| pnode = parents[0].node() | pnode = parents[0].node() | ||||
| marks = [] | marks = [] | ||||
| ms = None | |||||
| try: | try: | ||||
| ms = mergemod.mergestate.read(repo) | ms = mergemod.mergestate.read(repo) | ||||
| except error.UnsupportedMergeRecords as e: | except error.UnsupportedMergeRecords as e: | ||||
| s = ' '.join(e.recordtypes) | s = ' '.join(e.recordtypes) | ||||
| ui.warn( | ui.warn( | ||||
| _('warning: merge state has unsupported record types: %s\n') % s) | _('warning: merge state has unsupported record types: %s\n') % s) | ||||
| unresolved = [] | unresolved = [] | ||||
| else: | else: | ||||
| Returns 0 on success. | Returns 0 on success. | ||||
| """ | """ | ||||
| opts = pycompat.byteskwargs(opts) | opts = pycompat.byteskwargs(opts) | ||||
| ui.pager('tags') | ui.pager('tags') | ||||
| fm = ui.formatter('tags', opts) | fm = ui.formatter('tags', opts) | ||||
| hexfunc = fm.hexfunc | hexfunc = fm.hexfunc | ||||
| tagtype = "" | |||||
| for t, n in reversed(repo.tagslist()): | for t, n in reversed(repo.tagslist()): | ||||
| hn = hexfunc(n) | hn = hexfunc(n) | ||||
| label = 'tags.normal' | label = 'tags.normal' | ||||
| tagtype = '' | tagtype = '' | ||||
| if repo.tagtype(t) == 'local': | if repo.tagtype(t) == 'local': | ||||
| label = 'tags.local' | label = 'tags.local' | ||||
| tagtype = 'local' | tagtype = 'local' | ||||
| def debugstate(ui, repo, **opts): | def debugstate(ui, repo, **opts): | ||||
| """show the contents of the current dirstate""" | """show the contents of the current dirstate""" | ||||
| nodates = not opts[r'dates'] | nodates = not opts[r'dates'] | ||||
| if opts.get(r'nodates') is not None: | if opts.get(r'nodates') is not None: | ||||
| nodates = True | nodates = True | ||||
| datesort = opts.get(r'datesort') | datesort = opts.get(r'datesort') | ||||
| timestr = "" | |||||
| if datesort: | if datesort: | ||||
| keyfunc = lambda x: (x[1][3], x[0]) # sort by mtime, then by filename | keyfunc = lambda x: (x[1][3], x[0]) # sort by mtime, then by filename | ||||
| else: | else: | ||||
| keyfunc = None # sort by filename | keyfunc = None # sort by filename | ||||
| for file_, ent in sorted(repo.dirstate._map.iteritems(), key=keyfunc): | for file_, ent in sorted(repo.dirstate._map.iteritems(), key=keyfunc): | ||||
| if ent[3] == -1: | if ent[3] == -1: | ||||
| timestr = 'unset ' | timestr = 'unset ' | ||||
| elif nodates: | elif nodates: | ||||
| @command('debuginstall', [] + cmdutil.formatteropts, '', norepo=True) | @command('debuginstall', [] + cmdutil.formatteropts, '', norepo=True) | ||||
| def debuginstall(ui, **opts): | def debuginstall(ui, **opts): | ||||
| '''test Mercurial installation | '''test Mercurial installation | ||||
| Returns 0 on success. | Returns 0 on success. | ||||
| ''' | ''' | ||||
| opts = pycompat.byteskwargs(opts) | opts = pycompat.byteskwargs(opts) | ||||
| def writetemp(contents): | |||||
| (fd, name) = pycompat.mkstemp(prefix="hg-debuginstall-") | |||||
| f = os.fdopen(fd, r"wb") | |||||
| f.write(contents) | |||||
| f.close() | |||||
| return name | |||||
| problems = 0 | problems = 0 | ||||
| fm = ui.formatter('debuginstall', opts) | fm = ui.formatter('debuginstall', opts) | ||||
| fm.startitem() | fm.startitem() | ||||
| # encoding | # encoding | ||||
| fm.write('encoding', _("checking encoding (%s)...\n"), encoding.encoding) | fm.write('encoding', _("checking encoding (%s)...\n"), encoding.encoding) | ||||
| err = None | err = None | ||||
| if not source: | if not source: | ||||
| if not repo: | if not repo: | ||||
| raise error.Abort(_("there is no Mercurial repository here, and no " | raise error.Abort(_("there is no Mercurial repository here, and no " | ||||
| "server specified")) | "server specified")) | ||||
| source = "default" | source = "default" | ||||
| source, branches = hg.parseurl(ui.expandpath(source)) | source, branches = hg.parseurl(ui.expandpath(source)) | ||||
| url = util.url(source) | url = util.url(source) | ||||
| addr = None | |||||
| defaultport = {'https': 443, 'ssh': 22} | defaultport = {'https': 443, 'ssh': 22} | ||||
| if url.scheme in defaultport: | if url.scheme in defaultport: | ||||
| try: | try: | ||||
| addr = (url.host, int(url.port or defaultport[url.scheme])) | addr = (url.host, int(url.port or defaultport[url.scheme])) | ||||
| except ValueError: | except ValueError: | ||||
| raise error.Abort(_("malformed port number in URL")) | raise error.Abort(_("malformed port number in URL")) | ||||
| else: | else: | ||||
| version = 'v2' | version = 'v2' | ||||
| else: | else: | ||||
| raise error.Abort(_('changegroup version %s does not have ' | raise error.Abort(_('changegroup version %s does not have ' | ||||
| 'a known bundlespec') % version, | 'a known bundlespec') % version, | ||||
| hint=_('try upgrading your Mercurial ' | hint=_('try upgrading your Mercurial ' | ||||
| 'client')) | 'client')) | ||||
| elif part.type == 'stream2' and version is None: | elif part.type == 'stream2' and version is None: | ||||
| # A stream2 part requires to be part of a v2 bundle | # A stream2 part requires to be part of a v2 bundle | ||||
| version = "v2" | |||||
| requirements = urlreq.unquote(part.params['requirements']) | requirements = urlreq.unquote(part.params['requirements']) | ||||
| splitted = requirements.split() | splitted = requirements.split() | ||||
| params = bundle2._formatrequirementsparams(splitted) | params = bundle2._formatrequirementsparams(splitted) | ||||
| return 'none-v2;stream=v2;%s' % params | return 'none-v2;stream=v2;%s' % params | ||||
| if not version: | if not version: | ||||
| raise error.Abort(_('could not identify changegroup version in ' | raise error.Abort(_('could not identify changegroup version in ' | ||||
| 'bundle')) | 'bundle')) | ||||
| return _imerge(repo, mynode, orig, fcd, fco, fca, toolconf, files, labels) | return _imerge(repo, mynode, orig, fcd, fco, fca, toolconf, files, labels) | ||||
| def _imergeauto(repo, mynode, orig, fcd, fco, fca, toolconf, files, | def _imergeauto(repo, mynode, orig, fcd, fco, fca, toolconf, files, | ||||
| labels=None, localorother=None): | labels=None, localorother=None): | ||||
| """ | """ | ||||
| Generic driver for _imergelocal and _imergeother | Generic driver for _imergelocal and _imergeother | ||||
| """ | """ | ||||
| assert localorother is not None | assert localorother is not None | ||||
| tool, toolpath, binary, symlink, scriptfn = toolconf | |||||
| r = simplemerge.simplemerge(repo.ui, fcd, fca, fco, label=labels, | r = simplemerge.simplemerge(repo.ui, fcd, fca, fco, label=labels, | ||||
| localorother=localorother) | localorother=localorother) | ||||
| return True, r | return True, r | ||||
| @internaltool('merge-local', mergeonly, precheck=_mergecheck) | @internaltool('merge-local', mergeonly, precheck=_mergecheck) | ||||
| def _imergelocal(*args, **kwargs): | def _imergelocal(*args, **kwargs): | ||||
| """ | """ | ||||
| Like :merge, but resolve all conflicts non-interactively in favor | Like :merge, but resolve all conflicts non-interactively in favor | ||||
| Copy the store data to the repo and remove the sharedpath data. | Copy the store data to the repo and remove the sharedpath data. | ||||
| Returns a new repository object representing the unshared repository. | Returns a new repository object representing the unshared repository. | ||||
| The passed repository object is not usable after this function is | The passed repository object is not usable after this function is | ||||
| called. | called. | ||||
| """ | """ | ||||
| destlock = lock = None | destlock = None | ||||
| lock = repo.lock() | lock = repo.lock() | ||||
| try: | try: | ||||
| # we use locks here because if we race with commit, we | # we use locks here because if we race with commit, we | ||||
| # can end up with extra data in the cloned revlogs that's | # can end up with extra data in the cloned revlogs that's | ||||
| # not pointed to by changesets, thus causing verify to | # not pointed to by changesets, thus causing verify to | ||||
| # fail | # fail | ||||
| destlock = copystore(ui, repo, repo.path) | destlock = copystore(ui, repo, repo.path) | ||||
| # redefine the path to refer to the directory | # redefine the path to refer to the directory | ||||
| discarded = '/'.join(nameparts[1:]) | discarded = '/'.join(nameparts[1:]) | ||||
| # remove name parts plus accompanying slash | # remove name parts plus accompanying slash | ||||
| path = path[:-len(discarded) - 1] | path = path[:-len(discarded) - 1] | ||||
| try: | try: | ||||
| r = hg.repository(ui, path) | hg.repository(ui, path) | ||||
| directory = False | directory = False | ||||
| except (IOError, error.RepoError): | except (IOError, error.RepoError): | ||||
| pass | pass | ||||
| parts = [ | parts = [ | ||||
| req.apppath.strip('/'), | req.apppath.strip('/'), | ||||
| subdir.strip('/'), | subdir.strip('/'), | ||||
| name.strip('/'), | name.strip('/'), | ||||
| fctx = ctx[f] | fctx = ctx[f] | ||||
| if fctx is None: | if fctx is None: | ||||
| removed.append(f) | removed.append(f) | ||||
| else: | else: | ||||
| added.append(f) | added.append(f) | ||||
| m[f] = self._filecommit(fctx, m1, m2, linkrev, | m[f] = self._filecommit(fctx, m1, m2, linkrev, | ||||
| trp, changed) | trp, changed) | ||||
| m.setflag(f, fctx.flags()) | m.setflag(f, fctx.flags()) | ||||
| except OSError as inst: | except OSError: | ||||
| self.ui.warn(_("trouble committing %s!\n") % f) | self.ui.warn(_("trouble committing %s!\n") % f) | ||||
| raise | raise | ||||
| except IOError as inst: | except IOError as inst: | ||||
| errcode = getattr(inst, 'errno', errno.ENOENT) | errcode = getattr(inst, 'errno', errno.ENOENT) | ||||
| if error or errcode and errcode != errno.ENOENT: | if error or errcode and errcode != errno.ENOENT: | ||||
| self.ui.warn(_("trouble committing %s!\n") % f) | self.ui.warn(_("trouble committing %s!\n") % f) | ||||
| raise | raise | ||||
| writeremotenamefile(repo, remotepath, bookmarks, 'bookmarks') | writeremotenamefile(repo, remotepath, bookmarks, 'bookmarks') | ||||
| if branches: | if branches: | ||||
| writeremotenamefile(repo, remotepath, branches, 'branches') | writeremotenamefile(repo, remotepath, branches, 'branches') | ||||
| finally: | finally: | ||||
| wlock.release() | wlock.release() | ||||
| def activepath(repo, remote): | def activepath(repo, remote): | ||||
| """returns remote path""" | """returns remote path""" | ||||
| local = None | |||||
| # is the remote a local peer | # is the remote a local peer | ||||
| local = remote.local() | local = remote.local() | ||||
| # determine the remote path from the repo, if possible; else just | # determine the remote path from the repo, if possible; else just | ||||
| # use the string given to us | # use the string given to us | ||||
| rpath = remote | rpath = remote | ||||
| if local: | if local: | ||||
| rpath = util.pconvert(remote._repo.root) | rpath = util.pconvert(remote._repo.root) | ||||
| return _lazymanifest(self.data, self.positions, self.extrainfo, | return _lazymanifest(self.data, self.positions, self.extrainfo, | ||||
| self.extradata) | self.extradata) | ||||
| def _compact(self): | def _compact(self): | ||||
| # hopefully not called TOO often | # hopefully not called TOO often | ||||
| if len(self.extradata) == 0: | if len(self.extradata) == 0: | ||||
| return | return | ||||
| l = [] | l = [] | ||||
| last_cut = 0 | |||||
| i = 0 | i = 0 | ||||
| offset = 0 | offset = 0 | ||||
| self.extrainfo = [0] * len(self.positions) | self.extrainfo = [0] * len(self.positions) | ||||
| while i < len(self.positions): | while i < len(self.positions): | ||||
| if self.positions[i] >= 0: | if self.positions[i] >= 0: | ||||
| cur = self.positions[i] | cur = self.positions[i] | ||||
| last_cut = cur | last_cut = cur | ||||
| while True: | while True: | ||||
| relevantfiles.add(copykey) | relevantfiles.add(copykey) | ||||
| for movedirkey in movewithdir: | for movedirkey in movewithdir: | ||||
| relevantfiles.add(movedirkey) | relevantfiles.add(movedirkey) | ||||
| filesmatcher = scmutil.matchfiles(repo, relevantfiles) | filesmatcher = scmutil.matchfiles(repo, relevantfiles) | ||||
| matcher = matchmod.intersectmatchers(matcher, filesmatcher) | matcher = matchmod.intersectmatchers(matcher, filesmatcher) | ||||
| diff = m1.diff(m2, match=matcher) | diff = m1.diff(m2, match=matcher) | ||||
| if matcher is None: | |||||
| matcher = matchmod.always('', '') | |||||
| actions = {} | actions = {} | ||||
| for f, ((n1, fl1), (n2, fl2)) in diff.iteritems(): | for f, ((n1, fl1), (n2, fl2)) in diff.iteritems(): | ||||
| if n1 and n2: # file exists on both local and remote side | if n1 and n2: # file exists on both local and remote side | ||||
| if f not in ma: | if f not in ma: | ||||
| fa = copy.get(f, None) | fa = copy.get(f, None) | ||||
| if fa is not None: | if fa is not None: | ||||
| actions[f] = (ACTION_MERGE, (f, f, fa, False, pa.node()), | actions[f] = (ACTION_MERGE, (f, f, fa, False, pa.node()), | ||||
| 'both renamed from %s' % fa) | 'both renamed from %s' % fa) | ||||
| nb['type'] not in 'definition bullet field option')): | nb['type'] not in 'definition bullet field option')): | ||||
| out.append('</%s>\n' % start) | out.append('</%s>\n' % start) | ||||
| listnest.pop() | listnest.pop() | ||||
| return ''.join(out) | return ''.join(out) | ||||
| def parse(text, indent=0, keep=None, admonitions=None): | def parse(text, indent=0, keep=None, admonitions=None): | ||||
| """Parse text into a list of blocks""" | """Parse text into a list of blocks""" | ||||
| pruned = [] | |||||
| blocks = findblocks(text) | blocks = findblocks(text) | ||||
| for b in blocks: | for b in blocks: | ||||
| b['indent'] += indent | b['indent'] += indent | ||||
| blocks = findliteralblocks(blocks) | blocks = findliteralblocks(blocks) | ||||
| blocks = findtables(blocks) | blocks = findtables(blocks) | ||||
| blocks, pruned = prunecontainers(blocks, keep or []) | blocks, pruned = prunecontainers(blocks, keep or []) | ||||
| blocks = findsections(blocks) | blocks = findsections(blocks) | ||||
| blocks = inlineliterals(blocks) | blocks = inlineliterals(blocks) | ||||
| del blocks[s[0]:real] | del blocks[s[0]:real] | ||||
| return blocks | return blocks | ||||
| def _getsections(blocks): | def _getsections(blocks): | ||||
| '''return a list of (section path, nesting level, blocks) tuples''' | '''return a list of (section path, nesting level, blocks) tuples''' | ||||
| nest = "" | nest = "" | ||||
| names = () | names = () | ||||
| level = 0 | |||||
| secs = [] | secs = [] | ||||
| def getname(b): | def getname(b): | ||||
| if b['type'] == 'field': | if b['type'] == 'field': | ||||
| x = b['key'] | x = b['key'] | ||||
| else: | else: | ||||
| x = b['lines'][0] | x = b['lines'][0] | ||||
| x = encoding.lower(x).strip('"') | x = encoding.lower(x).strip('"') | ||||
| return [self.text] | return [self.text] | ||||
| def _read(self, lr): | def _read(self, lr): | ||||
| def getline(lr, hunk): | def getline(lr, hunk): | ||||
| l = lr.readline() | l = lr.readline() | ||||
| hunk.append(l) | hunk.append(l) | ||||
| return l.rstrip('\r\n') | return l.rstrip('\r\n') | ||||
| size = 0 | |||||
| while True: | while True: | ||||
| line = getline(lr, self.hunk) | line = getline(lr, self.hunk) | ||||
| if not line: | if not line: | ||||
| raise PatchError(_('could not extract "%s" binary data') | raise PatchError(_('could not extract "%s" binary data') | ||||
| % self._fname) | % self._fname) | ||||
| if line.startswith('literal '): | if line.startswith('literal '): | ||||
| size = int(line[8:].rstrip()) | size = int(line[8:].rstrip()) | ||||
| break | break | ||||
| afile = 'a/' + m.group(1) | afile = 'a/' + m.group(1) | ||||
| bfile = 'b/' + m.group(2) | bfile = 'b/' + m.group(2) | ||||
| while gitpatches and not gitpatches[-1].ispatching(afile, bfile): | while gitpatches and not gitpatches[-1].ispatching(afile, bfile): | ||||
| gp = gitpatches.pop() | gp = gitpatches.pop() | ||||
| yield 'file', ('a/' + gp.path, 'b/' + gp.path, None, gp.copy()) | yield 'file', ('a/' + gp.path, 'b/' + gp.path, None, gp.copy()) | ||||
| if not gitpatches: | if not gitpatches: | ||||
| raise PatchError(_('failed to synchronize metadata for "%s"') | raise PatchError(_('failed to synchronize metadata for "%s"') | ||||
| % afile[2:]) | % afile[2:]) | ||||
| gp = gitpatches[-1] | |||||
| newfile = True | newfile = True | ||||
| elif x.startswith('---'): | elif x.startswith('---'): | ||||
| # check for a unified diff | # check for a unified diff | ||||
| l2 = lr.readline() | l2 = lr.readline() | ||||
| if not l2.startswith('+++'): | if not l2.startswith('+++'): | ||||
| lr.push(l2) | lr.push(l2) | ||||
| continue | continue | ||||
| newfile = True | newfile = True | ||||
| # XXX this would ideally be done in the matcher, but that is | # XXX this would ideally be done in the matcher, but that is | ||||
| # generally meant to 'or' patterns, not 'and' them. In this case we | # generally meant to 'or' patterns, not 'and' them. In this case we | ||||
| # need to 'and' all the patterns from the matcher with relroot. | # need to 'and' all the patterns from the matcher with relroot. | ||||
| def filterrel(l): | def filterrel(l): | ||||
| return [f for f in l if f.startswith(relroot)] | return [f for f in l if f.startswith(relroot)] | ||||
| modified = filterrel(modified) | modified = filterrel(modified) | ||||
| added = filterrel(added) | added = filterrel(added) | ||||
| removed = filterrel(removed) | removed = filterrel(removed) | ||||
| relfiltered = True | |||||
| # filter out copies where either side isn't inside the relative root | # filter out copies where either side isn't inside the relative root | ||||
| copy = dict(((dst, src) for (dst, src) in copy.iteritems() | copy = dict(((dst, src) for (dst, src) in copy.iteritems() | ||||
| if dst.startswith(relroot) | if dst.startswith(relroot) | ||||
| and src.startswith(relroot))) | and src.startswith(relroot))) | ||||
| modifiedset = set(modified) | modifiedset = set(modified) | ||||
| addedset = set(added) | addedset = set(added) | ||||
| removedset = set(removed) | removedset = set(removed) | ||||
| parent = stackid(stack[1:]) | parent = stackid(stack[1:]) | ||||
| myid = len(stack2id) | myid = len(stack2id) | ||||
| stack2id[stack] = myid | stack2id[stack] = myid | ||||
| id2stack.append(dict(category=stack[0][0], name='%s %s' % stack[0])) | id2stack.append(dict(category=stack[0][0], name='%s %s' % stack[0])) | ||||
| if parent is not None: | if parent is not None: | ||||
| id2stack[-1].update(parent=parent) | id2stack[-1].update(parent=parent) | ||||
| return myid | return myid | ||||
| def endswith(a, b): | |||||
| return list(a)[-len(b):] == list(b) | |||||
| # The sampling profiler can sample multiple times without | # The sampling profiler can sample multiple times without | ||||
| # advancing the clock, potentially causing the Chrome trace viewer | # advancing the clock, potentially causing the Chrome trace viewer | ||||
| # to render single-pixel columns that we cannot zoom in on. We | # to render single-pixel columns that we cannot zoom in on. We | ||||
| # work around this by pretending that zero-duration samples are a | # work around this by pretending that zero-duration samples are a | ||||
| # millisecond in length. | # millisecond in length. | ||||
| clamp = 0.001 | clamp = 0.001 | ||||
| ts=sampletime*1e6, pid=0)) | ts=sampletime*1e6, pid=0)) | ||||
| else: | else: | ||||
| blacklist.add(oldidx) | blacklist.add(oldidx) | ||||
| # Much fiddling to synthesize correctly(ish) nested begin/end | # Much fiddling to synthesize correctly(ish) nested begin/end | ||||
| # events given only stack snapshots. | # events given only stack snapshots. | ||||
| for sample in data.samples: | for sample in data.samples: | ||||
| tos = sample.stack[0] | |||||
| name = tos.function | |||||
| path = simplifypath(tos.path) | |||||
| stack = tuple((('%s:%d' % (simplifypath(frame.path), frame.lineno), | stack = tuple((('%s:%d' % (simplifypath(frame.path), frame.lineno), | ||||
| frame.function) for frame in sample.stack)) | frame.function) for frame in sample.stack)) | ||||
| qstack = collections.deque(stack) | qstack = collections.deque(stack) | ||||
| if laststack == qstack: | if laststack == qstack: | ||||
| continue | continue | ||||
| while laststack and qstack and laststack[-1] == qstack[-1]: | while laststack and qstack and laststack[-1] == qstack[-1]: | ||||
| laststack.pop() | laststack.pop() | ||||
| qstack.pop() | qstack.pop() | ||||
| def debug(s, msg, r=""): | def debug(s, msg, r=""): | ||||
| if r: | if r: | ||||
| r = "%s:%s:%s" % r | r = "%s:%s:%s" % r | ||||
| repo.ui.debug(" subrepo %s: %s %s\n" % (s, msg, r)) | repo.ui.debug(" subrepo %s: %s %s\n" % (s, msg, r)) | ||||
| promptssrc = filemerge.partextras(labels) | promptssrc = filemerge.partextras(labels) | ||||
| for s, l in sorted(s1.iteritems()): | for s, l in sorted(s1.iteritems()): | ||||
| prompts = None | |||||
| a = sa.get(s, nullstate) | a = sa.get(s, nullstate) | ||||
| ld = l # local state with possible dirty flag for compares | ld = l # local state with possible dirty flag for compares | ||||
| if wctx.sub(s).dirty(): | if wctx.sub(s).dirty(): | ||||
| ld = (l[0], l[1] + "+") | ld = (l[0], l[1] + "+") | ||||
| if wctx == actx: # overwrite | if wctx == actx: # overwrite | ||||
| a = ld | a = ld | ||||
| prompts = promptssrc.copy() | prompts = promptssrc.copy() | ||||
| _(' local%(l)s changed subrepository %(s)s' | _(' local%(l)s changed subrepository %(s)s' | ||||
| ' which remote%(o)s removed\n' | ' which remote%(o)s removed\n' | ||||
| 'use (c)hanged version or (d)elete?' | 'use (c)hanged version or (d)elete?' | ||||
| '$$ &Changed $$ &Delete') % prompts, 0): | '$$ &Changed $$ &Delete') % prompts, 0): | ||||
| debug(s, "prompt remove") | debug(s, "prompt remove") | ||||
| wctx.sub(s).remove() | wctx.sub(s).remove() | ||||
| for s, r in sorted(s2.items()): | for s, r in sorted(s2.items()): | ||||
| prompts = None | |||||
| if s in s1: | if s in s1: | ||||
| continue | continue | ||||
| elif s not in sa: | elif s not in sa: | ||||
| debug(s, "remote added, get", r) | debug(s, "remote added, get", r) | ||||
| mctx.sub(s).get(r) | mctx.sub(s).get(r) | ||||
| sm[s] = r | sm[s] = r | ||||
| elif r != sa[s]: | elif r != sa[s]: | ||||
| prompts = promptssrc.copy() | prompts = promptssrc.copy() | ||||
| report(_("failed to recover %s\n") % f) | report(_("failed to recover %s\n") % f) | ||||
| else: | else: | ||||
| target = f or b | target = f or b | ||||
| try: | try: | ||||
| vfs.unlink(target) | vfs.unlink(target) | ||||
| except (IOError, OSError) as inst: | except (IOError, OSError) as inst: | ||||
| if inst.errno != errno.ENOENT: | if inst.errno != errno.ENOENT: | ||||
| raise | raise | ||||
| except (IOError, OSError, error.Abort) as inst: | except (IOError, OSError, error.Abort): | ||||
| if not c: | if not c: | ||||
| raise | raise | ||||
| backuppath = "%s.backupfiles" % journal | backuppath = "%s.backupfiles" % journal | ||||
| if opener.exists(backuppath): | if opener.exists(backuppath): | ||||
| opener.unlink(backuppath) | opener.unlink(backuppath) | ||||
| opener.unlink(journal) | opener.unlink(journal) | ||||
| try: | try: | ||||
| for f in backupfiles: | for f in backupfiles: | ||||
| if opener.exists(f): | if opener.exists(f): | ||||
| opener.unlink(f) | opener.unlink(f) | ||||
| except (IOError, OSError, error.Abort) as inst: | except (IOError, OSError, error.Abort): | ||||
| # only pure backup file remains, it is sage to ignore any error | # only pure backup file remains, it is sage to ignore any error | ||||
| pass | pass | ||||
| class transaction(util.transactional): | class transaction(util.transactional): | ||||
| def __init__(self, report, opener, vfsmap, journalname, undoname=None, | def __init__(self, report, opener, vfsmap, journalname, undoname=None, | ||||
| after=None, createmode=None, validator=None, releasefn=None, | after=None, createmode=None, validator=None, releasefn=None, | ||||
| checkambigfiles=None, name=r'<unnamed>'): | checkambigfiles=None, name=r'<unnamed>'): | ||||
| """Begin a new transaction | """Begin a new transaction | ||||
| "config item: '%s.%s' '%s'") | "config item: '%s.%s' '%s'") | ||||
| msg %= (section, name, pycompat.bytestr(default)) | msg %= (section, name, pycompat.bytestr(default)) | ||||
| self.develwarn(msg, 2, 'warn-config-default') | self.develwarn(msg, 2, 'warn-config-default') | ||||
| for s, n in alternates: | for s, n in alternates: | ||||
| candidate = self._data(untrusted).get(s, n, None) | candidate = self._data(untrusted).get(s, n, None) | ||||
| if candidate is not None: | if candidate is not None: | ||||
| value = candidate | value = candidate | ||||
| section = s | |||||
| name = n | |||||
| break | break | ||||
| if self.debugflag and not untrusted and self._reportuntrusted: | if self.debugflag and not untrusted and self._reportuntrusted: | ||||
| for s, n in alternates: | for s, n in alternates: | ||||
| uvalue = self._ucfg.get(s, n) | uvalue = self._ucfg.get(s, n) | ||||
| if uvalue is not None and uvalue != value: | if uvalue is not None and uvalue != value: | ||||
| self.debug("ignoring untrusted configuration option " | self.debug("ignoring untrusted configuration option " | ||||
| "%s.%s = %s\n" % (s, n, uvalue)) | "%s.%s = %s\n" % (s, n, uvalue)) | ||||
| if not bundle1allowed(repo, 'pull'): | if not bundle1allowed(repo, 'pull'): | ||||
| if not exchange.bundle2requested(opts.get('bundlecaps')): | if not exchange.bundle2requested(opts.get('bundlecaps')): | ||||
| if proto.name == 'http-v1': | if proto.name == 'http-v1': | ||||
| return wireprototypes.ooberror(bundle2required) | return wireprototypes.ooberror(bundle2required) | ||||
| raise error.Abort(bundle2requiredmain, | raise error.Abort(bundle2requiredmain, | ||||
| hint=bundle2requiredhint) | hint=bundle2requiredhint) | ||||
| prefercompressed = True | |||||
| try: | try: | ||||
| clheads = set(repo.changelog.heads()) | clheads = set(repo.changelog.heads()) | ||||
| heads = set(opts.get('heads', set())) | heads = set(opts.get('heads', set())) | ||||
| common = set(opts.get('common', set())) | common = set(opts.get('common', set())) | ||||
| common.discard(nullid) | common.discard(nullid) | ||||
| if (repo.ui.configbool('server', 'pullbundle') and | if (repo.ui.configbool('server', 'pullbundle') and | ||||
| 'partial-pull' in proto.getprotocaps()): | 'partial-pull' in proto.getprotocaps()): | ||||
| # Check if a pre-built bundle covers this request. | # Check if a pre-built bundle covers this request. | ||||
| if fp: | if fp: | ||||
| fp.close() | fp.close() | ||||
| if tempname: | if tempname: | ||||
| os.unlink(tempname) | os.unlink(tempname) | ||||
| fd, tempname = pycompat.mkstemp(prefix='hg-unbundle-') | fd, tempname = pycompat.mkstemp(prefix='hg-unbundle-') | ||||
| repo.ui.debug('redirecting incoming bundle to %s\n' % | repo.ui.debug('redirecting incoming bundle to %s\n' % | ||||
| tempname) | tempname) | ||||
| fp = os.fdopen(fd, pycompat.sysstr('wb+')) | fp = os.fdopen(fd, pycompat.sysstr('wb+')) | ||||
| r = 0 | |||||
| for p in payload: | for p in payload: | ||||
| fp.write(p) | fp.write(p) | ||||
| fp.seek(0) | fp.seek(0) | ||||
| gen = exchange.readbundle(repo.ui, fp, None) | gen = exchange.readbundle(repo.ui, fp, None) | ||||
| if (isinstance(gen, changegroupmod.cg1unpacker) | if (isinstance(gen, changegroupmod.cg1unpacker) | ||||
| and not bundle1allowed(repo, 'push')): | and not bundle1allowed(repo, 'push')): | ||||
| if proto.name == 'http-v1': | if proto.name == 'http-v1': | ||||
| def cleanup(): | def cleanup(): | ||||
| terminate(proc) | terminate(proc) | ||||
| ret = proc.wait() | ret = proc.wait() | ||||
| if ret == 0: | if ret == 0: | ||||
| ret = signal.SIGTERM << 8 | ret = signal.SIGTERM << 8 | ||||
| killdaemons(env['DAEMON_PIDS']) | killdaemons(env['DAEMON_PIDS']) | ||||
| return ret | return ret | ||||
| output = b'' | |||||
| proc.tochild.close() | proc.tochild.close() | ||||
| try: | try: | ||||
| output = proc.fromchild.read() | output = proc.fromchild.read() | ||||
| except KeyboardInterrupt: | except KeyboardInterrupt: | ||||
| vlog('# Handling keyboard interrupt') | vlog('# Handling keyboard interrupt') | ||||
| cleanup() | cleanup() | ||||
| raise | raise | ||||
| graphnodes = range(nullrev, len(graph)) | graphnodes = range(nullrev, len(graph)) | ||||
| bases = samplerevs(graphnodes) | bases = samplerevs(graphnodes) | ||||
| # fast algorithm | # fast algorithm | ||||
| inc = ancestor.incrementalmissingancestors(graph.__getitem__, bases) | inc = ancestor.incrementalmissingancestors(graph.__getitem__, bases) | ||||
| # reference slow algorithm | # reference slow algorithm | ||||
| naiveinc = naiveincrementalmissingancestors(ancs, bases) | naiveinc = naiveincrementalmissingancestors(ancs, bases) | ||||
| seq = [] | seq = [] | ||||
| revs = [] | |||||
| for _ in xrange(inccount): | for _ in xrange(inccount): | ||||
| if rng.random() < 0.2: | if rng.random() < 0.2: | ||||
| newbases = samplerevs(graphnodes) | newbases = samplerevs(graphnodes) | ||||
| seq.append(('addbases', newbases)) | seq.append(('addbases', newbases)) | ||||
| inc.addbases(newbases) | inc.addbases(newbases) | ||||
| naiveinc.addbases(newbases) | naiveinc.addbases(newbases) | ||||
| if rng.random() < 0.4: | if rng.random() < 0.4: | ||||
| # larger set so that there are more revs to remove from | # larger set so that there are more revs to remove from | ||||
| maxlinenum = 0xffffff | maxlinenum = 0xffffff | ||||
| maxb1 = 0xffffff | maxb1 = 0xffffff | ||||
| maxdeltaa = 10 | maxdeltaa = 10 | ||||
| maxdeltab = 10 | maxdeltab = 10 | ||||
| def _genedits(seed, endrev): | def _genedits(seed, endrev): | ||||
| lines = [] | lines = [] | ||||
| random.seed(seed) | random.seed(seed) | ||||
| rev = 0 | |||||
| for rev in range(0, endrev): | for rev in range(0, endrev): | ||||
| n = len(lines) | n = len(lines) | ||||
| a1 = random.randint(0, n) | a1 = random.randint(0, n) | ||||
| a2 = random.randint(a1, min(n, a1 + maxdeltaa)) | a2 = random.randint(a1, min(n, a1 + maxdeltaa)) | ||||
| b1 = random.randint(0, maxb1) | b1 = random.randint(0, maxb1) | ||||
| b2 = random.randint(b1, b1 + maxdeltab) | b2 = random.randint(b1, b1 + maxdeltab) | ||||
| usevec = not bool(random.randint(0, vecratio)) | usevec = not bool(random.randint(0, vecratio)) | ||||
| if usevec: | if usevec: | ||||
| newcount = ancestorcounts[(filename, p1)] + 1 | newcount = ancestorcounts[(filename, p1)] + 1 | ||||
| ancestorcounts[(filename, node)] = newcount | ancestorcounts[(filename, node)] = newcount | ||||
| # Must add file entries in reverse topological order | # Must add file entries in reverse topological order | ||||
| revisions = list(reversed(revisions)) | revisions = list(reversed(revisions)) | ||||
| pack = self.createPack(revisions) | pack = self.createPack(revisions) | ||||
| # Verify the pack contents | # Verify the pack contents | ||||
| for (filename, node), (p1, p2, lastnode) in allentries.items(): | for (filename, node) in allentries: | ||||
| ancestors = pack.getancestors(filename, node) | ancestors = pack.getancestors(filename, node) | ||||
| self.assertEquals(ancestorcounts[(filename, node)], | self.assertEquals(ancestorcounts[(filename, node)], | ||||
| len(ancestors)) | len(ancestors)) | ||||
| for anode, (ap1, ap2, alinknode, copyfrom) in ancestors.items(): | for anode, (ap1, ap2, alinknode, copyfrom) in ancestors.items(): | ||||
| ep1, ep2, elinknode = allentries[(filename, anode)] | ep1, ep2, elinknode = allentries[(filename, anode)] | ||||
| self.assertEquals(ap1, ep1) | self.assertEquals(ap1, ep1) | ||||
| self.assertEquals(ap2, ep2) | self.assertEquals(ap2, ep2) | ||||
| self.assertEquals(alinknode, elinknode) | self.assertEquals(alinknode, elinknode) | ||||
| deltas._findsnapshots(rlog, result15, 15) | deltas._findsnapshots(rlog, result15, 15) | ||||
| result15 = dict(result15.items()) | result15 = dict(result15.items()) | ||||
| if result15 != snapshotmap15: | if result15 != snapshotmap15: | ||||
| print('snapshot map differ:') | print('snapshot map differ:') | ||||
| print(' expected: %s' % snapshotmap15) | print(' expected: %s' % snapshotmap15) | ||||
| print(' got: %s' % result15) | print(' got: %s' % result15) | ||||
| def maintest(): | def maintest(): | ||||
| expected = rl = None | |||||
| with newtransaction() as tr: | with newtransaction() as tr: | ||||
| rl = newrevlog(recreate=True) | rl = newrevlog(recreate=True) | ||||
| expected = writecases(rl, tr) | expected = writecases(rl, tr) | ||||
| checkrevlog(rl, expected) | checkrevlog(rl, expected) | ||||
| print('local test passed') | print('local test passed') | ||||
| # Copy via revlog.addgroup | # Copy via revlog.addgroup | ||||
| rl1 = addgroupcopy(rl, tr) | rl1 = addgroupcopy(rl, tr) | ||||
| checkrevlog(rl1, expected) | checkrevlog(rl1, expected) | ||||