upstream/mercurial-mirror Commit - r40165:293835e0

wireprotov2: pass ui into clientreactor and serverreactor...

Gregory Szorc -

r40165:293835e0 default

parent child

mercurial/httppeer.py

0 +2 -1

             def sendv2request(ui, opener, requestbuilder, apiurl, permission, requests,
                               redirect):
-                reactor = wireprotoframing.clientreactor(hasmultiplesend=False,
+                reactor = wireprotoframing.clientreactor(ui,
+                                                         hasmultiplesend=False,
                                                          buffersends=True)
                 handler = wireprotov2peer.clienthandler(ui, reactor,

mercurial/wireprotoframing.py

0 +4 -2

                 between who responds to what.
                 """
-                def __init__(self, deferoutput=False):
+                def __init__(self, ui, deferoutput=False):
                     """Construct a new server reactor.
                     ``deferoutput`` can be used to indicate that no output frames should be
                     send those frames. This is useful for half-duplex transports where the
                     sender cannot receive until all data has been transmitted.
                     """
+                    self._ui = ui
                     self._deferoutput = deferoutput
                     self._state = 'initial'
                     self._nextoutgoingstreamid = 2
                    is expected to follow or we're at the end of the response stream,
                    respectively.
                 """
-                def __init__(self, hasmultiplesend=False, buffersends=True):
+                def __init__(self, ui, hasmultiplesend=False, buffersends=True):
                     """Create a new instance.
                     ``hasmultiplesend`` indicates whether multiple sends are supported
                     ``buffercommands`` indicates whether sends should be buffered until the
                     last request has been issued.
                     """
+                    self._ui = ui
                     self._hasmultiplesend = hasmultiplesend
                     self._buffersends = buffersends

mercurial/wireprotov2server.py

0 +2 -2

                 # We assume we have a unified framing protocol request body.
-                reactor = wireprotoframing.serverreactor()
+                reactor = wireprotoframing.serverreactor(ui)
                 states = []
                 while True:
                 # TODO Some HTTP clients are full duplex and can receive data before
                 # the entire request is transmitted. Figure out a way to indicate support
                 # for that so we can opt into full duplex mode.
-                reactor = wireprotoframing.serverreactor(deferoutput=True)
+                reactor = wireprotoframing.serverreactor(ui, deferoutput=True)
                 seencommand = False
                 outstream = reactor.makeoutputstream()

tests/test-wireproto-clientreactor.py

0 +21 -14

             from mercurial import (
                 error,
+                ui as uimod,
                 wireprotoframing as framing,
             )
             from mercurial.utils import (
             ffs = framing.makeframefromhumanstring
+            globalui = uimod.ui()
             def sendframe(reactor, frame):
                 """Send a frame bytearray to a reactor."""
                 header = framing.parseheader(frame)
                         unittest.TestCase.assertRaisesRegexp)
                 def testbasic(self):
-                    reactor = framing.clientreactor(hasmultiplesend=False, buffersends=True)
+                    reactor = framing.clientreactor(globalui,
+                                                    hasmultiplesend=False,
+                                                    buffersends=True)
                     request, action, meta = reactor.callcommand(b'foo', {})
                     self.assertEqual(request.state, b'pending')
             class NoBufferTests(unittest.TestCase):
                 """A reactor without send buffering sends requests immediately."""
                 def testbasic(self):
-                    reactor = framing.clientreactor(hasmultiplesend=True, buffersends=False)
+                    reactor = framing.clientreactor(globalui,
+                                                    hasmultiplesend=True,
+                                                    buffersends=False)
                     request, action, meta = reactor.callcommand(b'command1', {})
                     self.assertEqual(request.requestid, 1)
                         unittest.TestCase.assertRaisesRegexp)
                 def testoddstream(self):
-                    reactor = framing.clientreactor()
+                    reactor = framing.clientreactor(globalui)
                     action, meta = sendframe(reactor, ffs(b'1 1 0 1 0 foo'))
                     self.assertEqual(action, b'error')
                                      b'received frame with odd numbered stream ID: 1')
                 def testunknownstream(self):
-                    reactor = framing.clientreactor()
+                    reactor = framing.clientreactor(globalui)
                     action, meta = sendframe(reactor, ffs(b'1 0 0 1 0 foo'))
                     self.assertEqual(action, b'error')
                                      b'of stream flag set')
                 def testunhandledframetype(self):
-                    reactor = framing.clientreactor(buffersends=False)
+                    reactor = framing.clientreactor(globalui, buffersends=False)
                     request, action, meta = reactor.callcommand(b'foo', {})
                     for frame in meta[b'framegen']:
             class StreamTests(unittest.TestCase):
                 def testmultipleresponseframes(self):
-                    reactor = framing.clientreactor(buffersends=False)
+                    reactor = framing.clientreactor(globalui, buffersends=False)
                     request, action, meta = reactor.callcommand(b'foo', {})
             class RedirectTests(unittest.TestCase):
                 def testredirect(self):
-                    reactor = framing.clientreactor(buffersends=False)
+                    reactor = framing.clientreactor(globalui, buffersends=False)
                     redirect = {
                         b'targets': [b'a', b'b'],
             class StreamSettingsTests(unittest.TestCase):
                 def testnoflags(self):
-                    reactor = framing.clientreactor(buffersends=False)
+                    reactor = framing.clientreactor(globalui, buffersends=False)
                     request, action, meta = reactor.callcommand(b'foo', {})
                     for f in meta[b'framegen']:
                     })
                 def testconflictflags(self):
-                    reactor = framing.clientreactor(buffersends=False)
+                    reactor = framing.clientreactor(globalui, buffersends=False)
                     request, action, meta = reactor.callcommand(b'foo', {})
                     for f in meta[b'framegen']:
                     })
                 def testemptypayload(self):
-                    reactor = framing.clientreactor(buffersends=False)
+                    reactor = framing.clientreactor(globalui, buffersends=False)
                     request, action, meta = reactor.callcommand(b'foo', {})
                     for f in meta[b'framegen']:
                     })
                 def testbadcbor(self):
-                    reactor = framing.clientreactor(buffersends=False)
+                    reactor = framing.clientreactor(globalui, buffersends=False)
                     request, action, meta = reactor.callcommand(b'foo', {})
                     for f in meta[b'framegen']:
                     self.assertEqual(action, b'error')
                 def testsingleobject(self):
-                    reactor = framing.clientreactor(buffersends=False)
+                    reactor = framing.clientreactor(globalui, buffersends=False)
                     request, action, meta = reactor.callcommand(b'foo', {})
                     for f in meta[b'framegen']:
                     self.assertEqual(meta, {})
                 def testmultipleobjects(self):
-                    reactor = framing.clientreactor(buffersends=False)
+                    reactor = framing.clientreactor(globalui, buffersends=False)
                     request, action, meta = reactor.callcommand(b'foo', {})
                     for f in meta[b'framegen']:
                     self.assertEqual(meta, {})
                 def testmultipleframes(self):
-                    reactor = framing.clientreactor(buffersends=False)
+                    reactor = framing.clientreactor(globalui, buffersends=False)
                     request, action, meta = reactor.callcommand(b'foo', {})
                     for f in meta[b'framegen']:

tests/test-wireproto-serverreactor.py

0 +3 -1

                 cbor,
             )
             from mercurial import (
+                ui as uimod,
                 util,
                 wireprotoframing as framing,
             )
             OK = cbor.dumps({b'status': b'ok'})
             def makereactor(deferoutput=False):
-                return framing.serverreactor(deferoutput=deferoutput)
+                ui = uimod.ui()
+                return framing.serverreactor(ui, deferoutput=deferoutput)
             def sendframes(reactor, gen):
                 """Send a generator of frame bytearray to a reactor.

General Comments 0

Write
Preview

You need to be logged in to leave comments. Login now

No TODOs yet

	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