def test_blocking_server_finite_client_timeout(self):
sck = socket(AF_INET, SOCK_STREAM)
sck.setsockopt(SOL_SOCKET, SO_REUSEADDR, 1)
sck.bind(('127.0.0.1', TESTING_PORT))
sck.listen(10)
sck = ServerSocket(sck)
class ClientSocketThread(Thread):
def __init__(self, utc):
"""@param utc: unit test class"""
Thread.__init__(self)
self.utc = utc
def run(self):
sck = socket(AF_INET, SOCK_STREAM)
sck.connect(('127.0.0.1', TESTING_PORT))
sck = Socket(sck)
sck.settimeout(5)
self.utc.assertEquals(sck.read(2), 'Ye')
self.utc.assertEquals(sck.read(1), 's')
sck.write('Hello World')
sck.close()
cs = ClientSocketThread(self)
cs.start()
csk = sck.read()
sleep(3)
csk.write('Yes')
self.assertEquals(csk.read(5), 'Hello')
self.assertEquals(csk.read(6), ' World')
csk.close()
cs.join()
sck.close()
def test_blocking_server(self):
"""tests L{ServerSocket} and a client L{Socket} in a multithreaded model"""
sck = socket(AF_INET, SOCK_STREAM)
sck.setsockopt(SOL_SOCKET, SO_REUSEADDR, 1)
sck.bind(('127.0.0.1', TESTING_PORT))
sck.listen(10)
sck = ServerSocket(sck)
class ClientSocketThread(Thread):
def __init__(self, utc):
Thread.__init__(self)
self.utc = utc
def run(self):
"""@param utc: unit test class"""
sleep(0.1)
sck = socket(AF_INET, SOCK_STREAM)
sck.connect(('127.0.0.1', TESTING_PORT))
sck = Socket(sck)
sck.write('Hello World')
self.pkdata = sck.read(3, less=False, peek=True)
self.data = sck.read(3)
self.utc.assertRaises(ChannelClosed, sck.read, 1)
sck.close()
cs = ClientSocketThread(self)
cs.start()
csk = sck.read()
self.assertEquals(csk.read(6), 'Hello ')
self.assertEquals(csk.read(5), 'World')
csk.write('Yes')
csk.close()
cs.join()
self.assertEquals(cs.pkdata, 'Yes')
self.assertEquals(cs.data, 'Yes')
sck.close()
def test_blocking_server_client_with_less(self):
"""tests less=True mechanism for channels in sockets"""
sck = socket(AF_INET, SOCK_STREAM)
sck.setsockopt(SOL_SOCKET, SO_REUSEADDR, 1)
sck.bind(('127.0.0.1', TESTING_PORT))
sck.listen(10)
sck = ServerSocket(sck)
class ClientSocketThread(Thread):
def __init__(self, utc):
Thread.__init__(self)
self.utc = utc
def run(self):
"""@param utc: unit test class"""
sleep(0.1)
sck = socket(AF_INET, SOCK_STREAM)
sck.connect(('127.0.0.1', TESTING_PORT))
sck = Socket(sck)
self.utc.assertEquals(sck.blocking, True)
self.utc.assertEquals(sck.read(1), 'L')
pkdata = sck.read(100, less=True, peek=True)
data = sck.read(100, less=True)
self.utc.assertEquals(pkdata, 'ong string? Not enough.')
self.utc.assertEquals(data, 'ong string? Not enough.')
self.utc.assertRaises(ChannelClosed, sck.read, 1)
sck.close()
cs = ClientSocketThread(self)
cs.start()
csk = sck.read()
csk.write('Long string? Not enough.')
csk.close()
cs.join()
sck.close()
def setUp(self):
# initialize cshardmgr test socket
ss = socket(AF_INET, SOCK_STREAM)
ss.setsockopt(SOL_SOCKET, SO_REUSEADDR, 1)
ss.bind(('127.0.0.1', TESTING_PORT))
ss.listen(10)
ss = ServerSocket(ss)
sl = SelectLayer([ss], CounterCollection('dontcare'))
class SelectLayerThread(BaseThread):
def __init__(self, sl):
BaseThread.__init__(self)
self.sl = sl
def run(self):
while not self._terminating:
self.sl.select()
for channel in self.sl.channels:
self.sl.close_channel(channel)
self.slt = SelectLayerThread(sl).start()
))
# ===================================================== queue workers
omm = OpportunisticMatchMaker(player_database, nsm).start()
ac = AlphaCounter(player_database, nsm).start()
# ===================================================== EventProcessor
ep = EventProcessor(player_database, EPtoSL, SLtoEP, nsm)
# ===================================================== StatisticsNotary
server_socket = socket(AF_INET, SOCK_STREAM)
server_socket.setsockopt(SOL_SOCKET, SO_REUSEADDR, 1)
server_socket.bind((config['stat_not_interface'], config['stat_not_port']))
server_socket.listen(10)
server_socket = ServerSocket(server_socket)
sn = StatisticsNotary(player_database, server_socket)
# ===================================================== Core run option
from satella.instrumentation.exctrack import Trackback
# ----- designate runner threads
class SNThread(BaseThread):
def run(self):
while not self._terminating:
try:
sn.select(timeout=10)
