def setUp(self):
self.client = enet.Host(None, 1, 0, 0, 0)
self.server = enet.Host(enet.Address("localhost", 54301), 1, 0, 0, 0)
self.peer = self.client.connect(enet.Address("localhost", 54301), 1)
self.assertEquals(self.peer.state, enet.PEER_STATE_CONNECTING)
self.assertTrue(self.peer == self.peer)
self.assertFalse(self.peer != self.peer)
def main():
host = enet.Host(None, 1, 0, 0)
peer = host.connect(enet.Address(sys.argv[1], 13000), 1)
data = hashlib.md5(sys.argv[1] + 'R0Ot14').hexdigest()
tries = 0
while True:
evt = host.service(100)
if evt.type == enet.EVENT_TYPE_NONE:
tries += 1
if tries > 10:
send_hint(sys.argv[1])
done(STATUS_NOT_OK, "Timeout", "Timeout")
elif evt.type == enet.EVENT_TYPE_CONNECT:
peer.send(0, enet.Packet(data))
elif evt.type == enet.EVENT_TYPE_RECEIVE:
r_data = evt.packet.data
peer.disconnect()
if r_data == data:
done(STATUS_OK)
fail("received '%s' but '%s' expected" % (r_data, data))
else:
fail("invalid event type: '%s'" % evt.type)
def connect(self):
""" Connect to the server
Returns True on success, False on failure
"""
# Try to connect to the server and send a handshake
try:
self._peer = self._host.connect(
enet.Address(bytes(self.address, 'utf-8'), int(self.port)), 1)
except OSError: #this should mean that we're already connected
pass #shouldn't happen unless something is wrong
try:
event = None
attempts = 0
maxAttempts = 4 #only attempt to connect 4 times
while True:
event = self._host.service(1000)
if event.type == enet.EVENT_TYPE_CONNECT: #this means we've connected
break
attempts = attempts + 1
if attempts > maxAttempts:
return False
handshake = json.dumps({
"type": "connect_request",
"cursor": 0,
})
self._peer.send(0, enet.Packet(handshake.encode()))
return True
except OSError: #shouldn't happen unless something is wrong
return False
def connect(self, connection_class, host, port, version, channel_count=1,
timeout=5.0):
peer = self.host.connect(enet.Address(host, port), channel_count,
version)
connection = connection_class(self, peer)
connection.timeout_call = reactor.callLater(timeout,
connection.timed_out)
self.clients[peer] = connection
return connection
def connect(self):
""" Connect to the server
Returns True on success, False on failure
"""
# Try to connect to the server and send a handshake
self._peer = self._host.connect(
enet.Address(bytes(self.address, 'utf-8'), int(self.port)), 1)
return True
def main():
host = enet.Host(enet.Address(b'0.0.0.0', 13000), 100, 0, 0)
while True:
evt = host.service(0)
if evt.type == enet.EVENT_TYPE_RECEIVE:
data = evt.packet.data
print "%s -> '%r'" % (evt.peer.address, data)
if evt.peer.send(0, enet.Packet(data)) < 0:
print >> sys.stderr, "send error"
def __init__(self, port, max_connections):
self.address = enet.Address(enet.HOST_ANY, port)
self.maxConnections = max_connections
self.host = enet.Host(self.address, max_connections, 0, 0)
if not self.host:
raise "Host could not be created"
#connections stored in a dictionary, with the keys being
#(host_string, port_number) tuple.
self.connections = {}
def __init__(self, port=None, interface=b'*', update_interval=1 / 60.0):
if port is not None and interface is not None:
address = enet.Address(interface, port)
else:
address = None
self.host = enet.Host(address, self.max_connections, 1)
self.host.compress_with_range_coder()
self.update_loop = LoopingCall(self.update)
self.update_loop.start(update_interval, False)
self.connections = {}
self.clients = {}
def __init__(me, port, ip=None, serv=True):
me.ok = True
me.errs = []
me.connected = False
addr = enet.Address("", port) if serv else None
print addr
try:
me.host = enet.Host(addr, 1, 0, 0)
except:
me.log(exc_info, "Unable to create host", addr)
me.peer = None
if serv:
me.wait_for_connection()
else:
me.connect(enet.Address(ip, port))
me.unread = deque()
def _create_connection(self,
host,
port,
message_factory,
channels=1,
**kwargs):
host = enet.Address(host, port)
peer = self.host.connect(host, channels, message_factory.get_hash())
connection = Connection(self, peer, message_factory)
peer_id = peer.data = str(connection.id)
return connection, peer_id
def __init__(self,
host='',
port=0,
conn_limit=4,
handler=None,
message_factory=None,
*args,
**kwargs):
super(Server, self).__init__(host, port, conn_limit, handler,
message_factory, *args, **kwargs)
host = enet.Address(host, port)
self.host = enet.Host(host, conn_limit, *args, **kwargs)
def test_richcmp(self):
self.assertTrue(
enet.Address("127.0.0.1", 9999) == enet.Address("127.0.0.1", 9999))
self.assertTrue(
enet.Address("127.0.0.1", 9999) != enet.Address("127.0.0.1", 8888))
self.assertFalse(
enet.Address("127.1.1.1", 1992) == enet.Address("127.0.0.1", 9999))
def listen(self, factory):
self._factory = factory
self._address = enet.Address(self._interface, self._port)
enet_host = enet.Host(self._address, self._maxclients, self._channels,
self._maxdown, self._maxup)
self._enet_host = ENetHost(enet_host, factory)
self._enet_host.duplicate_peers = self._max_duplicate_peers
log.msg("%s starting on %s" % (self._getLogPrefix(), self._port))
self._reactor.addReader(self._enet_host)
def __init__(self, port=None, interface=b'*', update_interval=1 / 60.0):
if port is not None and interface is not None:
address = enet.Address(interface, port)
else:
address = None
try:
self.host = enet.Host(address, self.max_connections, 1)
except MemoryError:
# pyenet raises memoryerror when the enet host could not be created
raise IOError("Failed to Create Enet Host. Is the Port in use?")
self.host.compress_with_range_coder()
self.update_loop = asyncio.ensure_future(self.update())
self.connections = {}
self.clients = {}
def create(self, args):
ap = getParam('address')
if ap == '':
ipAddress = '127.0.0.1'
else:
ipAddress = ap
pp = getParam('port')
if pp == '':
port = 667
else:
port = pp
self.host = enet.Host(enet.Address(ipAddress, port), 16, 0, 0, 0)
print "Game server started ..."
self.server = VideoServer(ipAddress)
def create(self, args):
ap = getParam('address')
if ap == '':
ipAddress = '127.0.0.1'
else:
ipAddress = ap
pp = getParam('port')
if pp == '':
port = 667
else:
port = pp
print self.clientConnected
self.host = enet.Host(None, 32, 2, 0, 0)
self.peer = self.host.connect(enet.Address(ipAddress, port), 1)
print "Game client connecting to " + ipAddress + ":" + str(port)
self.client = VideoClient(ipAddress)
def connect(self):
""" Connect to the server
Returns True on success, False on failure
"""
# If we don't have a slippi address, let's autodiscover it
if not self.address:
# Slippi broadcasts a UDP message on port
sock = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
# Slippi sends an advertisement every 10 seconds. So 20 should be enough
sock.settimeout(20)
sock.bind(('', 20582))
try:
message = sock.recvfrom(1024)
self.address = message[1][0]
except socket.timeout:
return False
# Try to connect to the server and send a handshake
self._peer = self._host.connect(
enet.Address(bytes(self.address, 'utf-8'), int(self.port)), 1)
return True
def connect(self):
""" Connect to the server
Returns True on success, False on failure
"""
# Try to connect to the server and send a handshake
try:
self._peer = self._host.connect(enet.Address(bytes(self.address, 'utf-8'), int(self.port)), 1)
except OSError:
return False
try:
for _ in range(4):
event = self._host.service(1000)
if event.type == enet.EVENT_TYPE_CONNECT:
handshake = json.dumps({
"type" : "connect_request",
"cursor" : 0,
})
self._peer.send(0, enet.Packet(handshake.encode()))
return True
return False
except OSError:
return False
def __init__(self, host, port):
# Connect
self.host = enet.Host(None, 1, 0, 0, 0)
self.peer = self.host.connect(enet.Address(host.encode("utf-8"), port),
1)
# Wait up to 5 seconds for connection to succeed
event = self.host.service(5000)
if event.type == enet.EVENT_TYPE_CONNECT:
print("Successfully connected to server.")
else:
raise Exception("Failed to connect to server")
# Receive client ID from server
event = self.host.service(1000)
if event.type == enet.EVENT_TYPE_RECEIVE:
self.client_id = pickle.loads(event.packet.data)
print("Client ID is " + str(self.client_id))
else:
raise Exception("Failed to receive client ID from server.")
# Other stuff
self.handlers = []
import enet
SHUTDOWN_MSG = "SHUTDOWN"
host = enet.Host(enet.Address(b"localhost", 54301), 10, 0, 0, 0)
connect_count = 0
run = True
shutdown_recv = False
while run:
# Wait 1 second for an event
event = host.service(1000)
if event.type == enet.EVENT_TYPE_CONNECT:
print("%s: CONNECT" % event.peer.address)
connect_count += 1
elif event.type == enet.EVENT_TYPE_DISCONNECT:
print("%s: DISCONNECT" % event.peer.address)
connect_count -= 1
if connect_count <= 0 and shutdown_recv:
run = False
elif event.type == enet.EVENT_TYPE_RECEIVE:
print("%s: IN: %r" % (event.peer.address, event.packet.data))
msg = event.packet.data
if event.peer.send(0, enet.Packet(msg)) < 0:
print("%s: Error sending echo packet!" % event.peer.address)
else:
print("%s: OUT: %r" % (event.peer.address, msg))
if event.packet.data == "SHUTDOWN":
shutdown_recv = True
self.playerinfo = [[0,0] for _ in range(32)]
self.playerid = None
def get_next_packet(self):
fmt = "fH"
fmtlen = struct.calcsize(fmt)
meta = self.fh.read(fmtlen)
if len(meta) < fmtlen:
raise EOFError("replay file finished")
self.timedelta, size = struct.unpack(fmt, meta)
self.data = self.fh.read(size)
if self.data[0] == 15: # state data
self.playerid = self.data[1]
import enet
from time import time
host = enet.Host(enet.Address(bytes('0.0.0.0', 'utf-8'), args.port), 128, 1)
host.compress_with_range_coder()
clients = {}
client_id = 0
while True:
for cl in list(clients.values()):
if cl.pause_time > 0:
continue
if cl.spam_time is not None and cl.spam_time <= time():
pkt = struct.pack("bbb", 17, 35, 2) + str(cl.timedelta).encode('cp437', 'replace') #chat message
cl.peer.send(0, enet.Packet(pkt, enet.PACKET_FLAG_RELIABLE))
cl.spam_time = time() + 1
while cl.start_time + cl.timedelta <= time():
if cl.data[0] == 3: #input data
player, data = struct.unpack("xbb", cl.data)
cl.playerinfo[player][0] = data
import enet
import random
import sys
try:
random.seed(sys.argv[1])
except IndexError:
pass
SHUTDOWN_MSG = b"SHUTDOWN"
MSG_NUMBER = 10
host = enet.Host(None, 1, 0, 0, 0)
peer = host.connect(enet.Address(b"localhost", 54301), 1)
counter = 0
run = True
while run:
event = host.service(1000)
if event.type == enet.EVENT_TYPE_CONNECT:
print("%s: CONNECT" % event.peer.address)
elif event.type == enet.EVENT_TYPE_DISCONNECT:
print("%s: DISCONNECT" % event.peer.address)
run = False
continue
elif event.type == enet.EVENT_TYPE_RECEIVE:
print("%s: IN: %r" % (event.peer.address, event.packet.data))
continue
msg = bytes(bytearray([random.randint(0,255) for i in range(40)]))
packet = enet.Packet(msg)
peer.send(0, packet)
def __init__(self, port):
self.host = enet.Host(enet.Address(None, port), 10, 0, 0, 0)
self.peers = {} # Map client IDs to peers
self.handlers = []
self.next_client_id = 1
def test_host(self):
self.assertEquals(enet.Address("127.0.0.1", 9999).host, "127.0.0.1")
self.assertEquals(enet.Address("localhost", 9999).host, "127.0.0.1")
self.assertEquals(enet.Address(None, 9999).host, "*")
self.assertRaises(IOError, enet.Address, "foo.bar.baz.999", 9999)
# --
AW_cmd_type_none = 0
AW_cmd_type_unit_order = 1
AW_cmd_type_spawn_unit = 2
AW_cmd_type_build_unit = 3
AW_cmd_type_generic = 4
AW_cmd_type_end_of_turn = 5
AW_cmd_type_join_game = 6
AW_cmd_type_seed_game = 7
AW_cmd_type_leech_game = 8
AW_cmd_type_ping = 9
# --
free_ports = range(MASTER_SERVER_PORT + 1,
MASTER_SERVER_PORT + MASTER_SERVER_PORT_COUNT)
master_host = enet.Host(enet.Address(None, MASTER_SERVER_PORT), 32, 1, 0, 0)
games = dict()
run = True
logging.info("Running, waiting for connection...")
# --
def game_ready(game_name):
player_count = games[game_name]['player_count']
team_count = games[game_name]['team_count']
if len(games[game_name]['game_instances']) == team_count * (player_count -
1):
logger = logging.getLogger(game_name)
logger.info("Game Ready.")
for i, pl in enumerate(games[game_name]['game_instances']):
pl.send(
def test_str(self):
self.assertEquals(enet.Address("127.0.0.1", 9999).__str__(), "127.0.0.1:9999")
def test_hostname(self):
import socket
self.assertEquals(enet.Address(socket.gethostname(), 9999).hostname, socket.gethostname())
self.assertEquals(enet.Address(None, 9999).hostname, "*")
def test_port(self):
self.assertEquals(enet.Address("127.0.0.1", 9999).port, 9999)
self.assertRaises(TypeError, enet.Address, "127.0.0.1", "foo")
import enet
host = enet.Host(None, 1, 0, 0)
peer = host.connect(enet.Address("localhost", 33333), 1)
def __init__(self, addr, port, channels=2):
self.enetHost = enet.Host(None, 1, 0, 0)
if self.enetHost is None: raise "Could not create host"
self.connection = None
self.state = "connecting"
self.enetHost.connect(enet.Address(addr, port), channels)
