def connect(self):
"""Connect to master server.
After this, you can use `send_packet` and `receive_packet` to communicate
with the server.
"""
if self.is_connected:
raise network.AlreadyConnected(
"We are already connected to a server")
self.log.debug("[CONNECT] to server %s" % (self.server_address))
try:
if self.server_address is None:
# can only construct address now, as it resolves the target and requires internet connection
self.server_address = enet.Address(
*self.server_address_parameters)
self.server_peer = self.host.connect(self.server_address, 1,
SERVER_PROTOCOL)
except (IOError, MemoryError):
raise network.NetworkException(
_("Unable to connect to server.") + u" " +
_("Maybe invalid or irresolvable server address."))
event = self.host.service(SERVER_TIMEOUT)
if event.type != enet.EVENT_TYPE_CONNECT:
self._reset()
raise network.UnableToConnect(_("Unable to connect to server."))
def run(self):
logging.info("Starting up server on %s:%d" % (self.hostname, self.port))
try:
self.host = enet.Host(enet.Address(self.hostname, self.port), MAX_PEERS, 0, 0, 0)
except (IOError, MemoryError) as e:
# these exceptions do not provide any information.
raise network.NetworkException("Unable to create network structure: %s" % (e))
logging.debug("Entering the main loop...")
while True:
if self.statistic['file'] is not None:
if self.statistic['timestamp'] <= 0:
self.print_statistic(self.statistic['file'])
self.statistic['timestamp'] = self.statistic['interval']
else:
self.statistic['timestamp'] -= CONNECTION_TIMEOUT
event = self.host.service(CONNECTION_TIMEOUT)
if event.type == enet.EVENT_TYPE_NONE:
continue
elif event.type == enet.EVENT_TYPE_CONNECT:
self.call_callbacks("onconnect", event)
elif event.type == enet.EVENT_TYPE_DISCONNECT:
self.call_callbacks("ondisconnect", event)
elif event.type == enet.EVENT_TYPE_RECEIVE:
self.call_callbacks("onreceive", event)
else:
logging.warning("Invalid packet (%u)" % (event.type))
def run(self):
"""
Main loop of the server
"""
logging.info("Starting up server on {0!s}:{1:d}".format(self.hostname, self.port))
try:
self.host = enet.Host(enet.Address(self.hostname, self.port), MAX_PEERS, 0, 0, 0)
except (IOError, MemoryError) as e:
# these exceptions do not provide any information.
raise network.NetworkException("Unable to create network structure: {0!s}".format((e)))
logging.debug("Entering the main loop...")
while True:
self.collect_statistics()
event = self.host.service(CONNECTION_TIMEOUT)
if event.type == enet.EVENT_TYPE_NONE:
continue
elif event.type == enet.EVENT_TYPE_CONNECT:
self.events.broadcast("on_connect", event)
elif event.type == enet.EVENT_TYPE_DISCONNECT:
self.events.broadcast("on_disconnect", event)
elif event.type == enet.EVENT_TYPE_RECEIVE:
self.events.broadcast("on_receive_data", event)
else:
logging.warning("Invalid packet ({0})".format(event.type))
def __init__(self, name, version, server_address, client_address=None):
try:
clientaddress = enet.Address(
client_address[0],
client_address[1]) if client_address is not None else None
self.host = enet.Host(clientaddress, MAX_PEERS, 0, 0, 0)
except (IOError, MemoryError):
raise network.NetworkException(
"Unable to create network structure. Maybe invalid or irresolvable client address."
)
self.name = name
self.version = version
self.serveraddress = Address(server_address[0], server_address[1])
self.serverpeer = None
self.mode = ClientMode.Server
self.game = None
self.packetqueue = []
self.callbacks = {
'lobbygame_chat': [],
'lobbygame_join': [],
'lobbygame_leave': [],
'lobbygame_state': [],
'lobbygame_starts': [],
'p2p_ready': [],
'p2p_data': [],
}
pass
def connect(self):
if self.serverpeer is not None:
raise network.AlreadyConnected(
"We are already connected to a server")
if self.mode is None:
self.mode = ClientMode.Server
if self.mode is not ClientMode.Server:
raise network.NotInServerMode(
"You can't connect to a server while client is not in server mode"
)
self.log.debug("[CONNECT] to server %s" % (self.serveraddress))
try:
self.serverpeer = self.host.connect(
enet.Address(self.serveraddress.host, self.serveraddress.port),
1, 0)
except (IOError, MemoryError):
raise network.NetworkException(
"Unable to connect to server. Maybe invalid or irresolvable server address."
)
self.mode = ClientMode.Server
event = self.host.service(SERVER_TIMEOUT)
if event.type != enet.EVENT_TYPE_CONNECT:
self.reset()
raise network.UnableToConnect("Unable to connect to server")
self.log.debug("[CONNECT] done")
def connect(self):
if self.serverpeer is not None:
raise network.AlreadyConnected("We are already connected to a server")
if self.mode is None:
self.mode = ClientMode.Server
if self.mode is not ClientMode.Server:
raise network.NotInServerMode("You can't connect to a server while client is not in server mode")
self.log.debug("[CONNECT] to server %s" % (self.serveraddress))
try:
self.serverpeer = self.host.connect(enet.Address(self.serveraddress.host, self.serveraddress.port), 1, 0)
except (IOError, MemoryError):
raise network.NetworkException("Unable to connect to server. Maybe invalid or irresolvable server address.")
self.mode = ClientMode.Server
event = self.host.service(SERVER_TIMEOUT)
if event.type != enet.EVENT_TYPE_CONNECT:
self.reset()
raise network.UnableToConnect("Unable to connect to server")
self.log.debug("[CONNECT] done")
if self.localport is None and hasattr(socket, 'fromfd'):
s = socket.fromfd(self.host.socket.fileno(), socket.AF_INET, socket.SOCK_DGRAM)
self.localport = s.getsockname()[1]
if self.localport is not None:
self.log.debug("[CONNECT] localport=%s" % (self.localport))
if self.extport is None:
self.extport = self.upnp_connect(self.localport)
if self.extport is None:
self.extport = self.natpmp_connect(self.localport)
else:
self.log.debug("[CONNECT] Unable to determine local port");
def __init__(self, process_async_packet, server_address, client_address=None):
try:
if client_address:
client_address = enet.Address(*client_address)
self.host = enet.Host(client_address, MAX_PEERS, 0, 0, 0)
except (IOError, MemoryError):
# these exceptions do not provide any information.
raise network.NetworkException("Unable to create network structure."
"Maybe invalid or irresolvable client address.")
self.server_address_parameters = server_address
self.server_address = None
self.server_peer = None
self.packetqueue = []
self.process_async_packet = process_async_packet
def run(self):
logging.info("Starting up server on %s:%d" % (self.hostname, self.port))
try:
self.host = enet.Host(enet.Address(self.hostname, self.port), MAX_PEERS, 0, 0, 0)
except (IOError, MemoryError):
raise network.NetworkException("Unable to create network structure. Maybe invalid or irresolvable server address.")
logging.debug("Entering the main loop...")
while True:
event = self.host.service(CONNECTION_TIMEOUT)
if event.type == enet.EVENT_TYPE_NONE:
continue
elif event.type == enet.EVENT_TYPE_CONNECT:
self.call_callbacks("connect", event)
elif event.type == enet.EVENT_TYPE_DISCONNECT:
self.call_callbacks("disconnect", event);
elif event.type == enet.EVENT_TYPE_RECEIVE:
self.call_callbacks("receive", event);
else:
logging.warning("Invalid packet (%u)" % (event.type))
def connect(self):
"""Connect to master server.
After this, you can use `send_packet` and `receive_packet` to communicate
with the server.
"""
if self.is_connected:
raise network.AlreadyConnected(
"We are already connected to a server")
self.log.debug("[CONNECT] to server %s" % (self.server_address))
try:
self.server_peer = self.host.connect(self.server_address, 1,
SERVER_PROTOCOL)
except (IOError, MemoryError):
raise network.NetworkException(
"Unable to connect to server."
"Maybe invalid or irresolvable server address.")
event = self.host.service(SERVER_TIMEOUT)
if event.type != enet.EVENT_TYPE_CONNECT:
self._reset()
raise network.UnableToConnect("Unable to connect to server")
def __init__(self, name, version, server_address, client_address=None, color=None, clientid=None):
try:
clientaddress = enet.Address(client_address[0], client_address[1]) if client_address is not None else None
self.host = enet.Host(clientaddress, MAX_PEERS, 0, 0, 0)
except (IOError, MemoryError):
# these exceptions do not provide any information.
raise network.NetworkException("Unable to create network structure. Maybe invalid or irresolvable client address.")
self.name = name
self.version = version
self.serveraddress = Address(server_address[0], server_address[1])
self.serverpeer = None
self.mode = None
self.sid = None
self.capabilities = None
self.game = None
self.clientid = clientid
self.color = color
self.packetqueue = []
self.callbacks = {
'lobbygame_chat': [],
'lobbygame_join': [],
'lobbygame_leave': [],
'lobbygame_terminate': [],
'lobbygame_toggleready': [],
'lobbygame_changename': [],
'lobbygame_kick': [],
'lobbygame_changecolor': [],
'lobbygame_state': [],
'lobbygame_starts': [],
'game_starts': [],
'game_data': [],
'savegame_data': [], #TODO
}
self.register_callback('lobbygame_changename', self.onchangename, True)
self.register_callback('lobbygame_changecolor', self.onchangecolor, True)
pass
def connect(self):
if self.serverpeer is not None:
raise network.AlreadyConnected("We are already connected to a server")
self.log.debug("[CONNECT] to server %s" % (self.serveraddress))
try:
self.serverpeer = self.host.connect(enet.Address(self.serveraddress.host,
self.serveraddress.port),
1, SERVER_PROTOCOL)
except (IOError, MemoryError):
raise network.NetworkException("Unable to connect to server. Maybe invalid or irresolvable server address.")
self.mode = ClientMode.Server
event = self.host.service(SERVER_TIMEOUT)
if event.type != enet.EVENT_TYPE_CONNECT:
self.reset()
raise network.UnableToConnect("Unable to connect to server")
# wait for session id
packet = self.recv_packet([packets.server.cmd_session])
if packet is None:
raise network.FatalError("No reply from server")
elif not isinstance(packet[1], packets.server.cmd_session):
raise network.CommandError("Unexpected packet")
self.sid = packet[1].sid
self.capabilities = packet[1].capabilities
self.log.debug("[CONNECT] done (session=%s)" % (self.sid))
