wireproto: rename wireproto to wireprotov1server (API)

We have wireprotov2server, wireprotov1peer, and wireprotov2peer.
wireproto only contains server functionality. So it makes sense to
rename it to wireprotov1server so the naming aligns with everything
else.

Differential Revision: https://phab.mercurial-scm.org/D3400

hgext/clonebundles.py

@@ -198,7 +198,7 b' from __future__ import absolute_import'
 
 from mercurial import (
     extensions,
-    wireproto,
+    wireprotov1server,
 )
 
 testedwith = 'ships-with-hg-core'
@@ -215,4 +215,4 b' def capabilities(orig, repo, proto):'
     return caps
 
 def extsetup(ui):
-    extensions.wrapfunction(wireproto, '_capabilities', capabilities)
+    extensions.wrapfunction(wireprotov1server, '_capabilities', capabilities)

hgext/infinitepush/__init__.py

@@ -125,9 +125,9 b' from mercurial import ('
     pycompat,
     registrar,
     util,
-    wireproto,
     wireprototypes,
     wireprotov1peer,
+    wireprotov1server,
 )
 
 from . import (
@@ -278,7 +278,7 b' def extsetup(ui):'
         clientextsetup(ui)
 
 def commonsetup(ui):
-    wireproto.commands['listkeyspatterns'] = (
+    wireprotov1server.commands['listkeyspatterns'] = (
         wireprotolistkeyspatterns, 'namespace patterns')
     scratchbranchpat = ui.config('infinitepush', 'branchpattern')
     if scratchbranchpat:
@@ -302,8 +302,8 b' def serverextsetup(ui):'
 
     extensions.wrapfunction(localrepo.localrepository, 'listkeys',
                             localrepolistkeys)
-    wireproto.commands['lookup'] = (
-        _lookupwrap(wireproto.commands['lookup'][0]), 'key')
+    wireprotov1server.commands['lookup'] = (
+        _lookupwrap(wireprotov1server.commands['lookup'][0]), 'key')
     extensions.wrapfunction(exchange, 'getbundlechunks', getbundlechunks)
 
     extensions.wrapfunction(bundle2, 'processparts', processparts)

hgext/largefiles/uisetup.py

@@ -31,7 +31,7 b' from mercurial import ('
     subrepo,
     upgrade,
     url,
-    wireproto,
+    wireprotov1server,
 )
 
 from . import (
@@ -164,22 +164,24 b' def uisetup(ui):'
                             overrides.openlargefile)
 
     # create the new wireproto commands ...
-    wireproto.wireprotocommand('putlfile', 'sha', permission='push')(
+    wireprotov1server.wireprotocommand('putlfile', 'sha', permission='push')(
         proto.putlfile)
-    wireproto.wireprotocommand('getlfile', 'sha', permission='pull')(
+    wireprotov1server.wireprotocommand('getlfile', 'sha', permission='pull')(
         proto.getlfile)
-    wireproto.wireprotocommand('statlfile', 'sha', permission='pull')(
+    wireprotov1server.wireprotocommand('statlfile', 'sha', permission='pull')(
         proto.statlfile)
-    wireproto.wireprotocommand('lheads', '', permission='pull')(
-        wireproto.heads)
+    wireprotov1server.wireprotocommand('lheads', '', permission='pull')(
+        wireprotov1server.heads)
 
     # ... and wrap some existing ones
-    extensions.wrapfunction(wireproto.commands['heads'], 'func', proto.heads)
+    extensions.wrapfunction(wireprotov1server.commands['heads'], 'func',
+                            proto.heads)
     # TODO also wrap wireproto.commandsv2 once heads is implemented there.
 
     extensions.wrapfunction(webcommands, 'decodepath', overrides.decodepath)
 
-    extensions.wrapfunction(wireproto, '_capabilities', proto._capabilities)
+    extensions.wrapfunction(wireprotov1server, '_capabilities',
+                            proto._capabilities)
 
     # can't do this in reposetup because it needs to have happened before
     # wirerepo.__init__ is called

hgext/lfs/__init__.py

@@ -149,8 +149,8 b' from mercurial import ('
     upgrade,
     util,
     vfs as vfsmod,
-    wireproto,
     wireprotoserver,
+    wireprotov1server,
 )
 
 from . import (
@@ -323,7 +323,7 b' def extsetup(ui):'
                  wrapper.allsupportedversions)
 
     wrapfunction(exchange, 'push', wrapper.push)
-    wrapfunction(wireproto, '_capabilities', wrapper._capabilities)
+    wrapfunction(wireprotov1server, '_capabilities', wrapper._capabilities)
     wrapfunction(wireprotoserver, 'handlewsgirequest',
                  wireprotolfsserver.handlewsgirequest)
 

mercurial/sshpeer.py

@@ -15,10 +15,10 b' from . import ('
     error,
     pycompat,
     util,
-    wireproto,
     wireprotoserver,
     wireprototypes,
     wireprotov1peer,
+    wireprotov1server,
 )
 from .utils import (
     procutil,
@@ -441,7 +441,7 b' class sshv1peer(wireprotov1peer.wirepeer'
                         dbg(line % '  %s-%s: %d' % (key, dk, len(dv)))
         self.ui.debug("sending %s command\n" % cmd)
         self._pipeo.write("%s\n" % cmd)
-        _func, names = wireproto.commands[cmd]
+        _func, names = wireprotov1server.commands[cmd]
         keys = names.split()
         wireargs = {}
         for k in keys:

mercurial/wireprotoserver.py

@@ -24,8 +24,8 b' from . import ('
     hook,
     pycompat,
     util,
-    wireproto,
     wireprototypes,
+    wireprotov1server,
     wireprotov2server,
 )
 from .utils import (
@@ -166,7 +166,7 b' class httpv1protocolhandler(object):'
 # there are no other known users, so with any luck we can discard this
 # hook if remotefilelog becomes a first-party extension.
 def iscmd(cmd):
-    return cmd in wireproto.commands
+    return cmd in wireprotov1server.commands
 
 def handlewsgirequest(rctx, req, res, checkperm):
     """Possibly process a wire protocol request.
@@ -329,7 +329,7 b' def _httpresponsetype(ui, proto, prefer_'
             return HGTYPE2, util._noopengine(), {}
 
         # Now find an agreed upon compression format.
-        compformats = wireproto.clientcompressionsupport(proto)
+        compformats = wireprotov1server.clientcompressionsupport(proto)
         for engine in wireprototypes.supportedcompengines(ui, util.SERVERROLE):
             if engine.wireprotosupport().name in compformats:
                 opts = {}
@@ -380,7 +380,7 b' def processcapabilitieshandshake(repo, r'
 
         descriptors[api] = descriptorfn(req, repo)
 
-    v1caps = wireproto.dispatch(repo, proto, 'capabilities')
+    v1caps = wireprotov1server.dispatch(repo, proto, 'capabilities')
     assert isinstance(v1caps, wireprototypes.bytesresponse)
 
     m = {
@@ -424,13 +424,13 b' def _callhttp(repo, req, res, proto, cmd'
         if bodygen is not None:
             res.setbodygen(bodygen)
 
-    if not wireproto.commands.commandavailable(cmd, proto):
+    if not wireprotov1server.commands.commandavailable(cmd, proto):
         setresponse(HTTP_OK, HGERRTYPE,
                     _('requested wire protocol command is not available over '
                       'HTTP'))
         return
 
-    proto.checkperm(wireproto.commands[cmd].permission)
+    proto.checkperm(wireprotov1server.commands[cmd].permission)
 
     # Possibly handle a modern client wanting to switch protocols.
     if (cmd == 'capabilities' and
@@ -438,7 +438,7 b' def _callhttp(repo, req, res, proto, cmd'
 
         return
 
-    rsp = wireproto.dispatch(repo, proto, cmd)
+    rsp = wireprotov1server.dispatch(repo, proto, cmd)
 
     if isinstance(rsp, bytes):
         setresponse(HTTP_OK, HGTYPE, bodybytes=rsp)
@@ -649,7 +649,8 b' def _runsshserver(ui, repo, fin, fout, e'
                 state = 'upgrade-initial'
                 continue
 
-            available = wireproto.commands.commandavailable(request, proto)
+            available = wireprotov1server.commands.commandavailable(
+                request, proto)
 
             # This command isn't available. Send an empty response and go
             # back to waiting for a new command.
@@ -657,7 +658,7 b' def _runsshserver(ui, repo, fin, fout, e'
                 _sshv1respondbytes(fout, b'')
                 continue
 
-            rsp = wireproto.dispatch(repo, proto, request)
+            rsp = wireprotov1server.dispatch(repo, proto, request)
 
             if isinstance(rsp, bytes):
                 _sshv1respondbytes(fout, rsp)
@@ -764,7 +765,7 b' def _runsshserver(ui, repo, fin, fout, e'
         elif state == 'upgrade-v2-finish':
             # Send the upgrade response.
             fout.write(b'upgraded %s %s\n' % (token, SSHV2))
-            servercaps = wireproto.capabilities(repo, proto)
+            servercaps = wireprotov1server.capabilities(repo, proto)
             rsp = b'capabilities: %s' % servercaps.data
             fout.write(b'%d\n%s\n' % (len(rsp), rsp))
             fout.flush()

mercurial/wireprotov1server.py

@@ -1,4 +1,4 b''
-# wireproto.py - generic wire protocol support functions
+# wireprotov1server.py - Wire protocol version 1 server functionality
 #
 # Copyright 2005-2010 Matt Mackall <[e-mail]>
 #

tests/sshprotoext.py

@@ -15,8 +15,8 b' from mercurial import ('
     extensions,
     registrar,
     sshpeer,
-    wireproto,
     wireprotoserver,
+    wireprotov1server,
 )
 
 configtable = {}
@@ -50,7 +50,7 b' class prehelloserver(wireprotoserver.ssh'
         assert l == b'between\n'
         proto = wireprotoserver.sshv1protocolhandler(self._ui, self._fin,
                                                      self._fout)
-        rsp = wireproto.dispatch(self._repo, proto, b'between')
+        rsp = wireprotov1server.dispatch(self._repo, proto, b'between')
         wireprotoserver._sshv1respondbytes(self._fout, rsp.data)
 
         super(prehelloserver, self).serve_forever()

tests/test-http-permissions.t

@@ -3,7 +3,7 b''
   $ cat > fakeremoteuser.py << EOF
   > import os
   > from mercurial.hgweb import hgweb_mod
-  > from mercurial import wireproto
+  > from mercurial import wireprotov1server
   > class testenvhgweb(hgweb_mod.hgweb):
   >     def __call__(self, env, respond):
   >         # Allow REMOTE_USER to define authenticated user.
@@ -15,16 +15,16 b''
   >         return super(testenvhgweb, self).__call__(env, respond)
   > hgweb_mod.hgweb = testenvhgweb
   > 
-  > @wireproto.wireprotocommand('customreadnoperm')
+  > @wireprotov1server.wireprotocommand('customreadnoperm')
   > def customread(repo, proto):
   >     return b'read-only command no defined permissions\n'
-  > @wireproto.wireprotocommand('customwritenoperm')
+  > @wireprotov1server.wireprotocommand('customwritenoperm')
   > def customwritenoperm(repo, proto):
   >     return b'write command no defined permissions\n'
-  > @wireproto.wireprotocommand('customreadwithperm', permission='pull')
+  > @wireprotov1server.wireprotocommand('customreadwithperm', permission='pull')
   > def customreadwithperm(repo, proto):
   >     return b'read-only command w/ defined permissions\n'
-  > @wireproto.wireprotocommand('customwritewithperm', permission='push')
+  > @wireprotov1server.wireprotocommand('customwritewithperm', permission='push')
   > def customwritewithperm(repo, proto):
   >     return b'write command w/ defined permissions\n'
   > EOF

tests/test-sshserver.py

@@ -6,8 +6,8 b' import unittest'
 import silenttestrunner
 
 from mercurial import (
-    wireproto,
     wireprotoserver,
+    wireprotov1server,
 )
 
 from mercurial.utils import (
@@ -29,7 +29,7 b' class SSHServerGetArgsTests(unittest.Tes'
         proto = wireprotoserver.sshv1protocolhandler(server._ui,
                                                      server._fin,
                                                      server._fout)
-        _func, spec = wireproto.commands[cmd]
+        _func, spec = wireprotov1server.commands[cmd]
         self.assertEqual(proto.getargs(spec), expected)
 
 def mockserver(inbytes):

tests/test-wireproto.py

@@ -5,9 +5,9 b' from mercurial import ('
     pycompat,
     ui as uimod,
     util,
-    wireproto,
     wireprototypes,
     wireprotov1peer,
+    wireprotov1server,
 )
 stringio = util.stringio
 
@@ -55,7 +55,7 b' class clientpeer(wireprotov1peer.wirepee'
 
     def _call(self, cmd, **args):
         args = pycompat.byteskwargs(args)
-        res = wireproto.dispatch(self.serverrepo, proto(args), cmd)
+        res = wireprotov1server.dispatch(self.serverrepo, proto(args), cmd)
         if isinstance(res, wireprototypes.bytesresponse):
             return res.data
         elif isinstance(res, bytes):
@@ -87,7 +87,7 b' def unmangle(s):'
 def greet(repo, proto, name):
     return mangle(repo.greet(unmangle(name)))
 
-wireproto.commands[b'greet'] = (greet, b'name',)
+wireprotov1server.commands[b'greet'] = (greet, b'name')
 
 srv = serverrepo()
 clt = clientpeer(srv, uimod.ui())

tests/wireprotohelpers.sh

@@ -16,11 +16,11 b' sendhttpv2peerhandshake() {'
 cat > dummycommands.py << EOF
 from mercurial import (
     wireprototypes,
+    wireprotov1server,
     wireprotov2server,
-    wireproto,
 )
 
[e-mail]('customreadonly', permission='pull')
[e-mail]('customreadonly', permission='pull')
 def customreadonlyv1(repo, proto):
     return wireprototypes.bytesresponse(b'customreadonly bytes response')
 
@@ -28,7 +28,7 b' def customreadonlyv1(repo, proto):'
 def customreadonlyv2(repo, proto):
     return wireprototypes.cborresponse(b'customreadonly bytes response')
 
[e-mail]('customreadwrite', permission='push')
[e-mail]('customreadwrite', permission='push')
 def customreadwrite(repo, proto):
     return wireprototypes.bytesresponse(b'customreadwrite bytes response')