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 __init__(self, address="127.0.0.1", port=51441, realtime=True): """ Constructor for this object """ self._host = enet.Host(None, 1, 0, 0) self._peer = None self.buf = bytearray() self.realtime = realtime self.address = address self.port = port
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, address="localhost", port=28785, name="Bot", playermodel=0): self.sock = enet.Host(None, 1, 2) self.address = address self.port = port self.name = name self.playermodel = playermodel
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__(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 __init__(self, address="127.0.0.1", port=51441, realtime=True): """ Constructor for this object """ self._host = enet.Host(None, 1, 0, 0) self._peer = None self.buf = bytearray() self.realtime = realtime self.address = address self.port = port # Not yet supported self.playedOn = "dolphin" self.timestamp = "" self.consoleNick = "" self.players = {}
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 __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 __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 = []
# -- 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(
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
def __init__(self, gameclient, host="127.0.0.1", port=1919): super(client_adapter, self).__init__(gameclient, host, port) self.enet = enet.Host(None, 1, 0, 0, 0) self.server = self.enet.connect(enet.Address(self.host, self.port), 1) self.connect_to_server()
def __init__(self, host='', port=0, con_limit=4, *args, **kwargs): super(Server, self).__init__(host, port, con_limit, *args, **kwargs) host = enet.Address(host, port) self.host = enet.Host(host, con_limit, *args, **kwargs) self._peer_cnt = 0
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)
def start(self): self.host = enet.Host(enet.Address(self.host, self.port), 1000, 0, 0, 0)
def __init__(self, conn_limit=1, *args, **kwargs): super(Client, self).__init__(*args, **kwargs) self.host = enet.Host(None, conn_limit)
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
import sys sys.exit() args.ip = ip[:-1] #TODO: fix race condition import os if os.path.exists(args.file): i = 1 while os.path.exists(args.file + "-" + str(i)): i += 1 args.file += "-" + str(i) import struct import enet from time import time con = enet.Host(None, 1, 1) con.compress_with_range_coder() print('Trying to connect to: ' + args.ip) peer = con.connect(enet.Address(bytes(args.ip, 'utf-8'), args.port), 1, args.version) with open(args.file, "wb") as fh: fh.write(struct.pack('BB', FILE_VERSION, args.version)) while True: try: event = con.service(1000) except IOError: continue if event is None: continue elif event.type == enet.EVENT_TYPE_CONNECT: print('connected to server')
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
import enet host = enet.Host(None, 1, 0, 0) peer = host.connect(enet.Address("localhost", 33333), 1)