rhodecode-vcsserver Compare - rhodecode-vcsserver@2582dee7dd4c0f1028fd5a55cdf1913c32cb520a > rhodecode-vcsserver@5682a2ff63e2d0d10d3e1e4aa81010bff74b5011

Compare Commits

Target:

Source:

Actions:

Compare Commits Swap

Time	Author	Commit		Description
0 commits hidden, click expand to show them.
No commits in this compare

Collapse all files

vcsserver/exceptions.py

0 0 -2

             # RhodeCode VCSServer provides access to different vcs backends via network.
             # Copyright (C) 2014-2016 RodeCode GmbH
             #
             # This program is free software; you can redistribute it and/or modify
             # it under the terms of the GNU General Public License as published by
             # the Free Software Foundation; either version 3 of the License, or
             # (at your option) any later version.
             #
             # This program is distributed in the hope that it will be useful,
             # but WITHOUT ANY WARRANTY; without even the implied warranty of
             # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
             # GNU General Public License for more details.
             #
             # You should have received a copy of the GNU General Public License
             # along with this program; if not, write to the Free Software Foundation,
             # Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301  USA
             """
             Special exception handling over the wire.
             Since we cannot assume that our client is able to import our exception classes,
             this module provides a "wrapping" mechanism to raise plain exceptions
             which contain an extra attribute `_vcs_kind` to allow a client to distinguish
             different error conditions.
             """
             import functools
             from pyramid.httpexceptions import HTTPLocked
             def _make_exception(kind, *args):
                 """
                 Prepares a base `Exception` instance to be sent over the wire.
                 To give our caller a hint what this is about, it will attach an attribute
                 `_vcs_kind` to the exception.
                 """
                 exc = Exception(*args)
                 exc._vcs_kind = kind
                 return exc
             AbortException = functools.partial(_make_exception, 'abort')
             ArchiveException = functools.partial(_make_exception, 'archive')
             LookupException = functools.partial(_make_exception, 'lookup')
             VcsException = functools.partial(_make_exception, 'error')
             RepositoryLockedException = functools.partial(_make_exception, 'repo_locked')
             RequirementException = functools.partial(_make_exception, 'requirement')
             UnhandledException = functools.partial(_make_exception, 'unhandled')
             URLError = functools.partial(_make_exception, 'url_error')
-            SubrepoMergeException = functools.partial(_make_exception, 'subrepo_merge_error')
             class HTTPRepoLocked(HTTPLocked):
                 """
                 Subclass of HTTPLocked response that allows to set the title and status
                 code via constructor arguments.
                 """
                 def __init__(self, title, status_code=None, **kwargs):
                     self.code = status_code or HTTPLocked.code
                     self.title = title
                     super(HTTPRepoLocked, self).__init__(**kwargs)

vcsserver/hg.py

0 0 -7

             # RhodeCode VCSServer provides access to different vcs backends via network.
             # Copyright (C) 2014-2016 RodeCode GmbH
             #
             # This program is free software; you can redistribute it and/or modify
             # it under the terms of the GNU General Public License as published by
             # the Free Software Foundation; either version 3 of the License, or
             # (at your option) any later version.
             #
             # This program is distributed in the hope that it will be useful,
             # but WITHOUT ANY WARRANTY; without even the implied warranty of
             # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
             # GNU General Public License for more details.
             #
             # You should have received a copy of the GNU General Public License
             # along with this program; if not, write to the Free Software Foundation,
             # Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301  USA
             import io
             import logging
             import stat
             import sys
             import urllib
             import urllib2
             from hgext import largefiles, rebase
             from hgext.strip import strip as hgext_strip
             from mercurial import commands
             from mercurial import unionrepo
             from vcsserver import exceptions
             from vcsserver.base import RepoFactory
             from vcsserver.hgcompat import (
                 archival, bin, clone, config as hgconfig, diffopts, hex, hg_url,
                 httpbasicauthhandler, httpdigestauthhandler, httppeer, localrepository,
                 match, memctx, exchange, memfilectx, nullrev, patch, peer, revrange, ui,
                 Abort, LookupError, RepoError, RepoLookupError, InterventionRequired,
                 RequirementError)
             log = logging.getLogger(__name__)
             def make_ui_from_config(repo_config):
                 baseui = ui.ui()
                 # clean the baseui object
                 baseui._ocfg = hgconfig.config()
                 baseui._ucfg = hgconfig.config()
                 baseui._tcfg = hgconfig.config()
                 for section, option, value in repo_config:
                     baseui.setconfig(section, option, value)
                 # make our hgweb quiet so it doesn't print output
                 baseui.setconfig('ui', 'quiet', 'true')
                 # force mercurial to only use 1 thread, otherwise it may try to set a
                 # signal in a non-main thread, thus generating a ValueError.
                 baseui.setconfig('worker', 'numcpus', 1)
                 # If there is no config for the largefiles extension, we explicitly disable
                 # it here. This overrides settings from repositories hgrc file. Recent
                 # mercurial versions enable largefiles in hgrc on clone from largefile
                 # repo.
                 if not baseui.hasconfig('extensions', 'largefiles'):
                     log.debug('Explicitly disable largefiles extension for repo.')
                     baseui.setconfig('extensions', 'largefiles', '!')
                 return baseui
             def reraise_safe_exceptions(func):
                 """Decorator for converting mercurial exceptions to something neutral."""
                 def wrapper(*args, **kwargs):
                     try:
                         return func(*args, **kwargs)
                     except (Abort, InterventionRequired):
                         raise_from_original(exceptions.AbortException)
                     except RepoLookupError:
                         raise_from_original(exceptions.LookupException)
                     except RequirementError:
                         raise_from_original(exceptions.RequirementException)
                     except RepoError:
                         raise_from_original(exceptions.VcsException)
                     except LookupError:
                         raise_from_original(exceptions.LookupException)
                     except Exception as e:
                         if not hasattr(e, '_vcs_kind'):
                             log.exception("Unhandled exception in hg remote call")
                             raise_from_original(exceptions.UnhandledException)
                         raise
                 return wrapper
             def raise_from_original(new_type):
                 """
                 Raise a new exception type with original args and traceback.
                 """
                 _, original, traceback = sys.exc_info()
                 try:
                     raise new_type(*original.args), None, traceback
                 finally:
                     del traceback
             class MercurialFactory(RepoFactory):
                 def _create_config(self, config, hooks=True):
                     if not hooks:
                         hooks_to_clean = frozenset((
                             'changegroup.repo_size', 'preoutgoing.pre_pull',
                             'outgoing.pull_logger', 'prechangegroup.pre_push'))
                         new_config = []
                         for section, option, value in config:
                             if section == 'hooks' and option in hooks_to_clean:
                                 continue
                             new_config.append((section, option, value))
                         config = new_config
                     baseui = make_ui_from_config(config)
                     return baseui
                 def _create_repo(self, wire, create):
                     baseui = self._create_config(wire["config"])
                     return localrepository(baseui, wire["path"], create)
             class HgRemote(object):
                 def __init__(self, factory):
                     self._factory = factory
                     self._bulk_methods = {
                         "affected_files": self.ctx_files,
                         "author": self.ctx_user,
                         "branch": self.ctx_branch,
                         "children": self.ctx_children,
                         "date": self.ctx_date,
                         "message": self.ctx_description,
                         "parents": self.ctx_parents,
                         "status": self.ctx_status,
                         "_file_paths": self.ctx_list,
                     }
                 @reraise_safe_exceptions
                 def archive_repo(self, archive_path, mtime, file_info, kind):
                     if kind == "tgz":
                         archiver = archival.tarit(archive_path, mtime, "gz")
                     elif kind == "tbz2":
                         archiver = archival.tarit(archive_path, mtime, "bz2")
                     elif kind == 'zip':
                         archiver = archival.zipit(archive_path, mtime)
                     else:
                         raise exceptions.ArchiveException(
                             'Remote does not support: "%s".' % kind)
                     for f_path, f_mode, f_is_link, f_content in file_info:
                         archiver.addfile(f_path, f_mode, f_is_link, f_content)
                     archiver.done()
                 @reraise_safe_exceptions
                 def bookmarks(self, wire):
                     repo = self._factory.repo(wire)
                     return dict(repo._bookmarks)
                 @reraise_safe_exceptions
                 def branches(self, wire, normal, closed):
                     repo = self._factory.repo(wire)
                     iter_branches = repo.branchmap().iterbranches()
                     bt = {}
                     for branch_name, _heads, tip, is_closed in iter_branches:
                         if normal and not is_closed:
                             bt[branch_name] = tip
                         if closed and is_closed:
                             bt[branch_name] = tip
                     return bt
                 @reraise_safe_exceptions
                 def bulk_request(self, wire, rev, pre_load):
                     result = {}
                     for attr in pre_load:
                         try:
                             method = self._bulk_methods[attr]
                             result[attr] = method(wire, rev)
                         except KeyError:
                             raise exceptions.VcsException(
                                 'Unknown bulk attribute: "%s"' % attr)
                     return result
                 @reraise_safe_exceptions
                 def clone(self, wire, source, dest, update_after_clone=False, hooks=True):
                     baseui = self._factory._create_config(wire["config"], hooks=hooks)
                     clone(baseui, source, dest, noupdate=not update_after_clone)
                 @reraise_safe_exceptions
                 def commitctx(
                         self, wire, message, parents, commit_time, commit_timezone,
                         user, files, extra, removed, updated):
                     def _filectxfn(_repo, memctx, path):
                         """
                         Marks given path as added/changed/removed in a given _repo. This is
                         for internal mercurial commit function.
                         """
                         # check if this path is removed
                         if path in removed:
                             # returning None is a way to mark node for removal
                             return None
                         # check if this path is added
                         for node in updated:
                             if node['path'] == path:
                                 return memfilectx(
                                     _repo,
                                     path=node['path'],
                                     data=node['content'],
                                     islink=False,
                                     isexec=bool(node['mode'] & stat.S_IXUSR),
                                     copied=False,
                                     memctx=memctx)
                         raise exceptions.AbortException(
                             "Given path haven't been marked as added, "
                             "changed or removed (%s)" % path)
                     repo = self._factory.repo(wire)
                     commit_ctx = memctx(
                         repo=repo,
                         parents=parents,
                         text=message,
                         files=files,
                         filectxfn=_filectxfn,
                         user=user,
                         date=(commit_time, commit_timezone),
                         extra=extra)
                     n = repo.commitctx(commit_ctx)
                     new_id = hex(n)
                     return new_id
                 @reraise_safe_exceptions
                 def ctx_branch(self, wire, revision):
                     repo = self._factory.repo(wire)
                     ctx = repo[revision]
                     return ctx.branch()
                 @reraise_safe_exceptions
                 def ctx_children(self, wire, revision):
                     repo = self._factory.repo(wire)
                     ctx = repo[revision]
                     return [child.rev() for child in ctx.children()]
                 @reraise_safe_exceptions
                 def ctx_date(self, wire, revision):
                     repo = self._factory.repo(wire)
                     ctx = repo[revision]
                     return ctx.date()
                 @reraise_safe_exceptions
                 def ctx_description(self, wire, revision):
                     repo = self._factory.repo(wire)
                     ctx = repo[revision]
                     return ctx.description()
                 @reraise_safe_exceptions
                 def ctx_diff(
                         self, wire, revision, git=True, ignore_whitespace=True, context=3):
                     repo = self._factory.repo(wire)
                     ctx = repo[revision]
                     result = ctx.diff(
                         git=git, ignore_whitespace=ignore_whitespace, context=context)
                     return list(result)
                 @reraise_safe_exceptions
                 def ctx_files(self, wire, revision):
                     repo = self._factory.repo(wire)
                     ctx = repo[revision]
                     return ctx.files()
                 @reraise_safe_exceptions
                 def ctx_list(self, path, revision):
                     repo = self._factory.repo(path)
                     ctx = repo[revision]
                     return list(ctx)
                 @reraise_safe_exceptions
                 def ctx_parents(self, wire, revision):
                     repo = self._factory.repo(wire)
                     ctx = repo[revision]
                     return [parent.rev() for parent in ctx.parents()]
                 @reraise_safe_exceptions
                 def ctx_substate(self, wire, revision):
                     repo = self._factory.repo(wire)
                     ctx = repo[revision]
                     return ctx.substate
                 @reraise_safe_exceptions
                 def ctx_status(self, wire, revision):
                     repo = self._factory.repo(wire)
                     ctx = repo[revision]
                     status = repo[ctx.p1().node()].status(other=ctx.node())
                     # object of status (odd, custom named tuple in mercurial) is not
                     # correctly serializable via Pyro, we make it a list, as the underling
                     # API expects this to be a list
                     return list(status)
                 @reraise_safe_exceptions
                 def ctx_user(self, wire, revision):
                     repo = self._factory.repo(wire)
                     ctx = repo[revision]
                     return ctx.user()
                 @reraise_safe_exceptions
                 def check_url(self, url, config):
                     log.info("Checking URL for remote cloning/import: %s", url)
                     _proto = None
                     if '+' in url[:url.find('://')]:
                         _proto = url[0:url.find('+')]
                         url = url[url.find('+') + 1:]
                     handlers = []
                     url_obj = hg_url(url)
                     test_uri, authinfo = url_obj.authinfo()
                     url_obj.passwd = '*****'
                     cleaned_uri = str(url_obj)
                     if authinfo:
                         # create a password manager
                         passmgr = urllib2.HTTPPasswordMgrWithDefaultRealm()
                         passmgr.add_password(*authinfo)
                         handlers.extend((httpbasicauthhandler(passmgr),
                                          httpdigestauthhandler(passmgr)))
                     o = urllib2.build_opener(*handlers)
                     o.addheaders = [('Content-Type', 'application/mercurial-0.1'),
                                     ('Accept', 'application/mercurial-0.1')]
                     q = {"cmd": 'between'}
                     q.update({'pairs': "%s-%s" % ('0' * 40, '0' * 40)})
                     qs = '?%s' % urllib.urlencode(q)
                     cu = "%s%s" % (test_uri, qs)
                     req = urllib2.Request(cu, None, {})
                     try:
                         log.debug("Trying to open URL %s", url)
                         resp = o.open(req)
                         if resp.code != 200:
                             raise exceptions.URLError('Return Code is not 200')
                     except Exception as e:
                         log.warning("URL cannot be opened: %s", url, exc_info=True)
                         # means it cannot be cloned
                         raise exceptions.URLError("[%s] org_exc: %s" % (cleaned_uri, e))
                     # now check if it's a proper hg repo, but don't do it for svn
                     try:
                         if _proto == 'svn':
                             pass
                         else:
                             # check for pure hg repos
                             log.debug(
                                 "Verifying if URL is a Mercurial repository: %s", url)
                             httppeer(make_ui_from_config(config), url).lookup('tip')
                     except Exception as e:
                         log.warning("URL is not a valid Mercurial repository: %s", url)
                         raise exceptions.URLError(
                             "url [%s] does not look like an hg repo org_exc: %s"
                             % (cleaned_uri, e))
                     log.info("URL is a valid Mercurial repository: %s", url)
                     return True
                 @reraise_safe_exceptions
                 def diff(
                         self, wire, rev1, rev2, file_filter, opt_git, opt_ignorews,
                         context):
                     repo = self._factory.repo(wire)
                     if file_filter:
                         filter = match(file_filter[0], '', [file_filter[1]])
                     else:
                         filter = file_filter
                     opts = diffopts(git=opt_git, ignorews=opt_ignorews, context=context)
                     try:
                         return "".join(patch.diff(
                             repo, node1=rev1, node2=rev2, match=filter, opts=opts))
                     except RepoLookupError:
                         raise exceptions.LookupException()
                 @reraise_safe_exceptions
                 def file_history(self, wire, revision, path, limit):
                     repo = self._factory.repo(wire)
                     ctx = repo[revision]
                     fctx = ctx.filectx(path)
                     def history_iter():
                         limit_rev = fctx.rev()
                         for obj in reversed(list(fctx.filelog())):
                             obj = fctx.filectx(obj)
                             if limit_rev >= obj.rev():
                                 yield obj
                     history = []
                     for cnt, obj in enumerate(history_iter()):
                         if limit and cnt >= limit:
                             break
                         history.append(hex(obj.node()))
                     return [x for x in history]
                 @reraise_safe_exceptions
                 def file_history_untill(self, wire, revision, path, limit):
                     repo = self._factory.repo(wire)
                     ctx = repo[revision]
                     fctx = ctx.filectx(path)
                     file_log = list(fctx.filelog())
                     if limit:
                         # Limit to the last n items
                         file_log = file_log[-limit:]
                     return [hex(fctx.filectx(cs).node()) for cs in reversed(file_log)]
                 @reraise_safe_exceptions
                 def fctx_annotate(self, wire, revision, path):
                     repo = self._factory.repo(wire)
                     ctx = repo[revision]
                     fctx = ctx.filectx(path)
                     result = []
                     for i, annotate_data in enumerate(fctx.annotate()):
                         ln_no = i + 1
                         sha = hex(annotate_data[0].node())
                         result.append((ln_no, sha, annotate_data[1]))
                     return result
                 @reraise_safe_exceptions
                 def fctx_data(self, wire, revision, path):
                     repo = self._factory.repo(wire)
                     ctx = repo[revision]
                     fctx = ctx.filectx(path)
                     return fctx.data()
                 @reraise_safe_exceptions
                 def fctx_flags(self, wire, revision, path):
                     repo = self._factory.repo(wire)
                     ctx = repo[revision]
                     fctx = ctx.filectx(path)
                     return fctx.flags()
                 @reraise_safe_exceptions
                 def fctx_size(self, wire, revision, path):
                     repo = self._factory.repo(wire)
                     ctx = repo[revision]
                     fctx = ctx.filectx(path)
                     return fctx.size()
                 @reraise_safe_exceptions
                 def get_all_commit_ids(self, wire, name):
                     repo = self._factory.repo(wire)
                     revs = repo.filtered(name).changelog.index
                     return map(lambda x: hex(x[7]), revs)[:-1]
                 @reraise_safe_exceptions
                 def get_config_value(self, wire, section, name, untrusted=False):
                     repo = self._factory.repo(wire)
                     return repo.ui.config(section, name, untrusted=untrusted)
                 @reraise_safe_exceptions
                 def get_config_bool(self, wire, section, name, untrusted=False):
                     repo = self._factory.repo(wire)
                     return repo.ui.configbool(section, name, untrusted=untrusted)
                 @reraise_safe_exceptions
                 def get_config_list(self, wire, section, name, untrusted=False):
                     repo = self._factory.repo(wire)
                     return repo.ui.configlist(section, name, untrusted=untrusted)
                 @reraise_safe_exceptions
                 def is_large_file(self, wire, path):
                     return largefiles.lfutil.isstandin(path)
                 @reraise_safe_exceptions
                 def in_store(self, wire, sha):
                     repo = self._factory.repo(wire)
                     return largefiles.lfutil.instore(repo, sha)
                 @reraise_safe_exceptions
                 def in_user_cache(self, wire, sha):
                     repo = self._factory.repo(wire)
                     return largefiles.lfutil.inusercache(repo.ui, sha)
                 @reraise_safe_exceptions
                 def store_path(self, wire, sha):
                     repo = self._factory.repo(wire)
                     return largefiles.lfutil.storepath(repo, sha)
                 @reraise_safe_exceptions
                 def link(self, wire, sha, path):
                     repo = self._factory.repo(wire)
                     largefiles.lfutil.link(
                         largefiles.lfutil.usercachepath(repo.ui, sha), path)
                 @reraise_safe_exceptions
                 def localrepository(self, wire, create=False):
                     self._factory.repo(wire, create=create)
                 @reraise_safe_exceptions
                 def lookup(self, wire, revision, both):
                     # TODO Paris: Ugly hack to "deserialize" long for msgpack
                     if isinstance(revision, float):
                         revision = long(revision)
                     repo = self._factory.repo(wire)
                     try:
                         ctx = repo[revision]
                     except RepoLookupError:
                         raise exceptions.LookupException(revision)
                     except LookupError as e:
                         raise exceptions.LookupException(e.name)
                     if not both:
                         return ctx.hex()
                     ctx = repo[ctx.hex()]
                     return ctx.hex(), ctx.rev()
                 @reraise_safe_exceptions
                 def pull(self, wire, url, commit_ids=None):
                     repo = self._factory.repo(wire)
                     remote = peer(repo, {}, url)
                     if commit_ids:
                         commit_ids = [bin(commit_id) for commit_id in commit_ids]
                     return exchange.pull(
                         repo, remote, heads=commit_ids, force=None).cgresult
                 @reraise_safe_exceptions
                 def revision(self, wire, rev):
                     repo = self._factory.repo(wire)
                     ctx = repo[rev]
                     return ctx.rev()
                 @reraise_safe_exceptions
                 def rev_range(self, wire, filter):
                     repo = self._factory.repo(wire)
                     revisions = [rev for rev in revrange(repo, filter)]
                     return revisions
                 @reraise_safe_exceptions
                 def rev_range_hash(self, wire, node):
                     repo = self._factory.repo(wire)
                     def get_revs(repo, rev_opt):
                         if rev_opt:
                             revs = revrange(repo, rev_opt)
                             if len(revs) == 0:
                                 return (nullrev, nullrev)
                             return max(revs), min(revs)
                         else:
                             return len(repo) - 1, 0
                     stop, start = get_revs(repo, [node + ':'])
                     revs = [hex(repo[r].node()) for r in xrange(start, stop + 1)]
                     return revs
                 @reraise_safe_exceptions
                 def revs_from_revspec(self, wire, rev_spec, *args, **kwargs):
                     other_path = kwargs.pop('other_path', None)
                     # case when we want to compare two independent repositories
                     if other_path and other_path != wire["path"]:
                         baseui = self._factory._create_config(wire["config"])
                         repo = unionrepo.unionrepository(baseui, other_path, wire["path"])
                     else:
                         repo = self._factory.repo(wire)
                     return list(repo.revs(rev_spec, *args))
                 @reraise_safe_exceptions
                 def strip(self, wire, revision, update, backup):
                     repo = self._factory.repo(wire)
                     ctx = repo[revision]
                     hgext_strip(
                         repo.baseui, repo, ctx.node(), update=update, backup=backup)
                 @reraise_safe_exceptions
                 def tag(self, wire, name, revision, message, local, user,
                         tag_time, tag_timezone):
                     repo = self._factory.repo(wire)
                     ctx = repo[revision]
                     node = ctx.node()
                     date = (tag_time, tag_timezone)
                     try:
                         repo.tag(name, node, message, local, user, date)
                     except Abort:
                         log.exception("Tag operation aborted")
                         raise exceptions.AbortException()
                 @reraise_safe_exceptions
                 def tags(self, wire):
                     repo = self._factory.repo(wire)
                     return repo.tags()
                 @reraise_safe_exceptions
                 def update(self, wire, node=None, clean=False):
                     repo = self._factory.repo(wire)
                     baseui = self._factory._create_config(wire['config'])
                     commands.update(baseui, repo, node=node, clean=clean)
                 @reraise_safe_exceptions
                 def identify(self, wire):
                     repo = self._factory.repo(wire)
                     baseui = self._factory._create_config(wire['config'])
                     output = io.BytesIO()
                     baseui.write = output.write
                     # This is required to get a full node id
                     baseui.debugflag = True
                     commands.identify(baseui, repo, id=True)
                     return output.getvalue()
                 @reraise_safe_exceptions
                 def pull_cmd(self, wire, source, bookmark=None, branch=None, revision=None,
                              hooks=True):
                     repo = self._factory.repo(wire)
                     baseui = self._factory._create_config(wire['config'], hooks=hooks)
                     # Mercurial internally has a lot of logic that checks ONLY if
                     # option is defined, we just pass those if they are defined then
                     opts = {}
                     if bookmark:
                         opts['bookmark'] = bookmark
                     if branch:
                         opts['branch'] = branch
                     if revision:
                         opts['rev'] = revision
                     commands.pull(baseui, repo, source, **opts)
                 @reraise_safe_exceptions
                 def heads(self, wire, branch=None):
                     repo = self._factory.repo(wire)
                     baseui = self._factory._create_config(wire['config'])
                     output = io.BytesIO()
                     def write(data, **unused_kwargs):
                         output.write(data)
                     baseui.write = write
                     if branch:
                         args = [branch]
                     else:
                         args = []
                     commands.heads(baseui, repo, template='{node} ', *args)
                     return output.getvalue()
                 @reraise_safe_exceptions
                 def ancestor(self, wire, revision1, revision2):
                     repo = self._factory.repo(wire)
                     baseui = self._factory._create_config(wire['config'])
                     output = io.BytesIO()
                     baseui.write = output.write
                     commands.debugancestor(baseui, repo, revision1, revision2)
                     return output.getvalue()
                 @reraise_safe_exceptions
                 def push(self, wire, revisions, dest_path, hooks=True,
                          push_branches=False):
                     repo = self._factory.repo(wire)
                     baseui = self._factory._create_config(wire['config'], hooks=hooks)
                     commands.push(baseui, repo, dest=dest_path, rev=revisions,
                                   new_branch=push_branches)
                 @reraise_safe_exceptions
                 def merge(self, wire, revision):
                     repo = self._factory.repo(wire)
                     baseui = self._factory._create_config(wire['config'])
                     repo.ui.setconfig('ui', 'merge', 'internal:dump')
-                    # In case of sub repositories are used mercurial prompts the user in
-                    # case of merge conflicts or different sub repository sources. By
-                    # setting the interactive flag to `False` mercurial doesn't prompt the
-                    # used but instead uses a default value.
-                    repo.ui.setconfig('ui', 'interactive', False)
                     commands.merge(baseui, repo, rev=revision)
                 @reraise_safe_exceptions
                 def commit(self, wire, message, username):
                     repo = self._factory.repo(wire)
                     baseui = self._factory._create_config(wire['config'])
                     repo.ui.setconfig('ui', 'username', username)
                     commands.commit(baseui, repo, message=message)
                 @reraise_safe_exceptions
                 def rebase(self, wire, source=None, dest=None, abort=False):
                     repo = self._factory.repo(wire)
                     baseui = self._factory._create_config(wire['config'])
                     repo.ui.setconfig('ui', 'merge', 'internal:dump')
                     rebase.rebase(
                         baseui, repo, base=source, dest=dest, abort=abort, keep=not abort)
                 @reraise_safe_exceptions
                 def bookmark(self, wire, bookmark, revision=None):
                     repo = self._factory.repo(wire)
                     baseui = self._factory._create_config(wire['config'])
                     commands.bookmark(baseui, repo, bookmark, rev=revision, force=True)

vcsserver/hgcompat.py

0 0 -1

             # RhodeCode VCSServer provides access to different vcs backends via network.
             # Copyright (C) 2014-2016 RodeCode GmbH
             #
             # This program is free software; you can redistribute it and/or modify
             # it under the terms of the GNU General Public License as published by
             # the Free Software Foundation; either version 3 of the License, or
             # (at your option) any later version.
             #
             # This program is distributed in the hope that it will be useful,
             # but WITHOUT ANY WARRANTY; without even the implied warranty of
             # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
             # GNU General Public License for more details.
             #
             # You should have received a copy of the GNU General Public License
             # along with this program; if not, write to the Free Software Foundation,
             # Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301  USA
             """
             Mercurial libs compatibility
             """
             import mercurial
             import mercurial.demandimport
             # patch demandimport, due to bug in mercurial when it always triggers
             # demandimport.enable()
             mercurial.demandimport.enable = lambda *args, **kwargs: 1
             from mercurial import ui
             from mercurial import patch
             from mercurial import config
             from mercurial import extensions
             from mercurial import scmutil
             from mercurial import archival
             from mercurial import discovery
             from mercurial import unionrepo
             from mercurial import localrepo
             from mercurial import merge as hg_merge
-            from mercurial import subrepo
             from mercurial.commands import clone, nullid, pull
             from mercurial.context import memctx, memfilectx
             from mercurial.error import (
                 LookupError, RepoError, RepoLookupError, Abort, InterventionRequired,
                 RequirementError)
             from mercurial.hgweb import hgweb_mod
             from mercurial.localrepo import localrepository
             from mercurial.match import match
             from mercurial.mdiff import diffopts
             from mercurial.node import bin, hex
             from mercurial.encoding import tolocal
             from mercurial.discovery import findcommonoutgoing
             from mercurial.hg import peer
             from mercurial.httppeer import httppeer
             from mercurial.util import url as hg_url
             from mercurial.scmutil import revrange
             from mercurial.node import nullrev
             from mercurial import exchange
             from hgext import largefiles
             # those authnadlers are patched for python 2.6.5 bug an
             # infinit looping when given invalid resources
             from mercurial.url import httpbasicauthhandler, httpdigestauthhandler

vcsserver/hgpatches.py

0 0 -74

             # RhodeCode VCSServer provides access to different vcs backends via network.
             # Copyright (C) 2014-2016 RodeCode GmbH
             #
             # This program is free software; you can redistribute it and/or modify
             # it under the terms of the GNU General Public License as published by
             # the Free Software Foundation; either version 3 of the License, or
             # (at your option) any later version.
             #
             # This program is distributed in the hope that it will be useful,
             # but WITHOUT ANY WARRANTY; without even the implied warranty of
             # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
             # GNU General Public License for more details.
             #
             # You should have received a copy of the GNU General Public License
             # along with this program; if not, write to the Free Software Foundation,
             # Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301  USA
             """
             Adjustments to Mercurial
             Intentionally kept separate from `hgcompat` and `hg`, so that these patches can
             be applied without having to import the whole Mercurial machinery.
             Imports are function local, so that just importing this module does not cause
             side-effects other than these functions being defined.
             """
             import logging
             def patch_largefiles_capabilities():
                 """
                 Patches the capabilities function in the largefiles extension.
                 """
                 from vcsserver import hgcompat
                 lfproto = hgcompat.largefiles.proto
                 wrapper = _dynamic_capabilities_wrapper(
                     lfproto, hgcompat.extensions.extensions)
                 lfproto.capabilities = wrapper
             def _dynamic_capabilities_wrapper(lfproto, extensions):
                 wrapped_capabilities = lfproto.capabilities
                 logger = logging.getLogger('vcsserver.hg')
                 def _dynamic_capabilities(repo, proto):
                     """
                     Adds dynamic behavior, so that the capability is only added if the
                     extension is enabled in the current ui object.
                     """
                     if 'largefiles' in dict(extensions(repo.ui)):
                         logger.debug('Extension largefiles enabled')
                         calc_capabilities = wrapped_capabilities
                     else:
                         logger.debug('Extension largefiles disabled')
                         calc_capabilities = lfproto.capabilitiesorig
                     return calc_capabilities(repo, proto)
                 return _dynamic_capabilities
-            def patch_subrepo_type_mapping():
-                from collections import defaultdict
-                from hgcompat import subrepo
-                from exceptions import SubrepoMergeException
-                class NoOpSubrepo(subrepo.abstractsubrepo):
-                    def __init__(self, ctx, path, *args, **kwargs):
-                        """Initialize abstractsubrepo part
-                        ``ctx`` is the context referring this subrepository in the
-                        parent repository.
-                        ``path`` is the path to this subrepository as seen from
-                        innermost repository.
-                        """
-                        self.ui = ctx.repo().ui
-                        self._ctx = ctx
-                        self._path = path
-                    def storeclean(self, path):
-                        """
-                        returns true if the repository has not changed since it was last
-                        cloned from or pushed to a given repository.
-                        """
-                        return True
-                    def dirty(self, ignoreupdate=False):
-                        """returns true if the dirstate of the subrepo is dirty or does not
-                        match current stored state. If ignoreupdate is true, only check
-                        whether the subrepo has uncommitted changes in its dirstate.
-                        """
-                        return False
-                    def basestate(self):
-                        """current working directory base state, disregarding .hgsubstate
-                        state and working directory modifications"""
-                        substate = subrepo.state(self._ctx, self.ui)
-                        file_system_path, rev, repotype = substate.get(self._path)
-                        return rev
-                    def remove(self):
-                        """remove the subrepo
-                        (should verify the dirstate is not dirty first)
-                        """
-                        pass
-                    def get(self, state, overwrite=False):
-                        """run whatever commands are needed to put the subrepo into
-                        this state
-                        """
-                        pass
-                    def merge(self, state):
-                        """merge currently-saved state with the new state."""
-                        raise SubrepoMergeException()
-                    def push(self, opts):
-                        """perform whatever action is analogous to 'hg push'
-                        This may be a no-op on some systems.
-                        """
-                        pass
-                # Patch subrepo type mapping to always return our NoOpSubrepo class
-                # whenever a subrepo class is looked up.
-                subrepo.types = {
-                    'hg': NoOpSubrepo,
-                    'git': NoOpSubrepo,
-                    'svn': NoOpSubrepo

vcsserver/http_main.py

0 0 -1

             # RhodeCode VCSServer provides access to different vcs backends via network.
             # Copyright (C) 2014-2016 RodeCode GmbH
             #
             # This program is free software; you can redistribute it and/or modify
             # it under the terms of the GNU General Public License as published by
             # the Free Software Foundation; either version 3 of the License, or
             # (at your option) any later version.
             #
             # This program is distributed in the hope that it will be useful,
             # but WITHOUT ANY WARRANTY; without even the implied warranty of
             # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
             # GNU General Public License for more details.
             #
             # You should have received a copy of the GNU General Public License
             # along with this program; if not, write to the Free Software Foundation,
             # Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301  USA
             import base64
             import locale
             import logging
             import uuid
             import wsgiref.util
             from itertools import chain
             import msgpack
             from beaker.cache import CacheManager
             from beaker.util import parse_cache_config_options
             from pyramid.config import Configurator
             from pyramid.wsgi import wsgiapp
             from vcsserver import remote_wsgi, scm_app, settings, hgpatches
             from vcsserver.echo_stub import remote_wsgi as remote_wsgi_stub
             from vcsserver.echo_stub.echo_app import EchoApp
             from vcsserver.exceptions import HTTPRepoLocked
             from vcsserver.server import VcsServer
             try:
                 from vcsserver.git import GitFactory, GitRemote
             except ImportError:
                 GitFactory = None
                 GitRemote = None
             try:
                 from vcsserver.hg import MercurialFactory, HgRemote
             except ImportError:
                 MercurialFactory = None
                 HgRemote = None
             try:
                 from vcsserver.svn import SubversionFactory, SvnRemote
             except ImportError:
                 SubversionFactory = None
                 SvnRemote = None
             log = logging.getLogger(__name__)
             class VCS(object):
                 def __init__(self, locale=None, cache_config=None):
                     self.locale = locale
                     self.cache_config = cache_config
                     self._configure_locale()
                     self._initialize_cache()
                     if GitFactory and GitRemote:
                         git_repo_cache = self.cache.get_cache_region(
                             'git', region='repo_object')
                         git_factory = GitFactory(git_repo_cache)
                         self._git_remote = GitRemote(git_factory)
                     else:
                         log.info("Git client import failed")
                     if MercurialFactory and HgRemote:
                         hg_repo_cache = self.cache.get_cache_region(
                             'hg', region='repo_object')
                         hg_factory = MercurialFactory(hg_repo_cache)
                         self._hg_remote = HgRemote(hg_factory)
                     else:
                         log.info("Mercurial client import failed")
                     if SubversionFactory and SvnRemote:
                         svn_repo_cache = self.cache.get_cache_region(
                             'svn', region='repo_object')
                         svn_factory = SubversionFactory(svn_repo_cache)
                         self._svn_remote = SvnRemote(svn_factory, hg_factory=hg_factory)
                     else:
                         log.info("Subversion client import failed")
                     self._vcsserver = VcsServer()
                 def _initialize_cache(self):
                     cache_config = parse_cache_config_options(self.cache_config)
                     log.info('Initializing beaker cache: %s' % cache_config)
                     self.cache = CacheManager(**cache_config)
                 def _configure_locale(self):
                     if self.locale:
                         log.info('Settings locale: `LC_ALL` to %s' % self.locale)
                     else:
                         log.info(
                             'Configuring locale subsystem based on environment variables')
                     try:
                         # If self.locale is the empty string, then the locale
                         # module will use the environment variables. See the
                         # documentation of the package `locale`.
                         locale.setlocale(locale.LC_ALL, self.locale)
                         language_code, encoding = locale.getlocale()
                         log.info(
                             'Locale set to language code "%s" with encoding "%s".',
                             language_code, encoding)
                     except locale.Error:
                         log.exception(
                             'Cannot set locale, not configuring the locale system')
             class WsgiProxy(object):
                 def __init__(self, wsgi):
                     self.wsgi = wsgi
                 def __call__(self, environ, start_response):
                     input_data = environ['wsgi.input'].read()
                     input_data = msgpack.unpackb(input_data)
                     error = None
                     try:
                         data, status, headers = self.wsgi.handle(
                             input_data['environment'], input_data['input_data'],
                             *input_data['args'], **input_data['kwargs'])
                     except Exception as e:
                         data, status, headers = [], None, None
                         error = {
                             'message': str(e),
                             '_vcs_kind': getattr(e, '_vcs_kind', None)
                         }
                     start_response(200, {})
                     return self._iterator(error, status, headers, data)
                 def _iterator(self, error, status, headers, data):
                     initial_data = [
                         error,
                         status,
                         headers,
                     ]
                     for d in chain(initial_data, data):
                         yield msgpack.packb(d)
             class HTTPApplication(object):
                 ALLOWED_EXCEPTIONS = ('KeyError', 'URLError')
                 remote_wsgi = remote_wsgi
                 _use_echo_app = False
                 def __init__(self, settings=None):
                     self.config = Configurator(settings=settings)
                     locale = settings.get('', 'en_US.UTF-8')
                     vcs = VCS(locale=locale, cache_config=settings)
                     self._remotes = {
                         'hg': vcs._hg_remote,
                         'git': vcs._git_remote,
                         'svn': vcs._svn_remote,
                         'server': vcs._vcsserver,
                     }
                     if settings.get('dev.use_echo_app', 'false').lower() == 'true':
                         self._use_echo_app = True
                         log.warning("Using EchoApp for VCS operations.")
                         self.remote_wsgi = remote_wsgi_stub
                     self._configure_settings(settings)
                     self._configure()
                 def _configure_settings(self, app_settings):
                     """
                     Configure the settings module.
                     """
                     git_path = app_settings.get('git_path', None)
                     if git_path:
                         settings.GIT_EXECUTABLE = git_path
                 def _configure(self):
                     self.config.add_renderer(
                         name='msgpack',
                         factory=self._msgpack_renderer_factory)
                     self.config.add_route('status', '/status')
                     self.config.add_route('hg_proxy', '/proxy/hg')
                     self.config.add_route('git_proxy', '/proxy/git')
                     self.config.add_route('vcs', '/{backend}')
                     self.config.add_route('stream_git', '/stream/git/*repo_name')
                     self.config.add_route('stream_hg', '/stream/hg/*repo_name')
                     self.config.add_view(
                         self.status_view, route_name='status', renderer='json')
                     self.config.add_view(self.hg_proxy(), route_name='hg_proxy')
                     self.config.add_view(self.git_proxy(), route_name='git_proxy')
                     self.config.add_view(
                         self.vcs_view, route_name='vcs', renderer='msgpack')
                     self.config.add_view(self.hg_stream(), route_name='stream_hg')
                     self.config.add_view(self.git_stream(), route_name='stream_git')
                     self.config.add_view(
                         self.handle_vcs_exception, context=Exception,
                         custom_predicates=[self.is_vcs_exception])
                 def wsgi_app(self):
                     return self.config.make_wsgi_app()
                 def vcs_view(self, request):
                     remote = self._remotes[request.matchdict['backend']]
                     payload = msgpack.unpackb(request.body, use_list=True)
                     method = payload.get('method')
                     params = payload.get('params')
                     wire = params.get('wire')
                     args = params.get('args')
                     kwargs = params.get('kwargs')
                     if wire:
                         try:
                             wire['context'] = uuid.UUID(wire['context'])
                         except KeyError:
                             pass
                         args.insert(0, wire)
                     try:
                         resp = getattr(remote, method)(*args, **kwargs)
                     except Exception as e:
                         type_ = e.__class__.__name__
                         if type_ not in self.ALLOWED_EXCEPTIONS:
                             type_ = None
                         resp = {
                             'id': payload.get('id'),
                             'error': {
                                 'message': e.message,
                                 'type': type_
                             }
                         }
                         try:
                             resp['error']['_vcs_kind'] = e._vcs_kind
                         except AttributeError:
                             pass
                     else:
                         resp = {
                             'id': payload.get('id'),
                             'result': resp
                         }
                     return resp
                 def status_view(self, request):
                     return {'status': 'OK'}
                 def _msgpack_renderer_factory(self, info):
                     def _render(value, system):
                         value = msgpack.packb(value)
                         request = system.get('request')
                         if request is not None:
                             response = request.response
                             ct = response.content_type
                             if ct == response.default_content_type:
                                 response.content_type = 'application/x-msgpack'
                         return value
                     return _render
                 def hg_proxy(self):
                     @wsgiapp
                     def _hg_proxy(environ, start_response):
                         app = WsgiProxy(self.remote_wsgi.HgRemoteWsgi())
                         return app(environ, start_response)
                     return _hg_proxy
                 def git_proxy(self):
                     @wsgiapp
                     def _git_proxy(environ, start_response):
                         app = WsgiProxy(self.remote_wsgi.GitRemoteWsgi())
                         return app(environ, start_response)
                     return _git_proxy
                 def hg_stream(self):
                     if self._use_echo_app:
                         @wsgiapp
                         def _hg_stream(environ, start_response):
                             app = EchoApp('fake_path', 'fake_name', None)
                             return app(environ, start_response)
                         return _hg_stream
                     else:
                         @wsgiapp
                         def _hg_stream(environ, start_response):
                             repo_path = environ['HTTP_X_RC_REPO_PATH']
                             repo_name = environ['HTTP_X_RC_REPO_NAME']
                             packed_config = base64.b64decode(
                                 environ['HTTP_X_RC_REPO_CONFIG'])
                             config = msgpack.unpackb(packed_config)
                             app = scm_app.create_hg_wsgi_app(
                                 repo_path, repo_name, config)
                             # Consitent path information for hgweb
                             environ['PATH_INFO'] = environ['HTTP_X_RC_PATH_INFO']
                             environ['REPO_NAME'] = repo_name
                             return app(environ, ResponseFilter(start_response))
                         return _hg_stream
                 def git_stream(self):
                     if self._use_echo_app:
                         @wsgiapp
                         def _git_stream(environ, start_response):
                             app = EchoApp('fake_path', 'fake_name', None)
                             return app(environ, start_response)
                         return _git_stream
                     else:
                         @wsgiapp
                         def _git_stream(environ, start_response):
                             repo_path = environ['HTTP_X_RC_REPO_PATH']
                             repo_name = environ['HTTP_X_RC_REPO_NAME']
                             packed_config = base64.b64decode(
                                 environ['HTTP_X_RC_REPO_CONFIG'])
                             config = msgpack.unpackb(packed_config)
                             environ['PATH_INFO'] = environ['HTTP_X_RC_PATH_INFO']
                             app = scm_app.create_git_wsgi_app(
                                 repo_path, repo_name, config)
                             return app(environ, start_response)
                         return _git_stream
                 def is_vcs_exception(self, context, request):
                     """
                     View predicate that returns true if the context object is a VCS
                     exception.
                     """
                     return hasattr(context, '_vcs_kind')
                 def handle_vcs_exception(self, exception, request):
                     if exception._vcs_kind == 'repo_locked':
                         # Get custom repo-locked status code if present.
                         status_code = request.headers.get('X-RC-Locked-Status-Code')
                         return HTTPRepoLocked(
                             title=exception.message, status_code=status_code)
                     # Re-raise exception if we can not handle it.
                     raise exception
             class ResponseFilter(object):
                 def __init__(self, start_response):
                     self._start_response = start_response
                 def __call__(self, status, response_headers, exc_info=None):
                     headers = tuple(
                         (h, v) for h, v in response_headers
                         if not wsgiref.util.is_hop_by_hop(h))
                     return self._start_response(status, headers, exc_info)
             def main(global_config, **settings):
                 if MercurialFactory:
                     hgpatches.patch_largefiles_capabilities()
-                    hgpatches.patch_subrepo_type_mapping()
                 app = HTTPApplication(settings=settings)
                 return app.wsgi_app()

vcsserver/main.py

0 0 -1

             # RhodeCode VCSServer provides access to different vcs backends via network.
             # Copyright (C) 2014-2016 RodeCode GmbH
             #
             # This program is free software; you can redistribute it and/or modify
             # it under the terms of the GNU General Public License as published by
             # the Free Software Foundation; either version 3 of the License, or
             # (at your option) any later version.
             #
             # This program is distributed in the hope that it will be useful,
             # but WITHOUT ANY WARRANTY; without even the implied warranty of
             # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
             # GNU General Public License for more details.
             #
             # You should have received a copy of the GNU General Public License
             # along with this program; if not, write to the Free Software Foundation,
             # Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301  USA
             import atexit
             import locale
             import logging
             import optparse
             import os
             import textwrap
             import threading
             import sys
             import configobj
             import Pyro4
             from beaker.cache import CacheManager
             from beaker.util import parse_cache_config_options
             try:
                 from vcsserver.git import GitFactory, GitRemote
             except ImportError:
                 GitFactory = None
                 GitRemote = None
             try:
                 from vcsserver.hg import MercurialFactory, HgRemote
             except ImportError:
                 MercurialFactory = None
                 HgRemote = None
             try:
                 from vcsserver.svn import SubversionFactory, SvnRemote
             except ImportError:
                 SubversionFactory = None
                 SvnRemote = None
             from server import VcsServer
             from vcsserver import hgpatches, remote_wsgi, settings
             from vcsserver.echo_stub import remote_wsgi as remote_wsgi_stub
             log = logging.getLogger(__name__)
             HERE = os.path.dirname(os.path.abspath(__file__))
             SERVER_RUNNING_FILE = None
             # HOOKS - inspired by gunicorn #
             def when_ready(server):
                 """
                 Called just after the server is started.
                 """
                 def _remove_server_running_file():
                     if os.path.isfile(SERVER_RUNNING_FILE):
                         os.remove(SERVER_RUNNING_FILE)
                 # top up to match to level location
                 if SERVER_RUNNING_FILE:
                     with open(SERVER_RUNNING_FILE, 'wb') as f:
                         f.write(str(os.getpid()))
                     # register cleanup of that file when server exits
                     atexit.register(_remove_server_running_file)
             class LazyWriter(object):
                 """
                 File-like object that opens a file lazily when it is first written
                 to.
                 """
                 def __init__(self, filename, mode='w'):
                     self.filename = filename
                     self.fileobj = None
                     self.lock = threading.Lock()
                     self.mode = mode
                 def open(self):
                     if self.fileobj is None:
                         with self.lock:
                             self.fileobj = open(self.filename, self.mode)
                     return self.fileobj
                 def close(self):
                     fileobj = self.fileobj
                     if fileobj is not None:
                         fileobj.close()
                 def __del__(self):
                     self.close()
                 def write(self, text):
                     fileobj = self.open()
                     fileobj.write(text)
                     fileobj.flush()
                 def writelines(self, text):
                     fileobj = self.open()
                     fileobj.writelines(text)
                     fileobj.flush()
                 def flush(self):
                     self.open().flush()
             class Application(object):
                 """
                 Represents the vcs server application.
                 This object is responsible to initialize the application and all needed
                 libraries. After that it hooks together the different objects and provides
                 them a way to access things like configuration.
                 """
                 def __init__(
                         self, host, port=None, locale='', threadpool_size=None,
                         timeout=None, cache_config=None, remote_wsgi_=None):
                     self.host = host
                     self.port = int(port) or settings.PYRO_PORT
                     self.threadpool_size = (
                         int(threadpool_size) if threadpool_size else None)
                     self.locale = locale
                     self.timeout = timeout
                     self.cache_config = cache_config
                     self.remote_wsgi = remote_wsgi_ or remote_wsgi
                 def init(self):
                     """
                     Configure and hook together all relevant objects.
                     """
                     self._configure_locale()
                     self._configure_pyro()
                     self._initialize_cache()
                     self._create_daemon_and_remote_objects(host=self.host, port=self.port)
                 def run(self):
                     """
                     Start the main loop of the application.
                     """
                     if hasattr(os, 'getpid'):
                         log.info('Starting %s in PID %i.', __name__, os.getpid())
                     else:
                         log.info('Starting %s.', __name__)
                     if SERVER_RUNNING_FILE:
                         log.info('PID file written as %s', SERVER_RUNNING_FILE)
                     else:
                         log.info('No PID file written by default.')
                     when_ready(self)
                     try:
                         self._pyrodaemon.requestLoop(
                             loopCondition=lambda: not self._vcsserver._shutdown)
                     finally:
                         self._pyrodaemon.shutdown()
                 def _configure_locale(self):
                     if self.locale:
                         log.info('Settings locale: `LC_ALL` to %s' % self.locale)
                     else:
                         log.info(
                             'Configuring locale subsystem based on environment variables')
                     try:
                         # If self.locale is the empty string, then the locale
                         # module will use the environment variables. See the
                         # documentation of the package `locale`.
                         locale.setlocale(locale.LC_ALL, self.locale)
                         language_code, encoding = locale.getlocale()
                         log.info(
                             'Locale set to language code "%s" with encoding "%s".',
                             language_code, encoding)
                     except locale.Error:
                         log.exception(
                             'Cannot set locale, not configuring the locale system')
                 def _configure_pyro(self):
                     if self.threadpool_size is not None:
                         log.info("Threadpool size set to %s", self.threadpool_size)
                         Pyro4.config.THREADPOOL_SIZE = self.threadpool_size
                     if self.timeout not in (None, 0, 0.0, '0'):
                         log.info("Timeout for RPC calls set to %s seconds", self.timeout)
                         Pyro4.config.COMMTIMEOUT = float(self.timeout)
                     Pyro4.config.SERIALIZER = 'pickle'
                     Pyro4.config.SERIALIZERS_ACCEPTED.add('pickle')
                     Pyro4.config.SOCK_REUSE = True
                     # Uncomment the next line when you need to debug remote errors
                     # Pyro4.config.DETAILED_TRACEBACK = True
                 def _initialize_cache(self):
                     cache_config = parse_cache_config_options(self.cache_config)
                     log.info('Initializing beaker cache: %s' % cache_config)
                     self.cache = CacheManager(**cache_config)
                 def _create_daemon_and_remote_objects(self, host='localhost',
                                                       port=settings.PYRO_PORT):
                     daemon = Pyro4.Daemon(host=host, port=port)
                     self._vcsserver = VcsServer()
                     uri = daemon.register(
                         self._vcsserver, objectId=settings.PYRO_VCSSERVER)
                     log.info("Object registered = %s", uri)
                     if GitFactory and GitRemote:
                         git_repo_cache = self.cache.get_cache_region('git', region='repo_object')
                         git_factory = GitFactory(git_repo_cache)
                         self._git_remote = GitRemote(git_factory)
                         uri = daemon.register(self._git_remote, objectId=settings.PYRO_GIT)
                         log.info("Object registered = %s", uri)
                     else:
                         log.info("Git client import failed")
                     if MercurialFactory and HgRemote:
                         hg_repo_cache = self.cache.get_cache_region('hg', region='repo_object')
                         hg_factory = MercurialFactory(hg_repo_cache)
                         self._hg_remote = HgRemote(hg_factory)
                         uri = daemon.register(self._hg_remote, objectId=settings.PYRO_HG)
                         log.info("Object registered = %s", uri)
                     else:
                         log.info("Mercurial client import failed")
                     if SubversionFactory and SvnRemote:
                         svn_repo_cache = self.cache.get_cache_region('svn', region='repo_object')
                         svn_factory = SubversionFactory(svn_repo_cache)
                         self._svn_remote = SvnRemote(svn_factory, hg_factory=hg_factory)
                         uri = daemon.register(self._svn_remote, objectId=settings.PYRO_SVN)
                         log.info("Object registered = %s", uri)
                     else:
                         log.info("Subversion client import failed")
                     self._git_remote_wsgi = self.remote_wsgi.GitRemoteWsgi()
                     uri = daemon.register(self._git_remote_wsgi,
                                           objectId=settings.PYRO_GIT_REMOTE_WSGI)
                     log.info("Object registered = %s", uri)
                     self._hg_remote_wsgi = self.remote_wsgi.HgRemoteWsgi()
                     uri = daemon.register(self._hg_remote_wsgi,
                                           objectId=settings.PYRO_HG_REMOTE_WSGI)
                     log.info("Object registered = %s", uri)
                     self._pyrodaemon = daemon
             class VcsServerCommand(object):
                 usage = '%prog'
                 description = """
                 Runs the VCS server
                 """
                 default_verbosity = 1
                 parser = optparse.OptionParser(
                     usage,
                     description=textwrap.dedent(description)
                 )
                 parser.add_option(
                     '--host',
                     type="str",
                     dest="host",
                 )
                 parser.add_option(
                     '--port',
                     type="int",
                     dest="port"
                 )
                 parser.add_option(
                     '--running-file',
                     dest='running_file',
                     metavar='RUNNING_FILE',
                     help="Create a running file after the server is initalized with "
                          "stored PID of process"
                 )
                 parser.add_option(
                     '--locale',
                     dest='locale',
                     help="Allows to set the locale, e.g. en_US.UTF-8",
                     default=""
                 )
                 parser.add_option(
                     '--log-file',
                     dest='log_file',
                     metavar='LOG_FILE',
                     help="Save output to the given log file (redirects stdout)"
                 )
                 parser.add_option(
                     '--log-level',
                     dest="log_level",
                     metavar="LOG_LEVEL",
                     help="use LOG_LEVEL to set log level "
                          "(debug,info,warning,error,critical)"
                 )
                 parser.add_option(
                     '--threadpool',
                     dest='threadpool_size',
                     type='int',
                     help="Set the size of the threadpool used to communicate with the "
                          "WSGI workers. This should be at least 6 times the number of "
                          "WSGI worker processes."
                     )
                 parser.add_option(
                     '--timeout',
                     dest='timeout',
                     type='float',
                     help="Set the timeout for RPC communication in seconds."
                     )
                 parser.add_option(
                     '--config',
                     dest='config_file',
                     type='string',
                     help="Configuration file for vcsserver."
                     )
                 def __init__(self, argv, quiet=False):
                     self.options, self.args = self.parser.parse_args(argv[1:])
                     if quiet:
                         self.options.verbose = 0
                 def _get_file_config(self):
                     ini_conf = {}
                     conf = configobj.ConfigObj(self.options.config_file)
                     if 'DEFAULT' in conf:
                         ini_conf = conf['DEFAULT']
                     return ini_conf
                 def _show_config(self, vcsserver_config):
                     order = [
                         'config_file',
                         'host',
                         'port',
                         'log_file',
                         'log_level',
                         'locale',
                         'threadpool_size',
                         'timeout',
                         'cache_config',
                     ]
                     def sorter(k):
                         return dict([(y, x) for x, y in enumerate(order)]).get(k)
                     _config = []
                     for k in sorted(vcsserver_config.keys(), key=sorter):
                         v = vcsserver_config[k]
                         # construct padded key for display eg %-20s % = key:   val
                         k_formatted = ('%-'+str(len(max(order, key=len))+1)+'s') % (k+':')
                         _config.append('    * %s %s' % (k_formatted, v))
                     log.info('\n[vcsserver configuration]:\n'+'\n'.join(_config))
                 def _get_vcsserver_configuration(self):
                     _defaults = {
                         'config_file': None,
                         'git_path': 'git',
                         'host': 'localhost',
                         'port': settings.PYRO_PORT,
                         'log_file': None,
                         'log_level': 'debug',
                         'locale': None,
                         'threadpool_size': 16,
                         'timeout': None,
                         # Development support
                         'dev.use_echo_app': False,
                         # caches, baker style config
                         'beaker.cache.regions': 'repo_object',
                         'beaker.cache.repo_object.expire': '10',
                         'beaker.cache.repo_object.type': 'memory',
                     }
                     config = {}
                     config.update(_defaults)
                     # overwrite defaults with one loaded from file
                     config.update(self._get_file_config())
                     # overwrite with self.option which has the top priority
                     for k, v in self.options.__dict__.items():
                         if v or v == 0:
                             config[k] = v
                     # clear all "extra" keys if they are somehow passed,
                     # we only want defaults, so any extra stuff from self.options is cleared
                     # except beaker stuff which needs to be dynamic
                     for k in [k for k in config.copy().keys() if not k.startswith('beaker.cache.')]:
                         if k not in _defaults:
                             del config[k]
                     # group together the cache into one key.
                     # Needed further for beaker lib configuration
                     _k = {}
                     for k in [k for k in config.copy() if k.startswith('beaker.cache.')]:
                         _k[k] = config.pop(k)
                     config['cache_config'] = _k
                     return config
                 def out(self, msg):  # pragma: no cover
                     if self.options.verbose > 0:
                         print(msg)
                 def run(self):  # pragma: no cover
                     vcsserver_config = self._get_vcsserver_configuration()
                     # Ensure the log file is writeable
                     if vcsserver_config['log_file']:
                         stdout_log = self._configure_logfile()
                     else:
                         stdout_log = None
                     # set PID file with running lock
                     if self.options.running_file:
                         global SERVER_RUNNING_FILE
                         SERVER_RUNNING_FILE = self.options.running_file
                     # configure logging, and logging based on configuration file
                     self._configure_logging(level=vcsserver_config['log_level'],
                                             stream=stdout_log)
                     if self.options.config_file:
                         if not os.path.isfile(self.options.config_file):
                             raise OSError('File %s does not exist' %
                                           self.options.config_file)
                         self._configure_file_logging(self.options.config_file)
                     self._configure_settings(vcsserver_config)
                     # display current configuration of vcsserver
                     self._show_config(vcsserver_config)
                     if not vcsserver_config['dev.use_echo_app']:
                         remote_wsgi_mod = remote_wsgi
                     else:
                         log.warning("Using EchoApp for VCS endpoints.")
                         remote_wsgi_mod = remote_wsgi_stub
                     app = Application(
                         host=vcsserver_config['host'],
                         port=vcsserver_config['port'],
                         locale=vcsserver_config['locale'],
                         threadpool_size=vcsserver_config['threadpool_size'],
                         timeout=vcsserver_config['timeout'],
                         cache_config=vcsserver_config['cache_config'],
                         remote_wsgi_=remote_wsgi_mod)
                     app.init()
                     app.run()
                 def _configure_logging(self, level, stream=None):
                     _format = (
                         '%(asctime)s.%(msecs)03d %(levelname)-5.5s [%(name)s] %(message)s')
                     levels = {
                         'debug': logging.DEBUG,
                         'info': logging.INFO,
                         'warning': logging.WARNING,
                         'error': logging.ERROR,
                         'critical': logging.CRITICAL,
                         }
                     try:
                         level = levels[level]
                     except KeyError:
                         raise AttributeError(
                             'Invalid log level please use one of %s' % (levels.keys(),))
                     logging.basicConfig(format=_format, stream=stream, level=level)
                     logging.getLogger('Pyro4').setLevel(level)
                 def _configure_file_logging(self, config):
                     import logging.config
                     try:
                         logging.config.fileConfig(config)
                     except Exception as e:
                         log.warning('Failed to configure logging based on given '
                                     'config file. Error: %s' % e)
                 def _configure_logfile(self):
                     try:
                         writeable_log_file = open(self.options.log_file, 'a')
                     except IOError as ioe:
                         msg = 'Error: Unable to write to log file: %s' % ioe
                         raise ValueError(msg)
                     writeable_log_file.close()
                     stdout_log = LazyWriter(self.options.log_file, 'a')
                     sys.stdout = stdout_log
                     sys.stderr = stdout_log
                     return stdout_log
                 def _configure_settings(self, config):
                     """
                     Configure the settings module based on the given `config`.
                     """
                     settings.GIT_EXECUTABLE = config['git_path']
             def main(argv=sys.argv, quiet=False):
                 if MercurialFactory:
                     hgpatches.patch_largefiles_capabilities()
-                    hgpatches.patch_subrepo_type_mapping()
                 command = VcsServerCommand(argv, quiet=quiet)
                 return command.run()

	Site-wide shortcuts
/	Use quick search box
g h	Goto home page
g g	Goto my private gists page
g G	Goto my public gists page
g 0-9	Goto bookmarked items from 0-9
n r	New repository page
n g	New gist page

	Repositories
g s	Goto summary page
g c	Goto changelog page
g f	Goto files page
g F	Goto files page with file search activated
g p	Goto pull requests page
g o	Goto repository settings
g O	Goto repository access permissions settings
t s	Toggle sidebar on some pages