def launchServer(self, name, port):
if not name in self.supportedTransports:
raise TransportLaunchException('Tried to launch unsupported transport %s'
% name)
serverClass = self.supportedTransports[name]
self.handler.setTransport(serverClass)
add_service(Service(self.handler.handle, port=port))
def test_lots_of_messages():
add_service(Service(handle_echo, port=8000))
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()
@_o
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)
@_o
def handshake(conn):
ekeypair = createEphemeralKeypair()
yield conn.write(ekeypair.public.bytes)
epub = yield conn.read(KEY_SIZE)
esession = makeEphemeralSession(ekeypair, epub)
coder = lite_socket(esession)
yield Return(coder)
add_service(Service(handle_socksDust, port=7050))
eventloop.run()
import sys
import monocle
from monocle import _o
monocle.init(sys.argv[1])
from monocle.stack import eventloop
from monocle.stack.network import add_service, Service
@_o
def lower_one(conn):
raise Exception("testing")
yield
@_o
def top_one(conn):
yield lower_one(conn)
add_service(Service(top_one, 12345))
eventloop.run()
import sys
import monocle
from monocle import _o
monocle.init(sys.argv[1])
from monocle.stack import eventloop
from monocle.stack.network import add_service, Service
@_o
def echo(conn):
their_message = yield conn.readline()
yield conn.write("you said: %s\r\n" % their_message.strip())
add_service(Service(echo, 7050))
eventloop.run()
from socks import *
@_o
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)
@_o
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)
add_service(Service(handle_dust, port=7051))
eventloop.run()
@_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()
add_service(Service(handle_echo, port=8000))
run(do_echos)
import time
import monocle
from monocle import _o
monocle.init("tornado")
from monocle.stack import eventloop
from monocle.stack.network import add_service, Service, Client, ConnectionLost
@_o
def pump(input, output):
while True:
try:
message = yield input.read_some()
yield output.write(message)
except ConnectionLost:
output.close()
break
@_o
def handle_socks(conn):
client = Client()
yield client.connect('localhost', 8088)
monocle.launch(pump, conn, client)
yield pump(client, conn)
add_service(Service(handle_socks, port=8888))
eventloop.run()
@_o
def handle_echo(conn):
while True:
try:
message = yield conn.read_until('\r\n')
message = message.decode().strip()
except ConnectionLost:
break
yield conn.write("you said: %s\r\n" % message)
@_o
def do_echos():
client = Client()
try:
yield client.connect('localhost', 8000)
t = time.time()
for x in range(10000):
msg = "hello, world #%s!" % x
yield client.write(msg + '\r\n')
echo_result = yield client.read_until('\r\n')
assert echo_result.decode().strip() == "you said: %s" % msg
print('10000 loops in %.2fs' % (time.time() - t))
finally:
client.close()
add_service(Service(handle_echo, port=8000, bindaddr="localhost"))
run(do_echos)
