mirror of
https://github.com/facebook/sapling.git
synced 2024-10-07 07:17:55 +03:00
f71c86b7e9
With this commit, the HTTP transport now parses the X-HgProto-<N> header to determine what media type and compression engine to use for responses. So far, we only compress responses that are already being compressed with zlib today (stream response types to specific commands). We can expand things to cover additional response types later. The practical side-effect of this commit is that non-zlib compression engines will be used if both ends support them. This means if both ends have zstd support, zstd - not zlib - will be used to compress data! When cloning the mozilla-unified repository between a local HTTP server and client, the benefits of non-zlib compression are quite noticeable: engine server CPU (s) client CPU (s) bundle size zlib (l=6) 174.1 283.2 1,148,547,026 zstd (l=1) 99.2 267.3 1,127,513,841 zstd (l=3) 103.1 266.9 1,018,861,363 zstd (l=7) 128.3 269.7 919,190,278 zstd (l=10) 162.0 - 894,547,179 none 95.3 277.2 4,097,566,064 The default zstd compression level is 3. So if you deploy zstd capable Mercurial to your clients and servers and CPU time on your server is dominated by "getbundle" requests (clients cloning and pulling) - and my experience at Mozilla tells me this is often the case - this commit could drastically reduce your server-side CPU usage *and* save on bandwidth costs! Another benefit of this change is that server operators can install *any* compression engine. While it isn't enabled by default, the "none" compression engine can now be used to disable wire protocol compression completely. Previously, commands like "getbundle" always zlib compressed output, adding considerable overhead to generating responses. If you are on a high speed network and your server is under high load, it might be advantageous to trade bandwidth for CPU. Although, zstd at level 1 doesn't use that much CPU, so I'm not convinced that disabling compression wholesale is worthwhile. And, my data seems to indicate a slow down on the client without compression. I suspect this is due to a lack of buffering resulting in an increase in socket read() calls and/or the fact we're transferring an extra 3 GB of data (parsing HTTP chunked transfer and processing extra TCP packets can add up). This is definitely worth investigating and optimizing. But since the "none" compressor isn't enabled by default, I'm inclined to punt on this issue. This commit introduces tons of tests. Some of these should arguably have been implemented on previous commits. But it was difficult to test without the server functionality in place.
93 lines
2.4 KiB
Python
Executable File
93 lines
2.4 KiB
Python
Executable File
#!/usr/bin/env python
|
|
|
|
"""This does HTTP GET requests given a host:port and path and returns
|
|
a subset of the headers plus the body of the result."""
|
|
|
|
from __future__ import absolute_import, print_function
|
|
|
|
import json
|
|
import os
|
|
import sys
|
|
|
|
from mercurial import (
|
|
util,
|
|
)
|
|
|
|
httplib = util.httplib
|
|
|
|
try:
|
|
import msvcrt
|
|
msvcrt.setmode(sys.stdout.fileno(), os.O_BINARY)
|
|
msvcrt.setmode(sys.stderr.fileno(), os.O_BINARY)
|
|
except ImportError:
|
|
pass
|
|
|
|
twice = False
|
|
if '--twice' in sys.argv:
|
|
sys.argv.remove('--twice')
|
|
twice = True
|
|
headeronly = False
|
|
if '--headeronly' in sys.argv:
|
|
sys.argv.remove('--headeronly')
|
|
headeronly = True
|
|
formatjson = False
|
|
if '--json' in sys.argv:
|
|
sys.argv.remove('--json')
|
|
formatjson = True
|
|
|
|
hgproto = None
|
|
if '--hgproto' in sys.argv:
|
|
idx = sys.argv.index('--hgproto')
|
|
hgproto = sys.argv[idx + 1]
|
|
sys.argv.pop(idx)
|
|
sys.argv.pop(idx)
|
|
|
|
tag = None
|
|
def request(host, path, show):
|
|
assert not path.startswith('/'), path
|
|
global tag
|
|
headers = {}
|
|
if tag:
|
|
headers['If-None-Match'] = tag
|
|
if hgproto:
|
|
headers['X-HgProto-1'] = hgproto
|
|
|
|
conn = httplib.HTTPConnection(host)
|
|
conn.request("GET", '/' + path, None, headers)
|
|
response = conn.getresponse()
|
|
print(response.status, response.reason)
|
|
if show[:1] == ['-']:
|
|
show = sorted(h for h, v in response.getheaders()
|
|
if h.lower() not in show)
|
|
for h in [h.lower() for h in show]:
|
|
if response.getheader(h, None) is not None:
|
|
print("%s: %s" % (h, response.getheader(h)))
|
|
if not headeronly:
|
|
print()
|
|
data = response.read()
|
|
|
|
# Pretty print JSON. This also has the beneficial side-effect
|
|
# of verifying emitted JSON is well-formed.
|
|
if formatjson:
|
|
# json.dumps() will print trailing newlines. Eliminate them
|
|
# to make tests easier to write.
|
|
data = json.loads(data)
|
|
lines = json.dumps(data, sort_keys=True, indent=2).splitlines()
|
|
for line in lines:
|
|
print(line.rstrip())
|
|
else:
|
|
sys.stdout.write(data)
|
|
|
|
if twice and response.getheader('ETag', None):
|
|
tag = response.getheader('ETag')
|
|
|
|
return response.status
|
|
|
|
status = request(sys.argv[1], sys.argv[2], sys.argv[3:])
|
|
if twice:
|
|
status = request(sys.argv[1], sys.argv[2], sys.argv[3:])
|
|
|
|
if 200 <= status <= 305:
|
|
sys.exit(0)
|
|
sys.exit(1)
|