def _test_connect(self, client_version=None, server_version=None):
server = FakeServer(minecraft_version=server_version)
addr, port = server.listen_socket.getsockname()
cond = threading.Condition()
def handle_client_exception(exc, exc_info):
with cond:
cond.exc_info = exc_info
cond.notify_all()
def client_write(packet, *args, **kwds):
def packet_write(*args, **kwds):
logging.debug('[C-> ] %s' % packet)
return real_packet_write(*args, **kwds)
real_packet_write = packet.write
packet.write = packet_write
return real_client_write(packet, *args, **kwds)
def client_react(packet, *args, **kwds):
logging.debug('[ ->C] %s' % packet)
return real_client_react(packet, *args, **kwds)
client = connection.Connection(
addr, port, username='******', initial_version=client_version,
handle_exception=handle_client_exception)
real_client_react = client._react
real_client_write = client.write_packet
client.write_packet = client_write
client._react = client_react
try:
with cond:
server_thread = threading.Thread(
name='_ConnectTest server',
target=self._test_connect_server,
args=(server, cond))
server_thread.daemon = True
server_thread.start()
self._test_connect_client(client, cond)
cond.exc_info = Ellipsis
cond.wait(THREAD_TIMEOUT_S)
if cond.exc_info is Ellipsis:
self.fail('Timed out.')
elif cond.exc_info is not None:
raise_(*cond.exc_info)
finally:
# Wait for all threads to exit.
for thread in server_thread, client.networking_thread:
if thread is not None and thread.is_alive():
thread.join(THREAD_TIMEOUT_S)
if thread is not None and thread.is_alive():
if cond.exc_info is None:
self.fail('Thread "%s" timed out.' % thread.name)
else:
# Keep the earlier exception, if there is one.
break
def run_connection(self):
try:
auth = self.authenticate()
except Exception as e:
if not isinstance(e, NO_TRACE_ERRORS):
traceback.print_exc()
return self.disconnect(e)
with self.rlock:
if auth is None:
kwds = {'username': self.uname}
self.profile_name = self.uname
else:
kwds = {'auth_token': auth}
self.profile_name = auth.profile.name
def conn_exception(exc, exc_info):
with self.rlock:
if conn is self.connection:
if not isinstance(exc, NO_TRACE_ERRORS):
traceback.print_exception(*exc_info)
self.disconnect(exc)
allowed_versions = None if self.version is None else {self.version}
conn = connection.Connection(self.host,
self.port,
allowed_versions=allowed_versions,
handle_exception=conn_exception,
**kwds)
for plugin in (self, ) + tuple(self.plugins or ()):
plugin.install(conn)
if self.show_packets:
conn.write_packet = partial(self.show_send_packet,
cont=conn.write_packet)
self.connection = conn
self.keep_alive = True
try:
conn.connect()
except BaseException as e:
if not isinstance(e, NO_TRACE_ERRORS):
traceback.print_exc()
return self.disconnect(e)
if self.prevent_timeout:
thread = Thread(target=self.run_prevent_timeout,
name='Connection.run_prevent_timeout')
thread.daemon = True
thread.start()
if self.no_timeout: return
while conn is self.connection:
with self.rlock:
if not self.keep_alive:
self.disconnect('Timed out (%ss).' % KEEPALIVE_TIMEOUT_S)
return
self.keep_alive = False
self.disconnect_cond.wait(KEEPALIVE_TIMEOUT_S)
def _test_connect(self, client_version, server_version):
server = FakeServer(minecraft_version=server_version)
addr, port = server.listen_socket.getsockname()
client = connection.Connection(addr,
port,
username='******',
initial_version=client_version)
cond = threading.Condition()
try:
with cond:
server_thread = threading.Thread(
name='test_connection server',
target=self._test_connect_server,
args=(server, cond))
server_thread.daemon = True
server_thread.start()
client_thread = threading.Thread(
name='test_connection client',
target=self._test_connect_client,
args=(client, cond))
client_thread.daemon = True
client_thread.start()
cond.wait()
if cond.exc_info is not None:
raise_(*cond.exc_info)
finally:
# Wait for all threads to exit.
for thread in server_thread, client_thread:
if thread.is_alive():
thread.join(THREAD_TIMEOUT_S)
if thread.is_alive():
if cond.exc_info is None:
self.fail('Thread "%s" timed out.' % thread.name)
else:
# Keep the earlier exception, if there is one.
break
def _test_connect(self,
client_versions=None,
server_version=None,
client_handler_type=None,
compression_threshold=None):
if client_versions is None:
client_versions = self.client_versions
if server_version is None:
server_version = self.server_version
if compression_threshold is None:
compression_threshold = self.compression_threshold
if client_handler_type is None:
client_handler_type = self.client_handler_type
server = FakeServer(minecraft_version=server_version,
compression_threshold=compression_threshold,
client_handler_type=client_handler_type)
addr = "localhost"
port = server.listen_socket.getsockname()[1]
cond = threading.Condition()
server_lock = threading.Lock()
server_exc_info = [None]
client_lock = threading.Lock()
client_exc_info = [None]
def handle_client_exception(exc, exc_info):
with client_lock:
client_exc_info[0] = exc_info
with cond:
cond.notify_all()
client = connection.Connection(
addr,
port,
username='******',
allowed_versions=client_versions,
handle_exception=handle_client_exception)
client.register_packet_listener(
lambda packet: logging.debug('[ ->C] %s' % packet),
packets.Packet,
early=True)
client.register_packet_listener(
lambda packet: logging.debug('[C-> ] %s' % packet),
packets.Packet,
early=True,
outgoing=True)
server_thread = threading.Thread(name='FakeServer',
target=self._test_connect_server,
args=(server, cond, server_lock,
server_exc_info))
server_thread.daemon = True
errors = []
try:
try:
with cond:
server_thread.start()
self._start_client(client)
cond.wait(THREAD_TIMEOUT_S)
finally:
# Wait for all threads to exit.
server.stop()
for thread in server_thread, client.networking_thread:
if thread is not None and thread.is_alive():
thread.join(THREAD_TIMEOUT_S)
if thread is not None and thread.is_alive():
errors.append(
{'msg': 'Thread "%s" timed out.' % thread.name})
except Exception:
errors.insert(0, {
'msg': 'Exception in main thread',
'exc_info': sys.exc_info()
})
else:
timeout = True
for lock, [exc_info
], thread_name in ((client_lock, client_exc_info,
'client thread'),
(server_lock, server_exc_info,
'server thread')):
with lock:
if exc_info is None:
continue
if not issubclass(exc_info[0], FakeServerTestSuccess):
errors.insert(
0, {
'msg': 'Exception in %s:' % thread_name,
'exc_info': exc_info
})
timeout = False
if timeout:
errors.insert(0, {'msg': 'Test timed out.'})
if len(errors) > 1:
for error in errors:
logging.error(**error)
self.fail('Multiple errors: see logging output.')
elif errors and 'exc_info' in errors[0]:
raise_(*errors[0]['exc_info'])
elif errors:
self.fail(errors[0]['msg'])
def test_connection(self):
connection = conn.Connection("localhost", 25565, None)
self.assertFalse(connection.options.compression_enabled)