def launch_proc_with_pipes(target, *args, **kwargs): log_child, log_parent = Pipe() child, parent = Pipe() args = [target, log_child, child] + list(args) p = Process(target=_wrapper_with_pipes, args=args, kwargs=kwargs) p.start() launch(log_receive, PipeChannel(log_parent)) return p, parent
def main(): ch = Channel() # Create a new channel. monocle.launch(generate, ch) # Start generate() as an o-routine. while True: prime = yield ch.recv() print prime ch1 = Channel() filter(ch, ch1, prime) ch = ch1
def handle_socksDust(conn): print('connection') client = Client() yield client.connect('blanu.net', 7051) coder=yield handshake(client) monocle.launch(pump, conn, client, coder.encrypt) yield pump(client, conn, coder.decrypt)
def handle_dust(conn): print('handle_dust') coder=yield handshake(conn) client = Client() yield client.connect('localhost', 9050) monocle.launch(pump, conn, client, coder.decrypt) yield pump(client, conn, coder.encrypt)
def run(self): """ Calls the start event on the transport and initiates pumping between upstream and downstream connections in both directions. """ self.transport.start() self.drain() monocle.launch(self.pumpUpstream) yield self.pumpDownstream()
def handle_dust(conn): print('handle_dust') coder=yield handshake(conn) buffer=FakeSocket() monocle.launch(pump, conn, buffer, coder.decrypt) monocle.launch(handle_socks, buffer.invert()) yield pump(buffer, conn, coder.encrypt, True) print('done handling dust')
def main(): """ The prime sieve: Daisy-chain filter processes together. """ ch = Channel() # Create a new channel. monocle.launch(generate, ch) # Start generate() as an o-routine. while True: prime = yield ch.recv() print(prime) ch1 = Channel() filter(ch, ch1, prime) ch = ch1
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 handle_socks(conn): print('connection') yield readHandshake(conn) yield sendHandshake(conn) dest=yield readRequest(conn) yield sendResponse(dest, conn) addr, port=uncompact(dest) print(addr) print(port) client = Client() yield client.connect(addr, port) monocle.launch(pump, conn, client) yield pump(client, conn)
def run(self): while self._running: timeout = 0 if self._queue: next = self._queue[-1][0] - time.time() if next <= 0: task = self._queue.pop() launch(task[1], *task[2], **task[3]) else: timeout = next if self._map: asyncore.loop(timeout=timeout, use_poll=True, count=1, map=self._map) else: time.sleep(0.1)
def _handler(tornado_request): try: headers = HttpHeaders() for k, v in tornado_request.headers.get_all(): headers.add(k, v) body_file = io.BytesIO(tornado_request.body) request = HttpRequest(proto=tornado_request.version, host=tornado_request.host, method=tornado_request.method, uri=tornado_request.uri, args=tornado_request.arguments, remote_ip=tornado_request.remote_ip, headers=headers, body=tornado_request.body, body_file=body_file) request._tornado_request = tornado_request value = yield launch(self.handle_request, request) code, headers, content = extract_response(value) except: code, headers, content = 500, {}, "500 Internal Server Error" tornado_request.write("HTTP/1.1 %s %s\r\n" % (code, responses.get(code, 'Unknown'))) headers.setdefault('Server', 'monocle/%s' % VERSION) headers.setdefault('Content-Length', str(len(content))) for name, value in headers.iteritems(): tornado_request.write("%s: %s\r\n" % (name, value)) tornado_request.write("\r\n") tornado_request.write(content) tornado_request.finish()
def _handler(request): try: code, headers, content = yield launch(self.handler, request) except Exception, e: print type(e), str(e) log.log_exception() code, headers, content = 500, {}, "500 Internal Server Error"
def first_evlp(): try: yield sleep(1) yield req() yield launch(second) finally: eventloop.halt()
def _handler(request): try: value = yield launch(self.handler, request) code, headers, content = extract_response(value) except Exception: log_exception() code, headers, content = 500, {}, "500 Internal Server Error" try: if request._disconnected: return request.setResponseCode(code) headers.setdefault('Server', 'monocle/%s' % VERSION) grouped_headers = {} for name, value in headers.iteritems(): if name in grouped_headers: grouped_headers[name].append(value) else: grouped_headers[name] = [value] for name, value in grouped_headers.iteritems(): request.responseHeaders.setRawHeaders(name, value) request.write(content) # close connections with a 'close' header if headers.get('Connection', '').lower() == 'close': request.channel.persistent = False request.finish() except Exception: log_exception() raise
def run(fn): ctx = {'exit_code': 0} @_o def _run_async(ctx): try: yield fn() except Exception: traceback.print_exc(file=sys.stdout) ctx['exit_code'] = 1 finally: eventloop.halt() launch(_run_async, ctx) eventloop.run() sys.exit(ctx['exit_code'])
def _handler(request): try: code, headers, content = yield launch(self.handler, request) except: code, headers, content = 500, {}, "500 Internal Server Error" request.setResponseCode(code) headers.setdefault('Server', 'monocle/%s' % VERSION) for name, value in headers.iteritems(): request.setHeader(name, value) request.write(content) request.finish()
def handle_socks(conn): print('handle_socks') yield readHandshake(conn) print('read handshake') yield sendHandshake(conn) print('send handshake') dest = yield readRequest(conn) print('read request: ' + str(dest)) yield sendResponse(dest, conn) print('sent response') addr, port = uncompact(dest) print(addr) print(port) client = Client() yield client.connect(addr, port) print('connected ' + str(addr) + ', ' + str(port)) monocle.launch(pump, conn, client, None) yield pump(client, conn, None)
def handle_socks(conn): print('handle_socks') yield readHandshake(conn) print('read handshake') yield sendHandshake(conn) print('send handshake') dest=yield readRequest(conn) print('read request: '+str(dest)) yield sendResponse(dest, conn) print('sent response') addr, port=uncompact(dest) print(addr) print(port) client = Client() yield client.connect(addr, port) print('connected '+str(addr)+', '+str(port)) monocle.launch(pump, conn, client, None) yield pump(client, conn, None)
def _handler(request): try: code, headers, content = yield launch(self.handler, request) except: code, headers, content = 500, {}, "500 Internal Server Error" request.write("HTTP/1.1 %s\r\n" % code) headers.setdefault('Server', 'monocle/%s' % VERSION) headers.setdefault('Content-Length', str(len(content))) for name, value in headers.iteritems(): request.write("%s: %s\r\n" % (name, value)) request.write("\r\n") request.write(content) request.finish()
def _handler(request): try: value = yield launch(self.handler, request) code, headers, content = extract_response(value) except: code, headers, content = 500, {}, "500 Internal Server Error" request.write("HTTP/1.1 %s\r\n" % code) headers.setdefault("Server", "monocle/%s" % VERSION) headers.setdefault("Content-Length", str(len(content))) for name, value in headers.iteritems(): request.write("%s: %s\r\n" % (name, value)) request.write("\r\n") request.write(content) request.finish()
def _handler(request): try: value = yield launch(self.handle_request, request) code, headers, content = extract_response(value) except: code, headers, content = 500, {}, "500 Internal Server Error" request.write("HTTP/1.1 %s %s\r\n" % (code, responses.get(code, 'Unknown'))) headers.setdefault('Server', 'monocle/%s' % VERSION) headers.setdefault('Content-Length', str(len(content))) for name, value in headers.iteritems(): request.write("%s: %s\r\n" % (name, value)) request.write("\r\n") request.write(content) request.finish()
def _handler(request): try: value = yield launch(self.handler, request) code, headers, content = extract_response(value) except Exception: log_exception() code, headers, content = 500, {}, "500 Internal Server Error" try: request.setResponseCode(code) headers.setdefault('Server', 'monocle/%s' % VERSION) for name, value in headers.iteritems(): request.setHeader(name, value) request.write(content) if not request._disconnected: # close connections with a 'close' header if headers.get('Connection', '').lower() == 'close': request.channel.persistent = False request.finish() except Exception: log_exception() raise
def main(): app = PyKitApp() launch(main_o, app) app.run_loop()
def main(): app = PyKitApp() env = {'__name__': '__console__', '__doc__': None} launch(repl, env) launch(demo_window, app) app.run_loop()
def handle_socks(conn): client = Client() yield client.connect('localhost', 8050) monocle.launch(pump, conn, client) yield pump(client, conn)
return fifth() @_o def third(): yield fourth() def second(): return third() @_o def first(): yield second() @_o def first_evlp(): try: yield sleep(1) yield req() yield launch(second) finally: eventloop.halt() launch(first) eventloop.queue_task(0, first_evlp) eventloop.run()
from __future__ import print_function import sys import monocle from monocle import _o monocle.init(sys.argv[1]) from monocle.stack import eventloop from monocle.experimental import Channel @_o def main(): s = 2 ch = Channel(s) for i in xrange(s): print(i) yield ch.send(i) print(ch.bufsize, len(ch._msgs)) for i in xrange(s): print((yield ch.recv())) print("done") monocle.launch(main) eventloop.run()
def proxy(conn): client = Client() yield client.connect(backend_host, backend_port) monocle.launch(make_pumper("client"), conn, client) pumper = make_pumper("server") yield pumper(client, conn)
def first_evlp(): yield sleep(1) yield req() yield launch(second) # won't crash
def example(): monocle.launch(print_every_second) monocle.launch(print_every_two_seconds)
import monocle from monocle import _o monocle.init(sys.argv[1]) from monocle.stack import eventloop from monocle.stack.network.http import HttpClient @_o def req(): client = HttpClient() try: yield client.connect("www.google.com", 80) resp = yield client.request('/') print resp.code, repr(resp.body) resp = yield client.request('http://www.google.com/') print resp.code, repr(resp.body) client.close() yield client.connect("localhost", 80) resp = yield client.request('/') print resp.code, repr(resp.body) resp = yield client.request('http://localhost/') print resp.code, repr(resp.body) finally: eventloop.halt() monocle.launch(req) eventloop.run()
import sys import monocle from monocle import _o monocle.init(sys.argv[1]) from monocle.stack import eventloop from monocle.util import sleep @_o def print_every_second(): for i in xrange(5): print "1" yield sleep(1) @_o def print_every_two_seconds(): for i in xrange(5): print "2" yield sleep(2) eventloop.halt() monocle.launch(print_every_second) monocle.launch(print_every_two_seconds) eventloop.run()
def main(args): parser = argparse.ArgumentParser(description="runs monocle tests") parser.add_argument('--verbose', '-v', action='store_true', default=False, help="verbose mode") parser.add_argument('stack', help="monocle stack to use") parser.add_argument('paths', nargs=argparse.REMAINDER, help="args for nosetests") args = parser.parse_args() monocle.init(args.stack) from monocle.stack import eventloop hook = rewrite.make_assertion_hook() sys.meta_path.insert(0, hook) class State(object): debug = False def trace(self, msg): if self.debug: print(msg) class Config(object): _assertstate = State() class Session(object): config = Config() def isinitpath(self, fn): return False hook.session = Session() paths = set() all_tests = [] test_files = [] for path in args.paths: if os.path.isfile(path): paths.add(os.path.dirname(path)) file = os.path.basename(path) all_tests.append(file[:-3]) test_files.append(path) elif os.path.isdir(path): for top, dirs, files in os.walk(path): for file in files: if file.endswith(".py"): paths.add(top) all_tests.append(file[:-3]) test_files.append(os.path.join(top, file)) else: print("Unknown file or directory", path) return sys.path.extend(paths) imported_tests = [] hook.fnpats = test_files for test in all_tests: try: m = __import__(test, globals(), locals()) if hasattr(m, "test"): imported_tests.extend(m.test.__globals__['_tests']) except Exception as e: print(test, str(e)) _tests.extend(set(imported_tests)) random.shuffle(_tests) monocle.launch(run, _tests, args.verbose) eventloop.run()
@monocle.o def invalid_yield(): yield "this should fail" @monocle.o def main(): value = yield square(5) print value try: yield fail() except Exception, e: print "Caught exception:", type(e), str(e) try: yield invalid_yield() except InvalidYieldException, e: print "Caught exception:", type(e), str(e) else: assert False def func_fail(): raise Exception("boo") monocle.launch(fail) monocle.launch(func_fail) monocle.launch(main)
all_tests.append(file[:-3]) test_files.append(os.path.join(top, file)) else: print "Unknown file or directory", path return sys.path.extend(paths) imported_tests = [] hook.fnpats = test_files for test in all_tests: try: m = __import__(test, globals(), locals()) if hasattr(m, "test"): imported_tests.extend(m.test.func_globals['_tests']) except Exception, e: print test, str(e) _tests.extend(set(imported_tests)) random.shuffle(_tests) monocle.launch(run, _tests, args.verbose) eventloop.run() if __name__ == '__main__': try: main(sys.argv[1:]) finally: sys.exit(_fail_count)
if not _c: continue # make the locals global so __g can reach them g_gs = dict(gs) g_gs.update(ls) eval(_c, g_gs, ls) # now monoclize it and get the callback _c = code.compile_command("monocle.o(__g)()", symbol="eval") cb = eval(_c, gs, ls) ls.pop('__g') #print "=== waiting for %s ===" % cb g_ls = yield cb if '__r' in g_ls: r = g_ls.pop('__r') if r: print r ls.update(g_ls) except Exception: traceback.print_exc() source = "" if __name__ == '__main__': monocle.init(sys.argv[1]) monocle.launch(repl, debug=False) eventloop.run()
def _handler(s): try: yield launch(handler, s) finally: s.close()
def handle_socksDust(conn, client): print('handle socks dust') coder=yield handshake(client) monocle.launch(pump, conn, client, coder.encrypt) yield pump(client, conn, coder.decrypt)
def example(): monocle.launch(fail) monocle.launch(func_fail) yield main()
from __future__ import print_function import sys import monocle from monocle import _o monocle.init(sys.argv[1]) from monocle.stack import eventloop from monocle.repl import repl @_o def main(): x = 7 print("about to drop into repl, x =", x) yield repl() print("returned from repl, x =", x) monocle.launch(main) eventloop.run()
def task(): return launch(callable, *args, **kw)
def main(): env = {'__name__': '__console__', '__doc__': None} launch(repl, env) launch(demo_window) yield monocle.util.sleep(2)
def handle_socksDust(conn, client): print('handle socks dust') coder = yield handshake(client) monocle.launch(pump, conn, client, coder.encrypt) yield pump(client, conn, coder.decrypt)
def __init__(self, chan, subchans): self.chan = chan self.channels = dict([(subchan, Channel(bufsize=float("inf"))) for subchan in subchans]) launch(self._receiver)
@_o def handle_echo(conn): while True: try: message = yield conn.read_until('\r\n') except ConnectionLost: break yield conn.write("you said: %s\r\n" % message.strip()) @_o def do_echos(): try: client = Client() yield client.connect('localhost', 8000) t = time.time() for x in xrange(10000): msg = "hello, world #%s!" % x yield client.write(msg + '\r\n') echo_result = yield client.read_until("\r\n") assert echo_result.strip() == "you said: %s" % msg print '10000 loops in %.2fs' % (time.time() - t) finally: client.close() eventloop.halt() add_service(Service(handle_echo, port=8000)) monocle.launch(do_echos) eventloop.run()