def testSslRereadRequired(self):
con = http.HTTPConnection('1.2.3.4:443')
con._connect()
# extend the list instead of assign because of how
# MockSSLSocket works.
con.sock.data = [
'HTTP/1.1 200 OK\r\n', 'Server: BogusServer 1.0\r\n',
'MultiHeader: Value\r\n'
'MultiHeader: Other Value\r\n'
'MultiHeader: One More!\r\n'
'Content-Length: 10\r\n', '\r\n'
'1234567890'
]
con.request('GET', '/')
expected_req = ('GET / HTTP/1.1\r\n'
'Host: 1.2.3.4\r\n'
'accept-encoding: identity\r\n\r\n')
self.assertEqual(('1.2.3.4', 443), con.sock.sa)
self.assertEqual(expected_req, con.sock.sent)
resp = con.getresponse()
self.assertEqual('1234567890', resp.read())
self.assertEqual(['Value', 'Other Value', 'One More!'],
resp.headers.getheaders('multiheader'))
self.assertEqual(['BogusServer 1.0'],
resp.headers.getheaders('server'))
def test_multiline_header(self):
con = http.HTTPConnection('1.2.3.4:80')
con._connect()
con.sock.data = ['HTTP/1.1 200 OK\r\n',
'Server: BogusServer 1.0\r\n',
'Multiline: Value\r\n',
' Rest of value\r\n',
'Content-Length: 10\r\n',
'\r\n'
'1234567890'
]
con.request('GET', '/')
expected_req = ('GET / HTTP/1.1\r\n'
'Host: 1.2.3.4\r\n'
'accept-encoding: identity\r\n\r\n')
self.assertEqual(('1.2.3.4', 80), con.sock.sa)
self.assertEqual(expected_req, con.sock.sent)
resp = con.getresponse()
self.assertEqual('1234567890', resp.read())
self.assertEqual(['Value\n Rest of value'],
resp.headers.getheaders('multiline'))
# Socket should not be closed
self.assertEqual(resp.sock.closed, False)
self.assertEqual(con.sock.closed, False)
def testSimpleRequest(self):
con = http.HTTPConnection('1.2.3.4:80',
proxy_hostport=('magicproxy', 4242))
con._connect()
con.sock.data = [
'HTTP/1.1 200 OK\r\n', 'Server: BogusServer 1.0\r\n',
'MultiHeader: Value\r\n'
'MultiHeader: Other Value\r\n'
'MultiHeader: One More!\r\n'
'Content-Length: 10\r\n', '\r\n'
'1234567890'
]
con.request('GET', '/')
expected_req = ('GET http://1.2.3.4/ HTTP/1.1\r\n'
'Host: 1.2.3.4\r\n'
'accept-encoding: identity\r\n\r\n')
self.assertEqual(('127.0.0.42', 4242), con.sock.sa)
self.assertStringEqual(expected_req, con.sock.sent)
resp = con.getresponse()
self.assertEqual('1234567890', resp.read())
self.assertEqual(['Value', 'Other Value', 'One More!'],
resp.headers.getheaders('multiheader'))
self.assertEqual(['BogusServer 1.0'],
resp.headers.getheaders('server'))
def testSSLRequest(self):
con = http.HTTPConnection('1.2.3.4:443',
proxy_hostport=('magicproxy', 4242))
socket.socket = make_preloaded_socket([
'HTTP/1.1 200 OK\r\n', 'Server: BogusServer 1.0\r\n',
'Content-Length: 10\r\n', '\r\n'
'1234567890'
])
con._connect()
con.sock.data = [
'HTTP/1.1 200 OK\r\n', 'Server: BogusServer 1.0\r\n',
'Content-Length: 10\r\n', '\r\n'
'1234567890'
]
connect_sent = con.sock.sent
con.sock.sent = ''
con.request('GET', '/')
expected_connect = ('CONNECT 1.2.3.4:443 HTTP/1.0\r\n'
'Host: 1.2.3.4\r\n'
'accept-encoding: identity\r\n'
'\r\n')
expected_request = ('GET / HTTP/1.1\r\n'
'Host: 1.2.3.4\r\n'
'accept-encoding: identity\r\n\r\n')
self.assertEqual(('127.0.0.42', 4242), con.sock.sa)
self.assertStringEqual(expected_connect, connect_sent)
self.assertStringEqual(expected_request, con.sock.sent)
resp = con.getresponse()
self.assertEqual(resp.status, 200)
self.assertEqual('1234567890', resp.read())
self.assertEqual(['BogusServer 1.0'],
resp.headers.getheaders('server'))
def testChunkedUpload(self):
con = http.HTTPConnection('1.2.3.4:80')
con._connect()
sock = con.sock
sock.read_wait_sentinel = '0\r\n\r\n'
sock.data = ['HTTP/1.1 200 OK\r\n',
'Server: BogusServer 1.0\r\n',
'Content-Length: 6',
'\r\n\r\n',
"Thanks"]
zz = 'zz\n'
con.request('POST', '/', body=cStringIO.StringIO(
(zz * (0x8010 / 3)) + 'end-of-body'))
expected_req = ('POST / HTTP/1.1\r\n'
'transfer-encoding: chunked\r\n'
'Host: 1.2.3.4\r\n'
'accept-encoding: identity\r\n\r\n')
expected_req += chunkedblock('zz\n' * (0x8000 / 3) + 'zz')
expected_req += chunkedblock(
'\n' + 'zz\n' * ((0x1b - len('end-of-body')) / 3) + 'end-of-body')
expected_req += '0\r\n\r\n'
self.assertEqual(('1.2.3.4', 80), sock.sa)
self.assertStringEqual(expected_req, sock.sent)
self.assertEqual("Thanks", con.getresponse().read())
self.assertEqual(sock.closed, False)
def testDeniedAfterContinueTimeoutExpires(self):
con = http.HTTPConnection('1.2.3.4:80')
con._connect()
sock = con.sock
sock.data = ['HTTP/1.1 403 Forbidden\r\n',
'Server: BogusServer 1.0\r\n',
'Content-Length: 18\r\n',
'Connection: close',
'\r\n\r\n'
"You can't do that."]
sock.read_wait_sentinel = 'Dear server, send response!'
sock.close_on_empty = True
# send enough data out that we'll chunk it into multiple
# blocks and the socket will close before we can send the
# whole request.
post_body = ('This is some POST data\n' * 1024 * 32 +
'Dear server, send response!\n' +
'This is some POST data\n' * 1024 * 32)
expected_req = self.doPost(con, expect_body=False,
body_to_send=post_body)
self.assertEqual(('1.2.3.4', 80), sock.sa)
self.assert_('POST data\n' in sock.sent)
self.assert_('Dear server, send response!\n' in sock.sent)
# We expect not all of our data was sent.
self.assertNotEqual(sock.sent, expected_req)
self.assertEqual("You can't do that.", con.getresponse().read())
self.assertEqual(sock.closed, True)
def image_exists(domain, path, check_size=False, size_limit=1024):
'''
Make a HEAD request to the remote server to make sure the image
actually exists before downloading. Also, check the headers sent
back to check the image size
- http://stackoverflow.com/q/5616102/396300
'''
try:
conn = http.HTTPConnection(domain)
conn.request('HEAD', path)
response = conn.getresponse()
headers = response.getheaders()
conn.close()
except:
return False
try:
length = int([x[1] for x in headers if x[0] == 'content-length'][0])
except:
length = 0
if length > MAX_SIZE:
return False
return response.status == 200
def testSSLProxyFailure(self):
con = http.HTTPConnection('1.2.3.4:443',
proxy_hostport=('magicproxy', 4242))
socket.socket = make_preloaded_socket(
['HTTP/1.1 407 Proxy Authentication Required\r\n\r\n'])
self.assertRaises(http.HTTPProxyConnectFailedException, con._connect)
self.assertRaises(http.HTTPProxyConnectFailedException, con.request,
'GET', '/')
def _run_simple_test(self, host, server_data, expected_req, expected_data):
con = http.HTTPConnection(host)
con._connect()
con.sock.data = server_data
con.request('GET', '/')
self.assertEqual(expected_req, con.sock.sent)
self.assertEqual(expected_data, con.getresponse().read())
def init(self):
try:
hConn = httplib.HTTPConnection(self.ip_addr.data())
hConn.request("GET", "/bazaar?start=scope+gen")
hConn.getresponse()
except:
print('Cannot connect to ' + self.ip_addr.data())
raise mdsExceptions.TclFAILED_ESSENTIAL
trigSource = self.trig_source.data()
trigEdge = self.trig_edge.data()
fullScale1 = self.full_scale_1.data()
fullScale2 = self.full_scale_2.data()
sleep(1)
jsonStr = {'datasets': {'params': {'trig_mode': 1}}}
print(jsonStr)
try:
hConn.request("POST", "/data", json.dumps(jsonStr))
hConn.getresponse()
except:
print("Cannot load trig_mode")
raise mdsExceptions.TclFAILED_ESSENTIAL
jsonStr = {'datasets': {'params': {'trig_source': int(trigSource)}}}
print(jsonStr)
try:
hConn.request("POST", "/data", json.dumps(jsonStr))
hConn.getresponse()
except:
print("Cannot load trig_source")
raise mdsExceptions.TclFAILED_ESSENTIAL
jsonStr = {'datasets': {'params': {'trig_edge': int(trigEdge)}}}
try:
hConn.request("POST", "/data", json.dumps(jsonStr))
hConn.getresponse()
except:
print("Cannot load trig_edge")
raise mdsExceptions.TclFAILED_ESSENTIAL
jsonStr = {'datasets': {'params': {'gain_ch1': int(fullScale1)}}}
try:
hConn.request("POST", "/data", json.dumps(jsonStr))
hConn.getresponse()
except:
print("Cannot load gain_ch1")
raise mdsExceptions.TclFAILED_ESSENTIAL
jsonStr = {'datasets': {'params': {'gain_ch2': int(fullScale2)}}}
try:
hConn.request("POST", "/data", json.dumps(jsonStr))
hConn.getresponse()
except:
print("Cannot load gain_ch2")
raise mdsExceptions.TclFAILED_ESSENTIAL
return
def store(self):
try:
hConn = httplib.HTTPConnection(self.ip_addr.data())
except:
print('Cannot connect to ' + self.ip_addr.data())
raise mdsExceptions.TclFAILED_ESSENTIAL
try:
hConn.request("GET", "/data")
r = hConn.getresponse()
jans = json.load(r)
except:
print('Cannot get data')
raise mdsExceptions.TclFAILED_ESSENTIAL
chan1 = jans['datasets']['g1'][0]['data']
chan2 = jans['datasets']['g1'][1]['data']
x1 = []
y1 = []
x2 = []
y2 = []
for i in range(0, len(chan1)):
x1.append(chan1[i][0] * 1E-6)
y1.append(chan1[i][1])
x2.append(chan2[i][0] * 1E-6)
y2.append(chan2[i][1])
try:
triggerTime = self.trig_time.data()
except:
triggerTime = 0
try:
dim1 = Data.compile('$1 + $2', Float32Array(x1),
Float32(triggerTime))
data1 = Float32Array(y1)
sig1 = Data.compile('build_signal($1,,$2)', data1, dim1)
self.channel_1.putData(sig1)
except:
print('Cannot Save Channel 1')
raise mdsExceptions.TclFAILED_ESSENTIAL
try:
dim2 = Data.compile('$1 + $2', Float32Array(x1),
Float32(triggerTime))
data2 = Float32Array(y2)
sig2 = Data.compile('build_signal($1,,$2)', data2, dim2)
self.channel_2.putData(sig2)
except:
print('Cannot Save Channel 2')
raise mdsExceptions.TclFAILED_ESSENTIAL
return
def testChunkedDownloadPartialChunk(self):
con = http.HTTPConnection('1.2.3.4:80')
con._connect()
sock = con.sock
sock.data = ['HTTP/1.1 200 OK\r\n',
'Server: BogusServer 1.0\r\n',
'transfer-encoding: chunked',
'\r\n\r\n',
chunkedblock('hi '),
] + list(chunkedblock('there\n' * 5)) + [chunkedblock('')]
con.request('GET', '/')
self.assertStringEqual('hi there\nthere\nthere\nthere\nthere\n',
con.getresponse().read())
def trigger(self):
try:
hConn = httplib.HTTPConnection(self.ip_addr.data())
except:
print('Cannot connect to ' + self.ip_addr.data())
raise mdsExceptions.TclFAILED_ESSENTIAL
jsonStr = {'datasets': {'params': {'single_btn': 1}}}
try:
hConn.request("POST", "/data", json.dumps(jsonStr))
hConn.getresponse()
except:
print("Cannot trigger device")
raise mdsExceptions.TclFAILED_ESSENTIAL
return
def testTimeout(self):
con = http.HTTPConnection('1.2.3.4:80')
con._connect()
con.sock.data = []
con.request('GET', '/')
self.assertRaises(http.HTTPTimeoutException,
con.getresponse)
expected_req = ('GET / HTTP/1.1\r\n'
'Host: 1.2.3.4\r\n'
'accept-encoding: identity\r\n\r\n')
self.assertEqual(('1.2.3.4', 80), con.sock.sa)
self.assertEqual(expected_req, con.sock.sent)
def testChunkedDownloadBadEOL(self):
con = http.HTTPConnection('1.2.3.4:80')
con._connect()
sock = con.sock
sock.data = ['HTTP/1.1 200 OK\n',
'Server: BogusServer 1.0\n',
'transfer-encoding: chunked',
'\n\n',
chunkedblock('hi ', eol='\n'),
chunkedblock('there', eol='\n'),
chunkedblock('', eol='\n'),
]
con.request('GET', '/')
self.assertStringEqual('hi there', con.getresponse().read())
def test_server_closes_before_end_of_body(self):
con = http.HTTPConnection('1.2.3.4:80')
con._connect()
s = con.sock
s.data = ['HTTP/1.1 200 OK\r\n',
'Server: BogusServer 1.0\r\n',
'Connection: Keep-Alive\r\n',
'Content-Length: 16',
'\r\n\r\n',
'You can '] # Note: this is shorter than content-length
s.close_on_empty = True
con.request('GET', '/')
r1 = con.getresponse()
self.assertRaises(http.HTTPRemoteClosedError, r1.read)
def testEarlyContinueResponse(self):
con = http.HTTPConnection('1.2.3.4:80')
con._connect()
sock = con.sock
sock.data = ['HTTP/1.1 403 Forbidden\r\n',
'Server: BogusServer 1.0\r\n',
'Content-Length: 18',
'\r\n\r\n'
"You can't do that."]
expected_req = self.doPost(con, expect_body=False)
self.assertEqual(('1.2.3.4', 80), sock.sa)
self.assertStringEqual(expected_req, sock.sent)
self.assertEqual("You can't do that.", con.getresponse().read())
self.assertEqual(sock.closed, True)
def testChunkedDownloadEarlyHangup(self):
con = http.HTTPConnection('1.2.3.4:80')
con._connect()
sock = con.sock
broken = chunkedblock('hi'*20)[:-1]
sock.data = ['HTTP/1.1 200 OK\r\n',
'Server: BogusServer 1.0\r\n',
'transfer-encoding: chunked',
'\r\n\r\n',
broken,
]
sock.close_on_empty = True
con.request('GET', '/')
resp = con.getresponse()
self.assertRaises(http.HTTPRemoteClosedError, resp.read)
def testServerWithoutContinue(self):
con = http.HTTPConnection('1.2.3.4:80')
con._connect()
sock = con.sock
sock.read_wait_sentinel = 'POST data'
sock.data = ['HTTP/1.1 200 OK\r\n',
'Server: BogusServer 1.0\r\n',
'Content-Length: 16',
'\r\n\r\n',
"You can do that."]
expected_req = self.doPost(con, expect_body=True)
self.assertEqual(('1.2.3.4', 80), sock.sa)
self.assertEqual(expected_req, sock.sent)
self.assertEqual("You can do that.", con.getresponse().read())
self.assertEqual(sock.closed, False)
def install(self, tmpl_name): # pragma: no cover
try:
self.old_cwd = os.getcwd()
self.directory = tempfile.mkdtemp()
self.make_venv(self.directory)
os.chdir(pkg_resources.get_distribution('pyramid').location)
subprocess.check_call([
os.path.join(self.directory, 'bin', 'python'), 'setup.py',
'develop'
])
os.chdir(self.directory)
subprocess.check_call(
['bin/paster', 'create', '-t', tmpl_name, 'Dingle'])
os.chdir('Dingle')
py = os.path.join(self.directory, 'bin', 'python')
subprocess.check_call([py, 'setup.py', 'install'])
subprocess.check_call([py, 'setup.py', 'test'])
paster = os.path.join(self.directory, 'bin', 'paster')
for ininame, hastoolbar in (('development.ini', True),
('production.ini', False)):
proc = subprocess.Popen([paster, 'serve', ininame])
try:
time.sleep(5)
proc.poll()
if proc.returncode is not None:
raise RuntimeError('%s didnt start' % ininame)
conn = httplib.HTTPConnection('localhost:6543')
conn.request('GET', '/')
resp = conn.getresponse()
assert resp.status == 200, ininame
data = resp.read()
toolbarchunk = '<div id="pDebug"'
if hastoolbar:
assert toolbarchunk in data, ininame
else:
assert not toolbarchunk in data, ininame
finally:
if hasattr(proc, 'terminate'):
# 2.6+
proc.terminate()
else:
# 2.5
os.kill(proc.pid, signal.SIGTERM)
finally:
shutil.rmtree(self.directory)
os.chdir(self.old_cwd)
def testSlowConnection(self):
con = http.HTTPConnection('1.2.3.4:80')
con._connect()
# simulate one byte arriving at a time, to check for various
# corner cases
con.sock.data = list('HTTP/1.1 200 OK\r\n'
'Server: BogusServer 1.0\r\n'
'Content-Length: 10'
'\r\n\r\n'
'1234567890')
con.request('GET', '/')
expected_req = ('GET / HTTP/1.1\r\n'
'Host: 1.2.3.4\r\n'
'accept-encoding: identity\r\n\r\n')
self.assertEqual(('1.2.3.4', 80), con.sock.sa)
self.assertEqual(expected_req, con.sock.sent)
self.assertEqual('1234567890', con.getresponse().read())
def testHeaderlessResponse(self):
con = http.HTTPConnection('1.2.3.4', use_ssl=False)
con._connect()
con.sock.data = ['HTTP/1.1 200 OK\r\n',
'\r\n'
'1234567890'
]
con.request('GET', '/')
expected_req = ('GET / HTTP/1.1\r\n'
'Host: 1.2.3.4\r\n'
'accept-encoding: identity\r\n\r\n')
self.assertEqual(('1.2.3.4', 80), con.sock.sa)
self.assertEqual(expected_req, con.sock.sent)
resp = con.getresponse()
self.assertEqual('1234567890', resp.read())
self.assertEqual({}, dict(resp.headers))
self.assertEqual(resp.status, 200)
def test_no_keepalive_http_1_0(self):
expected_request_one = """GET /remote/.hg/requires HTTP/1.1
Host: localhost:9999
range: bytes=0-
accept-encoding: identity
accept: application/mercurial-0.1
user-agent: mercurial/proto-1.0
""".replace('\n', '\r\n')
expected_response_headers = """HTTP/1.0 200 OK
Server: SimpleHTTP/0.6 Python/2.6.1
Date: Sun, 01 May 2011 13:56:57 GMT
Content-type: application/octet-stream
Content-Length: 33
Last-Modified: Sun, 01 May 2011 13:56:56 GMT
""".replace('\n', '\r\n')
expected_response_body = """revlogv1
store
fncache
dotencode
"""
con = http.HTTPConnection('localhost:9999')
con._connect()
con.sock.data = [expected_response_headers, expected_response_body]
con.request('GET', '/remote/.hg/requires',
headers={'accept-encoding': 'identity',
'range': 'bytes=0-',
'accept': 'application/mercurial-0.1',
'user-agent': 'mercurial/proto-1.0',
})
self.assertStringEqual(expected_request_one, con.sock.sent)
self.assertEqual(con.sock.closed, False)
self.assertNotEqual(con.sock.data, [])
self.assert_(con.busy())
resp = con.getresponse()
self.assertStringEqual(resp.read(), expected_response_body)
self.failIf(con.busy())
self.assertEqual(con.sock, None)
self.assertEqual(resp.sock.data, [])
self.assert_(resp.sock.closed)
def testSslRereadInEarlyResponse(self):
con = http.HTTPConnection('1.2.3.4:443')
con._connect()
con.sock.early_data = [
'HTTP/1.1 200 OK\r\n', 'Server: BogusServer 1.0\r\n',
'MultiHeader: Value\r\n'
'MultiHeader: Other Value\r\n'
'MultiHeader: One More!\r\n'
'Content-Length: 10\r\n', '\r\n'
'1234567890'
]
expected_req = self.doPost(con, False)
self.assertEqual(None, con.sock,
'Connection should have disowned socket')
resp = con.getresponse()
self.assertEqual(('1.2.3.4', 443), resp.sock.sa)
self.assertEqual(expected_req, resp.sock.sent)
self.assertEqual('1234567890', resp.read())
self.assertEqual(['Value', 'Other Value', 'One More!'],
resp.headers.getheaders('multiheader'))
self.assertEqual(['BogusServer 1.0'],
resp.headers.getheaders('server'))
def test_conn_keep_alive_but_server_close_anyway(self):
sockets = []
def closingsocket(*args, **kwargs):
s = util.MockSocket(*args, **kwargs)
sockets.append(s)
s.data = ['HTTP/1.1 200 OK\r\n',
'Server: BogusServer 1.0\r\n',
'Connection: Keep-Alive\r\n',
'Content-Length: 16',
'\r\n\r\n',
'You can do that.']
s.close_on_empty = True
return s
socket.socket = closingsocket
con = http.HTTPConnection('1.2.3.4:80')
con._connect()
con.request('GET', '/')
r1 = con.getresponse()
r1.read()
self.assertFalse(con.sock.closed)
self.assert_(con.sock.remote_closed)
con.request('GET', '/')
self.assertEqual(2, len(sockets))
def testReadline(self):
con = http.HTTPConnection('1.2.3.4')
con._connect()
# make sure it trickles in one byte at a time
# so that we touch all the cases in readline
con.sock.data = list(''.join(
['HTTP/1.1 200 OK\r\n',
'Server: BogusServer 1.0\r\n',
'Connection: Close\r\n',
'\r\n'
'1\n2\nabcdefg\n4\n5']))
expected_req = ('GET / HTTP/1.1\r\n'
'Host: 1.2.3.4\r\n'
'accept-encoding: identity\r\n\r\n')
con.request('GET', '/')
self.assertEqual(('1.2.3.4', 80), con.sock.sa)
self.assertEqual(expected_req, con.sock.sent)
r = con.getresponse()
for expected in ['1\n', '2\n', 'abcdefg\n', '4\n', '5']:
actual = r.readline()
self.assertEqual(expected, actual,
'Expected %r, got %r' % (expected, actual))
def test_broken_data_obj(self):
con = http.HTTPConnection('1.2.3.4:80')
con._connect()
self.assertRaises(http.BadRequestData,
con.request, 'POST', '/', body=1)
parser.add_option("-p",
"--port",
dest="port",
metavar="PORT",
default=80,
type="int",
help="Port to connect to")
(opts, args) = parser.parse_args()
if len(args) < 1:
parser.error("Hostname is required")
host = args[0]
if len(sys.argv) < 3:
sys.exit("Usage " + sys.argv[0] + "<hostname> <port> /n")
host = sys.argv[1]
port = sys.argv[2]
client = http.HTTPConnection(host, port)
client.request("GET", "/")
resp = client.getresponse()
client.close()
if resp.status == 200:
print(host + " : OK")
sys.exit
print(host + ": DOWN (" + resp.status + " . " + resp.reason + ")")
def test_no_response_raises_response_not_ready(self):
con = http.HTTPConnection('foo')
self.assertRaises(http.httplib.ResponseNotReady, con.getresponse)
