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)