def setUp(self):
self.conns = [None] * 2
self.server = None
self.loop = get_loop()
def serve(reader, writer):
self.conns[1] = Connection(self.loop, reader, writer)
@asyncio.coroutine
def connect():
host, port = '127.0.0.10', 5000
# let a server listen
self.server = (yield from asyncio.start_server(serve, host, port, loop=self.loop))
# connect a client
reader, writer = yield from asyncio.open_connection(host, port, loop=self.loop)
self.conns[0] = Connection(self.loop, reader, writer)
def close():
if self.server:
self.server.close()
for conn in self.conns:
if conn:
run_coroutine_threadsafe(conn.close(), loop=self.loop).result()
self.addCleanup(close)
run_coroutine_threadsafe(connect(), loop=self.loop).result()
def test_sendfile(self):
sendsock, recvsock = socket.socketpair()
src = tempfile.NamedTemporaryFile(prefix='bndl-sendfiletest-')
src.file.write(self.data)
received = []
def receive():
while sum(len(buffer) for buffer in received) < len(self.data):
buffer = recvsock.recv(len(self.data))
received.append(buffer)
receiver = threading.Thread(target=receive)
receiver.start()
loop = get_loop()
run_coroutine_threadsafe(sendfile(sendsock.fileno(),
src.file.fileno(),
0,
len(self.data),
loop=loop),
loop=loop).result()
receiver.join()
received = b''.join(received)
self.assertEqual(self.data, received)
def __init__(self,
name=None,
addresses=None,
seeds=None,
cluster='default',
loop=None):
self.loop = loop or get_loop()
self.node_type = camel_to_snake(self.__class__.__name__)
if name:
self.name = name
else:
self.name = '.'.join(reversed(socket.getfqdn().split('.'))) + \
'.' + self.node_type + \
'.' + str(os.getpid())
node_ids = Node._nodeids.setdefault(self.node_type,
itertools.count())
node_id = next(node_ids)
if node_id:
self.name += '.' + str(node_id)
self.servers = {address: None for address in (addresses or ())}
self.seeds = seeds or ()
self.peers = PeerTable()
self.cluster = cluster
self._peer_table_lock = asyncio.Lock(loop=self.loop)
self._watchdog = None
self._iotasks = set()
atexit.register(self._stop_tasks)
def setUp(self):
self.loop = get_loop()
self.loop.set_debug(True)
if not self.seeds:
self.seeds = [
self.address + ':' + str(port)
for port in range(5000, min(5000 + self.node_count, 5004))
]
self.nodes = self.create_nodes()
for i, node in enumerate(self.nodes):
self.run_coro(node.start())
if self.ease_discovery:
self.run_coro(wait_for_discovery(node, i)).result()
for node in self.nodes:
self.run_coro(wait_for_discovery(node,
self.node_count - 1)).result()
def __init__(self,
module,
main,
args,
process_count=None,
numactl=None,
pincore=None,
jemalloc=None,
min_run_time=MIN_RUN_TIME,
check_interval=CHECK_INTERVAL):
self.id = next(Supervisor._ids)
self.module = module
self.main = main
self.args = args
self.process_count = process_count
if numactl is None:
numactl = bndl.conf['bndl.run.numactl']
if pincore is None:
pincore = bndl.conf['bndl.run.pincore']
if jemalloc is None:
jemalloc = bndl.conf['bndl.run.jemalloc']
self.numactl = numactl
self.pincore = pincore
self.jemalloc = jemalloc
self.children = []
self.min_run_time = min_run_time
self.check_interval = check_interval
self._watcher = threading.Thread(target=self._watch,
daemon=True,
name='bndl-supervisor-%s' % self.id)
self.rmi = RMINode(name='supervisor.%s' % self.id,
addresses=['127.0.0.1:0'],
cluster=None,
loop=get_loop())
self.rmi.start_async().result()
atexit.register(self.stop)
def test_copyfile(self):
src = tempfile.NamedTemporaryFile(prefix='bndl-sendfiletest-')
src.file.write(self.data)
src.file.seek(0)
size = os.stat(src.fileno()).st_size
dst = tempfile.NamedTemporaryFile(prefix='bndl-sendfiletest-')
loop = get_loop()
run_coroutine_threadsafe(sendfile(dst.file.fileno(),
src.file.fileno(),
0,
size,
loop=loop),
loop=loop).result()
self.assertEqual(size, os.stat(dst.fileno()).st_size)
src.file.seek(0)
dst.file.seek(0)
self.assertEqual(src.file.read(), dst.file.read())
src.close()
dst.close()
def setUp(self):
self.loop = get_loop()