1. Marcin Kuzminski
  2. RhodeCode
  3. Issues

Issues

Issue #679 resolved

Unknown revision on pull request after merge

Aaron Graddy
created an issue

Tried to comment on a pull request after a merge was done:

Module weberror.errormiddleware:162 in __call__
<<              __traceback_supplement__ = Supplement, self, environ
                   sr_checker = ResponseStartChecker(start_response)
                   app_iter = self.application(environ, sr_checker)
                   return self.make_catching_iter(app_iter, environ, sr_checker)
               except:
>>  app_iter = self.application(environ, sr_checker)
Module beaker.middleware:155 in __call__
<<                          headers.append(('Set-cookie', cookie))
                   return start_response(status, headers, exc_info)
               return self.wrap_app(environ, session_start_response)

           def _get_session(self):
>>  return self.wrap_app(environ, session_start_response)
Module routes.middleware:131 in __call__
<<                                               r'\1', oldpath)

               response = self.app(environ, start_response)

               # Wrapped in try as in rare cases the attribute will be gone already
>>  response = self.app(environ, start_response)
Module pylons.wsgiapp:107 in __call__
<<          
               controller = self.resolve(environ, start_response)
               response = self.dispatch(controller, environ, start_response)

               if 'paste.testing_variables' in environ and hasattr(response,
>>  response = self.dispatch(controller, environ, start_response)
Module pylons.wsgiapp:312 in dispatch
<<          if log_debug:
                   log.debug("Calling controller class with WSGI interface")
               return controller(environ, start_response)

           def load_test_env(self, environ):
>>  return controller(environ, start_response)
Module rhodecode.lib.base:267 in __call__
<<                 self.ip_addr, auth_user, safe_unicode(_get_access_path(environ)))
                   )
                   return WSGIController.__call__(self, environ, start_response)
               finally:
                   log.info('IP: %s Request to %s time: %.3fs' % (
>>  return WSGIController.__call__(self, environ, start_response)
Module pylons.controllers.core:211 in __call__
<<                  return response(environ, self.start_response)

               response = self._dispatch_call()
               if not start_response_called:
                   self.start_response = start_response
>>  response = self._dispatch_call()
Module pylons.controllers.core:162 in _dispatch_call
<<              req.environ['pylons.action_method'] = func

                   response = self._inspect_call(func)
               else:
                   if log_debug:
>>  response = self._inspect_call(func)
Module pylons.controllers.core:105 in _inspect_call
<<                        func.__name__, args)
               try:
                   result = self._perform_call(func, args)
               except HTTPException, httpe:
                   if log_debug:
>>  result = self._perform_call(func, args)
Module pylons.controllers.core:57 in _perform_call
<<          """Hide the traceback for everything above this method"""
               __traceback_hide__ = 'before_and_this'
               return func(**args)

           def _inspect_call(self, func):
>>  return func(**args)
Module rhodecode.controllers.pullrequests:341 in show
<<          # load compare data into template context
               enable_comments = not c.pull_request.is_closed()
               self._load_compare_data(c.pull_request, enable_comments=enable_comments)

               # inline comments
>>  self._load_compare_data(c.pull_request, enable_comments=enable_comments)
Module rhodecode.controllers.pullrequests:274 in _load_compare_data
<<          c.cs_ranges, discovery_data = PullRequestModel().get_compare_data(
                                              org_repo, org_ref, other_repo, other_ref
                                             )
               if c.cs_ranges:
>>  org_repo, org_ref, other_repo, other_ref
Module rhodecode.model.pull_request:260 in get_compare_data
<<                                           other_repo.scm_instance,
                                                other_ref,
                                                discovery_data)

               return cs_ranges, discovery_data
>>  discovery_data)
Module rhodecode.model.pull_request:190 in _get_changesets
<<              ]

                   out = scmutil.revrange(org_repo._repo, revs)
                   for cs in reversed(out):
                       changesets.append(org_repo.get_changeset(cs))
>>  out = scmutil.revrange(org_repo._repo, revs)
Module mercurial.scmutil:622 in revrange
<<          # fall through to new-style queries if old-style fails
               m = revset.match(repo.ui, spec)
               dl = [r for r in m(repo, xrange(len(repo))) if r not in seen]
               l.extend(dl)
               seen.update(dl)
>>  dl = [r for r in m(repo, xrange(len(repo))) if r not in seen]
Module mercurial.revset:1743 in mfunc
<<      weight, tree = optimize(tree, True)
           def mfunc(repo, subset):
               return getset(repo, subset, tree)
           return mfunc
>>  return getset(repo, subset, tree)
Module mercurial.revset:187 in getset
<<      if not x:
               raise error.ParseError(_("missing argument"))
           return methods[x[0]](repo, subset, *x[1:])

       def _getrevsource(repo, r):
>>  return methods[x[0]](repo, subset, *x[1:])
Module mercurial.revset:243 in andset
<<  def andset(repo, subset, x, y):
           return getset(repo, getset(repo, subset, x), y)

       def orset(repo, subset, x, y):
>>  return getset(repo, getset(repo, subset, x), y)
Module mercurial.revset:187 in getset
<<      if not x:
               raise error.ParseError(_("missing argument"))
           return methods[x[0]](repo, subset, *x[1:])

       def _getrevsource(repo, r):
>>  return methods[x[0]](repo, subset, *x[1:])
Module mercurial.revset:252 in notset
<<  def notset(repo, subset, x):
           s = set(getset(repo, subset, x))
           return [r for r in subset if r not in s]
>>  s = set(getset(repo, subset, x))
Module mercurial.revset:187 in getset
<<      if not x:
               raise error.ParseError(_("missing argument"))
           return methods[x[0]](repo, subset, *x[1:])

       def _getrevsource(repo, r):
>>  return methods[x[0]](repo, subset, *x[1:])
Module mercurial.revset:260 in func
<<  def func(repo, subset, a, b):
           if a[0] == 'symbol' and a[1] in symbols:
               return symbols[a[1]](repo, subset, b)
           raise error.ParseError(_("not a function: %s") % a[1])
>>  return symbols[a[1]](repo, subset, b)
Module mercurial.revset:300 in ancestors
<<      Changesets that are ancestors of a changeset in set.
           """
           return _ancestors(repo, subset, x)

       def _firstancestors(repo, subset, x):
>>  return _ancestors(repo, subset, x)
Module mercurial.revset:290 in _ancestors
<<  def _ancestors(repo, subset, x, followfirst=False):
           args = getset(repo, range(len(repo)), x)
           if not args:
               return []
>>  args = getset(repo, range(len(repo)), x)
Module mercurial.revset:187 in getset
<<      if not x:
               raise error.ParseError(_("missing argument"))
           return methods[x[0]](repo, subset, *x[1:])

       def _getrevsource(repo, r):
>>  return methods[x[0]](repo, subset, *x[1:])
Module mercurial.revset:260 in func
<<  def func(repo, subset, a, b):
           if a[0] == 'symbol' and a[1] in symbols:
               return symbols[a[1]](repo, subset, b)
           raise error.ParseError(_("not a function: %s") % a[1])
>>  return symbols[a[1]](repo, subset, b)
Module mercurial.revset:940 in node_
<<      n = getstring(l[0], _("id requires a string"))
           if len(n) == 40:
               rn = repo[n].rev()
           else:
               rn = None
>>  rn = repo[n].rev()
Module mercurial.localrepo:349 in __getitem__
<<          if changeid is None:
                   return context.workingctx(self)
               return context.changectx(self, changeid)

           def __contains__(self, changeid):
>>  return context.changectx(self, changeid)
Module mercurial.context:106 in __init__
<<              pass
               raise error.RepoLookupError(
                   _("unknown revision '%s'") % changeid)

           def __str__(self):
>>  _("unknown revision '%s'") % changeid)
RepoLookupError: unknown revision 'f30498744c014085d3e60c523f832836b1ad4928'

That revision does in fact exist.

Comments (2)

  1. Log in to comment