def handle_request(self, req):
for pattern, handler in self.routes[req.method]:
match, kwargs = self.path_matches(urllib2.unquote(req.path),
pattern)
if match:
yield Return((yield handler(req, **kwargs)))
if self.handler:
resp = yield self.handler(req)
yield Return(resp)
yield Return(404, {}, "")
def hello_http(req):
content = "Hello, World!"
headers = HttpHeaders()
headers.add('Content-Type', 'text/plain')
headers.add('Set-Cookie', 'test0=blar; Path=/')
headers.add('Set-Cookie', 'test1=blar; Path=/')
yield Return(200, headers, content)
def request(self, url, headers=None, method='GET', body=None):
parts = urlparse.urlsplit(url)
if self.is_proxy:
host = parts.netloc
path = url
else:
if parts.scheme and parts.scheme != self.scheme:
raise HttpException("URL is %s but connection is %s" %
(parts.scheme, self.scheme))
host = parts.netloc
if not host:
host = self.host
if self.port != self.DEFAULT_PORTS[self.scheme]:
host += ":%s" % self.port
path = parts.path
if parts.query:
path += '?' + parts.query
if not headers:
headers = HttpHeaders()
headers.setdefault('User-Agent', 'monocle/%s' % VERSION)
headers.setdefault('Host', host)
if body is not None:
headers['Content-Length'] = str(len(body))
yield write_request(self.client, method, path, headers, body)
response = yield read_response(self.client)
yield Return(response)
def handle_request(self, req):
before = time.time()
resp = None
handler, kwargs = self.route_match(req)
try:
if handler:
resp = yield self.request_handler_wrapper(
req, handler, **kwargs)
elif self.handler:
resp = yield self.request_handler_wrapper(req, self.handler)
else:
resp = (404, {}, "")
except Exception:
log_exception()
resp = (500, {}, "500 Internal Server Error")
after = time.time()
content_length = 0
if len(resp) > 2:
content_length = len(resp[2])
log.info("[%s] %s %s %s -> %s (%s bytes, %.0fms); %s", req.remote_ip,
req.method, req.path, req.proto, resp[0], content_length,
(after - before) * 1000, req.headers.get('user-agent'))
yield Return(resp)
def handle_request(self, req):
before = time.time()
resp = None
handler, kwargs = self.route_match(req)
if handler:
resp = yield self.request_handler_wrapper(req, handler, **kwargs)
if self.handler and not resp:
resp = yield self.request_handler_wrapper(req, self.handler)
if not resp:
resp = (404, {}, "")
after = time.time()
content_length = 0
if len(resp) > 2:
content_length = len(resp[2])
log.info("[%s] %s %s %s -> %s (%s bytes, %.0fms); %s",
req.remote_ip,
req.method, req.path, req.proto,
resp[0], content_length, (after - before) * 1000,
req.headers.get('user-agent'))
yield Return(resp)
def handler(self, conn):
data = 'Hello, World!'
headers = http.HttpHeaders()
headers.add('Content-Length', len(data))
headers.add('Content-Type', 'text/plain')
headers.add('Connection', 'close')
yield Return(200, headers, data)
def _handler(conn):
recv_body.append(conn.body_file.read())
data = 'Hello, World!'
headers = http.HttpHeaders()
headers.add('Content-Length', len(data))
headers.add('Content-Type', 'text/plain')
headers.add('Connection', 'close')
yield Return(200, headers, data)
def read_request(conn):
data = yield conn.read_until("\r\n\r\n")
method, path, proto, headers = parse_request(data)
body = None
if method in ["POST", "PUT"] and "Content-Length" in headers:
cl = int(headers["Content-Length"])
body = yield conn.read(cl)
yield Return(method, path, proto, headers, body)
def recv(self):
# if there's buffer, read it
if self._msgs:
value = self._msgs.popleft()
yield Return(value)
# otherwise we need a sender
rcb = Callback()
if self._send_cbs:
# if there are senders waiting, wake up the first one
cb = self._send_cbs.popleft()
cb(rcb)
else:
# otherwise, wait for a sender
self._recv_cbs.append(rcb)
value = yield rcb
yield Return(value)
def readRequest(input): version=yield input.read(1) command=yield input.read(1) reserved=yield input.read(1) addrtype=yield input.read(1) dest=yield input.read(6) yield Return(dest)
def test_side_effect():
mock = MonocleMock()
mock.side_effect = Exception('a side effect')
try:
yield mock()
except Exception as e:
assert 'a side effect' == str(e)
yield Return(None)
assert False, "expected exception"
def run_test(test, verbose=False):
if verbose:
sys.stdout.write(test.__module__ + "." + test.__name__ + " ... ")
sys.stdout.flush()
result = {'test': test}
captured_stdout = ""
captured_stderr = ""
try:
real_stdout = sys.stdout
real_stderr = sys.stderr
sys.stdout = StringIO()
sys.stderr = StringIO()
log = StringIO()
handlers = []
while root.handlers:
handlers.append(root.handlers[0])
root.removeHandler(root.handlers[0])
handler = logging.StreamHandler(log)
root.addHandler(handler)
try:
yield test()
finally:
captured_stdout = sys.stdout.getvalue()
captured_stderr = sys.stderr.getvalue()
captured_log = log.getvalue()
sys.stdout = real_stdout
sys.stderr = real_stderr
root.removeHandler(handler)
for h in handlers:
root.addHandler(h)
except Exception as e:
if isinstance(e, AssertionError):
if verbose:
print("FAIL")
else:
sys.stdout.write("F")
result['type'] = "FAIL"
else:
if verbose:
print("ERROR")
else:
sys.stdout.write("E")
result['type'] = "ERROR"
result['tb'] = traceback.format_exc()
else:
if verbose:
print("ok")
else:
sys.stdout.write(".")
result['type'] = "SUCCESS"
sys.stdout.flush()
result['stdout'] = captured_stdout
result['stderr'] = captured_stderr
result['log'] = captured_log
yield Return(result)
def handshake(conn):
ekeypair = createEphemeralKeypair()
epub = yield conn.read(KEY_SIZE)
esession = makeEphemeralSession(ekeypair, epub).bytes
print('esssion: ' + encode(esession))
coder = lite_socket(esession.bytes)
yield conn.write(ekeypair.public.bytes)
yield Return(coder)
def readRequest(conn):
""" readRequest reads the SOCKS request information from the client and returns the bytes represneting the IPv4 destination. """
version = (yield conn.read(1))
command = (yield conn.read(1))
reserved = (yield conn.read(1))
addrtype = (yield conn.read(1))
dest = (yield conn.read(6))
yield Return(dest)
def launch_proc_with_sockets(target, *args, **kwargs):
port = 7051 # FIXME -- shouldn't be hardcoded
p = launch_proc(_subproc_wrapper, port, target, *args, **kwargs)
cb = Callback()
get_chan_service = partial(get_conn, cb)
service = Service(get_chan_service, port, bindaddr="127.0.0.1", backlog=1)
service._add()
conn = yield cb
yield service.stop()
chan = SocketChannel(conn)
yield Return(p, chan)
def run_in_proc(target, *args, **kwargs):
@_o
def wrapper(chan):
r = yield target(*args, **kwargs)
yield chan.send(r)
eventloop.halt()
p, chan = yield launch_proc_with_sockets(wrapper)
r = yield chan.recv()
p.join()
yield Return(r)
def read_some(self):
self._check_reading()
if not self._stack_conn.buffer:
self._check_closed()
self._stack_conn.resume()
self._queue_timeout(self._stack_conn.read_cb)
yield self._stack_conn.read_cb
tmp = self._stack_conn.buffer
self._stack_conn.buffer = ""
yield Return(tmp)
def read(self, size):
self._check_reading()
while len(self._stack_conn.buffer) < size:
self._check_closed()
self._stack_conn.resume()
self._queue_timeout(self._stack_conn.read_cb)
yield self._stack_conn.read_cb
tmp = self._stack_conn.buffer[:size]
self._stack_conn.buffer = self._stack_conn.buffer[size:]
yield Return(tmp)
def pumpIn(
self,
input,
output,
callback,
):
logging.error('pumpIn yielding ' + str(input))
try:
data = yield input.read_some()
except ConnectionLost as e:
logging.error('pumpIn: Connection lost')
yield Return(False)
except IOError:
print 'IOError'
print_exc()
yield Return(False)
except Exception, e:
print 'Exception'
print e
yield Return(False)
def first_of(*a):
cb = Callback()
cb.called = False
for i, c in enumerate(a):
def cb(result, i=i):
if isinstance(result, Exception):
raise result
if not cb.called:
cb.called = True
cb((i, result))
c.add(cb)
x, r = yield cb
yield Return([(True, r) if x == i else None for i in range(len(a))])
def query(self, url, headers=None, method='GET', body=None):
_http_client = tornado.httpclient.AsyncHTTPClient()
req = tornado.httpclient.HTTPRequest(url,
method=method,
headers=headers or {},
body=body,
# XXX: TODO
#request_timeout=self.timeout
)
cb = Callback()
_http_client.fetch(req, cb)
response = yield cb
yield Return(response)
def launch_proc_with_sockets(target, port, *args, **kwargs):
args = [target, port] + list(args)
p = Process(target=_wrapper_with_sockets, args=args, kwargs=kwargs)
p.start()
cb = Callback()
get_chan_service = partial(get_conn, cb)
service = Service(get_chan_service, port, bindaddr="127.0.0.1", backlog=1)
service._add()
conn = yield cb
yield service.stop()
chan = SocketChannel(conn)
main_chan, log_chan = make_subchannels(chan, ['main', 'log'])
launch(log_receive, log_chan)
yield Return(p, main_chan)
def query(cls, url, headers=None, method='GET', body=None):
self = cls()
parts = urlparse.urlsplit(url)
host = parts.hostname
port = parts.port or self.DEFAULT_PORTS[parts.scheme]
if not self.client or self.client.is_closed():
yield self.connect(host, port, scheme=parts.scheme)
elif not (self.host, self.port) == (host, port):
self.client.close()
yield self.connect(host, port, scheme=parts.scheme)
result = yield self.request(url, headers, method, body)
self.close()
yield Return(result)
def read_until(self, s):
self._check_reading()
while True:
size = self._stack_conn.buffer.find(s)
if size != -1:
size += len(s)
break
self._check_closed()
self._stack_conn.resume()
self._queue_timeout(self._stack_conn.read_cb)
yield self._stack_conn.read_cb
tmp = self._stack_conn.buffer[:size]
self._stack_conn.buffer = self._stack_conn.buffer[size:]
yield Return(tmp)
def handle_request(self, req):
resp = None
handler, kwargs = self.route_match(req)
try:
if handler:
resp = yield self.request_handler_wrapper(
req, handler, **kwargs)
elif self.handler:
resp = yield self.request_handler_wrapper(req, self.handler)
else:
resp = (404, {}, "")
except Exception:
log_exception()
resp = (500, {}, "500 Internal Server Error")
yield Return(resp)
def request(self, url, headers=None, method='GET', body=None):
parts = urlparse.urlsplit(url)
scheme = parts.scheme or self.scheme
if parts.scheme and parts.scheme not in ['http', 'https']:
raise HttpException('unsupported url scheme %s' % parts.scheme)
host = parts.hostname or self.host
path = parts.path
if parts.query:
path += '?' + parts.query
if scheme != self.scheme:
raise HttpException("URL is %s but connection is %s" %
(scheme, self.scheme))
if not headers:
headers = HttpHeaders()
headers.setdefault('User-Agent', 'monocle/%s' % VERSION)
headers.setdefault('Host', host)
if body is not None:
headers['Content-Length'] = str(len(body))
yield write_request(self.client, method, path, headers, body)
response = yield read_response(self.client)
yield Return(response)
def read_response(conn):
data = yield conn.read_until("\r\n\r\n")
proto, code, msg, headers = parse_response(data)
proto = proto.lower()
content_length = int(headers.get('Content-Length', 0))
body = ""
# From rfc2616 section 4.4:
# Messages MUST NOT include both a Content-Length header field and
# a non-identity transfer-coding. If the message does include a
# non- identity transfer-coding, the Content-Length MUST be
# ignored.
if headers.get('Transfer-Encoding', '').lower() == 'chunked':
while True:
line = yield conn.read_until("\r\n")
line = line[:-2]
parts = line.split(';')
chunk_len = int(parts[0], 16)
body += yield conn.read(chunk_len)
yield conn.read_until("\r\n")
if not chunk_len:
break
elif content_length:
body = yield conn.read(content_length)
elif ((proto == 'http/1.0'
and not headers.get('Connection', '').lower() == 'keep-alive')
or (proto == 'http/1.1'
and headers.get('Connection', '').lower() == 'close')):
while True:
try:
body += yield conn.read_some()
except ConnectionLost:
break
yield Return(HttpResponse(code, msg, headers, body, proto))
def recv(self):
value = yield self.split_chan.recv(self.name)
yield Return(value)
def recv(self, subchan):
value = yield self.channels[subchan].recv()
yield Return(value['content'])
def recv(self):
l = yield self.conn.readline()
l = int(l)
p = yield self.conn.read(l)
value = pickle.loads(p)
yield Return(value)
