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 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(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 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(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.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)
def main():
app = PyKitApp()
env = {'__name__': '__console__', '__doc__': None}
launch(repl, env)
launch(demo_window, app)
app.run_loop()
def main():
env = {'__name__': '__console__', '__doc__': None}
launch(repl, env)
launch(demo_window)
yield monocle.util.sleep(2)
def main():
app = PyKitApp()
launch(main_o, app)
app.run_loop()
def _handler(s):
try:
yield launch(handler, s)
finally:
s.close()
@_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()
