wireproto: use maybecapturestdio() for push responses (API)

The "pushres" and "pusherr" response types currently call
proto.restore() in the HTTP protocol. This completes the pairing
with proto.redirect() that occurs in the @wireprotocommand
functions. (But since the SSH protocol has a no-op redirect(),
it doesn't bother calling restore() because it would also be
a no-op.)

Having the disconnect between these paired calls is very confusing.
Knowing that you must use proto.redirect() if returning a "pushres"
or a "pusherr" is even wonkier.

We replace this confusing code with our new context manager for
[maybe] capturing output.

The "pushres" and "pusherr" types have gained an "output" argument
to their constructor and an attribute to hold captured data. The
HTTP protocol now retrieves output from these objects.

.. api::

   ``wireproto.pushres`` and ``wireproto.pusherr`` now explicitly
   track stdio output.

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

hgext/largefiles/proto.py

@@ -34,8 +34,7 httpoldcallstream = None
 def putlfile(repo, proto, sha):
     '''Server command for putting a largefile into a repository's local store
     and into the user cache.'''
-    proto.redirect()
-
+    with proto.mayberedirectstdio() as output:
     path = lfutil.storepath(repo, sha)
     util.makedirs(os.path.dirname(path))
     tmpfp = util.atomictempfile(path, createmode=repo.store.createmode)
@@ -50,11 +49,11 def putlfile(repo, proto, sha):
     except IOError as e:
         repo.ui.warn(_('largefiles: failed to put %s into store: %s\n') %
                      (sha, e.strerror))
-        return wireproto.pushres(1)
+            return wireproto.pushres(1, output.getvalue() if output else '')
     finally:
         tmpfp.discard()
 
-    return wireproto.pushres(0)
+    return wireproto.pushres(0, output.getvalue() if output else '')
 
 def getlfile(repo, proto, sha):
     '''Server command for retrieving a largefile from the repository-local

mercurial/wireproto.py

@@ -510,16 +510,18 class pushres(object):
 
     The call was successful and returned an integer contained in `self.res`.
     """
-    def __init__(self, res):
+    def __init__(self, res, output):
         self.res = res
+        self.output = output
 
 class pusherr(object):
     """wireproto reply: failure
 
     The call failed. The `self.res` attribute contains the error message.
     """
-    def __init__(self, res):
+    def __init__(self, res, output):
         self.res = res
+        self.output = output
 
 class ooberror(object):
     """wireproto reply: failure of a batch of operation
@@ -997,9 +999,8 def stream(repo, proto):
 def unbundle(repo, proto, heads):
     their_heads = decodelist(heads)
 
+    with proto.mayberedirectstdio() as output:
     try:
-        proto.redirect()
-
         exchange.check_heads(repo, their_heads, 'preparing changes')
 
         # write bundle data to temporary file because it can be big
@@ -1014,9 +1015,9 def unbundle(repo, proto, heads):
                 and not bundle1allowed(repo, 'push')):
                 if proto.name == 'http':
                     # need to special case http because stderr do not get to
-                    # the http client on failed push so we need to abuse some
-                    # other error type to make sure the message get to the
-                    # user.
+                        # the http client on failed push so we need to abuse
+                        # some other error type to make sure the message get to
+                        # the user.
                     return ooberror(bundle2required)
                 raise error.Abort(bundle2requiredmain,
                                   hint=bundle2requiredhint)
@@ -1024,10 +1025,10 def unbundle(repo, proto, heads):
             r = exchange.unbundle(repo, gen, their_heads, 'serve',
                                   proto._client())
             if util.safehasattr(r, 'addpart'):
-                # The return looks streamable, we are in the bundle2 case and
-                # should return a stream.
+                    # The return looks streamable, we are in the bundle2 case
+                    # and should return a stream.
                 return streamres_legacy(gen=r.getchunks())
-            return pushres(r)
+                return pushres(r, output.getvalue() if output else '')
 
         finally:
             fp.close()
@@ -1046,9 +1047,10 def unbundle(repo, proto, heads):
                 util.stderr.write("abort: %s\n" % exc)
                 if exc.hint is not None:
                     util.stderr.write("(%s)\n" % exc.hint)
-                return pushres(0)
+                    return pushres(0, output.getvalue() if output else '')
             except error.PushRaced:
-                return pusherr(str(exc))
+                    return pusherr(str(exc),
+                                   output.getvalue() if output else '')
 
         bundler = bundle2.bundle20(repo.ui)
         for out in getattr(exc, '_bundle2salvagedoutput', ()):
@@ -1066,7 +1068,8 def unbundle(repo, proto, heads):
                 part = bundler.newpart('error:pushkey')
                 part.addparam('in-reply-to', exc.partid)
                 if exc.namespace is not None:
-                    part.addparam('namespace', exc.namespace, mandatory=False)
+                        part.addparam('namespace', exc.namespace,
+                                      mandatory=False)
                 if exc.key is not None:
                     part.addparam('key', exc.key, mandatory=False)
                 if exc.new is not None:

mercurial/wireprotoserver.py

@@ -320,15 +320,13 def _callhttp(repo, req, proto, cmd):
         req.respond(HTTP_OK, mediatype)
         return gen
     elif isinstance(rsp, wireproto.pushres):
-        val = proto.restore()
-        rsp = '%d\n%s' % (rsp.res, val)
+        rsp = '%d\n%s' % (rsp.res, rsp.output)
         req.respond(HTTP_OK, HGTYPE, body=rsp)
         return []
     elif isinstance(rsp, wireproto.pusherr):
         # This is the httplib workaround documented in _handlehttperror().
         req.drain()
 
-        proto.restore()
         rsp = '0\n%s\n' % rsp.res
         req.respond(HTTP_OK, HGTYPE, body=rsp)
         return []