def test_basic(self): emitter = Emitter() obs = SpyObserver() emitter.bind(obs) emitter(index=1) self.assertEqual(len(obs.events), 1) self.assertEqual(obs.events[0][0], 'on_basic')
def test_key(self): emitter = Emitter() obs = SpyObserver() emitter.bind(obs) emitter(key='key_1', index=1) self.assertEqual(len(obs.events), 1) self.assertEqual(obs.events[0][0], 'on_key')
def test_subscribe_basic(self): emitter = Emitter() obs = SpyObserver() emitter.subscribe(obs.on_no_listener) emitter(index=1) self.assertEqual(len(obs.events), 1) self.assertEqual(obs.events[0][0], 'on_no_listener')
def test_both(self): emitter = Emitter(area='area_2') obs = SpyObserver() emitter.bind(obs) emitter(key='key_2', index=1) self.assertEqual(len(obs.events), 1) self.assertEqual(obs.events[0][0], 'on_both')
def test_custom_event(self): emitter = Emitter(event=MyEvent) obs = SpyObserver() emitter.bind(obs) emitter(index=1) self.assertEqual(len(obs.events), 1) self.assertEqual(obs.events[0][0], 'on_my_event')
def test_area(self): emitter = Emitter(area='area_1') obs = SpyObserver() emitter.bind(obs) emitter(index=1) self.assertEqual(len(obs.events), 1) self.assertEqual(obs.events[0][0], 'on_area')
def test_subscribe_key(self): '''Test subscription with a key - events with keys other than what we subscribed to must be filtered out.''' emitter = Emitter(area='area_1') obs = SpyObserver() emitter.subscribe(obs.on_basic, key='a') emitter(key='a', index=1) emitter(key='b', index=2) self.assertEqual(len(obs.events), 1) self.assertEqual(obs.events[0][0], 'on_basic') self.assertEqual(obs.events[0][1].data['index'], 1)
def __init__(self, server, port): self.server = server self.port = port self.socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM) self.compression_threshold = -1 self.raw_packet_emitter = Emitter(RawPacketEvent)
def __init__(self, packet_factory, connection): self.packet_factory = packet_factory self.connection = connection self._state = State.HANDSHAKING self.keep_alive_packet = packet_factory.get_by_name( State.PLAY, Direction.TO_SERVER, 'keep_alive') self.play_state_emitter = Emitter(PacketEvent, area=State.PLAY) self.login_state_emitter = Emitter(PacketEvent, area=State.LOGIN) self.handshake_state_emitter = Emitter( PacketEvent, area=State.HANDSHAKING) self.state_change_emitter = Emitter(StateChangeEvent) self.play_state_emitter.bind(self) self.login_state_emitter.bind(self) self.handshake_state_emitter.bind(self)
def __init__(self, packet_factory, connection): self.factory = packet_factory self.connection = connection self.tick_emitter = Emitter(TickEvent) self.stop_emitter = Emitter(StopEvent) RESPONSE_PACKETS = ('client_command', 'teleport_confirm', 'flying', 'position_look', 'block_dig', 'entity_action', 'block_place', 'chat', 'use_entity') for name in RESPONSE_PACKETS: prop_name = name + '_packet' packet = packet_factory.get_by_name(State.PLAY, Direction.TO_SERVER, name) setattr(self, prop_name, packet) self.dead = True self.respawn_timer = None self.facing = Facing() self.position = Position() self.velocity = Velocity() self.last_time = None self.tick_counter = 0 self.game_info = GameInfo() self.dig_ticks_remaining = None self.respond = True self.responder_thread = threading.Thread(target=self.responder) # map of (x,z) --> chunk data self.chunks = {}
def __init__(self, packet_factory, connection): self.packet_factory = packet_factory self.connection = connection self._state = State.HANDSHAKING self.keep_alive_packet = packet_factory.get_by_name( State.PLAY, Direction.TO_SERVER, 'keep_alive') self.play_state_emitter = Emitter(PacketEvent, area=State.PLAY) self.login_state_emitter = Emitter(PacketEvent, area=State.LOGIN) self.handshake_state_emitter = Emitter(PacketEvent, area=State.HANDSHAKING) self.state_change_emitter = Emitter(StateChangeEvent) self.play_state_emitter.bind(self) self.login_state_emitter.bind(self) self.handshake_state_emitter.bind(self)
class PacketReactor: class HandshakeState(enum.Enum): STATUS = 1 PLAY = 2 def __init__(self, packet_factory, connection): self.packet_factory = packet_factory self.connection = connection self._state = State.HANDSHAKING self.keep_alive_packet = packet_factory.get_by_name( State.PLAY, Direction.TO_SERVER, 'keep_alive') self.play_state_emitter = Emitter(PacketEvent, area=State.PLAY) self.login_state_emitter = Emitter(PacketEvent, area=State.LOGIN) self.handshake_state_emitter = Emitter(PacketEvent, area=State.HANDSHAKING) self.state_change_emitter = Emitter(StateChangeEvent) self.play_state_emitter.bind(self) self.login_state_emitter.bind(self) self.handshake_state_emitter.bind(self) @property def state(self): return self._state @state.setter def state(self, new_state): # print('State transition {} --> {}'.format(self._state, new_state)) self.state_change_emitter(old_state=self._state, new_state=new_state) self._state = new_state @Listener(RawPacketEvent) def on_raw_packet(self, event): # print('on_raw_packet (state={}, packet_id={})'.format(self.state, event.packet_id)) packet_clz = self.packet_factory.get_by_id(self.state, Direction.TO_CLIENT, event.packet_id) # TODO need to handle packets with 'switch' field types for name, xtype in packet_clz.FIELDS: if xtype == 'switch': print('Skipping packet "{}" w/ switch field.'.format( packet_clz.NAME)) return packet = packet_clz() packet.from_wire(event.data, event.length) if self._state == State.PLAY: self.play_state_emitter(key=packet.NAME, packet=packet) elif self._state == State.LOGIN: self.login_state_emitter(key=packet.NAME, packet=packet) elif self._state == State.HANDSHAKING: self.handshake_state_emitter(key=packet.NAME, packet=packet) def login(self, username): handshake_pkt = self.packet_factory.get_by_name( State.HANDSHAKING, Direction.TO_SERVER, 'set_protocol')() handshake_pkt.fields.protocolVersion = self.packet_factory.version handshake_pkt.fields.serverHost = self.connection.server handshake_pkt.fields.serverPort = self.connection.port handshake_pkt.fields.nextState = self.HandshakeState.PLAY.value self.connection.send(handshake_pkt) self.state = State.LOGIN login_pkt = self.packet_factory.get_by_name(State.LOGIN, Direction.TO_SERVER, 'login_start')() login_pkt.fields.username = username self.connection.send(login_pkt) # # default handlers # @Listener(PacketEvent, State.LOGIN, key='encryption_begin') def on_encryption_begin(self, packet): raise NotImplementedError( 'Encryption (aka Online Mode) is not supported at this time.') @Listener(PacketEvent, State.LOGIN, key='success') def on_login(self, event): packet = event.packet print('LOGIN: Robot "{}:{}" has been logged in.'.format( packet.fields.username, packet.fields.uuid)) self.state = State.PLAY @Listener(PacketEvent, State.LOGIN, key='disconnect') def on_disconnect(self, packet): raise DisconnectException(packet.reason) @Listener(PacketEvent, State.LOGIN, key='compress') def on_compress(self, event): packet = event.packet self.connection.set_compression(packet.threshold) @Listener(PacketEvent, State.PLAY, key='keep_alive') def on_keep_alive(self, event): packet = event.packet response = self.keep_alive_packet() response.fields.keepAliveId = packet.fields.keepAliveId self.connection.send(response) @Listener(PacketEvent, State.PLAY, key='kick_disconnect') def on_kick_disconnect(self, event): raise KickedOutException(event.packet.fields.reason)
class PacketReactor: class HandshakeState(enum.Enum): STATUS = 1 PLAY = 2 def __init__(self, packet_factory, connection): self.packet_factory = packet_factory self.connection = connection self._state = State.HANDSHAKING self.keep_alive_packet = packet_factory.get_by_name( State.PLAY, Direction.TO_SERVER, 'keep_alive') self.play_state_emitter = Emitter(PacketEvent, area=State.PLAY) self.login_state_emitter = Emitter(PacketEvent, area=State.LOGIN) self.handshake_state_emitter = Emitter( PacketEvent, area=State.HANDSHAKING) self.state_change_emitter = Emitter(StateChangeEvent) self.play_state_emitter.bind(self) self.login_state_emitter.bind(self) self.handshake_state_emitter.bind(self) @property def state(self): return self._state @state.setter def state(self, new_state): # print('State transition {} --> {}'.format(self._state, new_state)) self.state_change_emitter(old_state=self._state, new_state=new_state) self._state = new_state @Listener(RawPacketEvent) def on_raw_packet(self, event): # print('on_raw_packet (state={}, packet_id={})'.format(self.state, event.packet_id)) packet_clz = self.packet_factory.get_by_id( self.state, Direction.TO_CLIENT, event.packet_id) # TODO need to handle packets with 'switch' field types for name, xtype in packet_clz.FIELDS: if xtype == 'switch': print('Skipping packet "{}" w/ switch field.'.format( packet_clz.NAME)) return packet = packet_clz() packet.from_wire(event.data, event.length) if self._state == State.PLAY: self.play_state_emitter(key=packet.NAME, packet=packet) elif self._state == State.LOGIN: self.login_state_emitter(key=packet.NAME, packet=packet) elif self._state == State.HANDSHAKING: self.handshake_state_emitter(key=packet.NAME, packet=packet) def login(self, username): handshake_pkt = self.packet_factory.get_by_name( State.HANDSHAKING, Direction.TO_SERVER, 'set_protocol')() handshake_pkt.fields.protocolVersion = self.packet_factory.version handshake_pkt.fields.serverHost = self.connection.server handshake_pkt.fields.serverPort = self.connection.port handshake_pkt.fields.nextState = self.HandshakeState.PLAY.value self.connection.send(handshake_pkt) self.state = State.LOGIN login_pkt = self.packet_factory.get_by_name( State.LOGIN, Direction.TO_SERVER, 'login_start')() login_pkt.fields.username = username self.connection.send(login_pkt) # # default handlers # @Listener(PacketEvent, State.LOGIN, key='encryption_begin') def on_encryption_begin(self, packet): raise NotImplementedError( 'Encryption (aka Online Mode) is not supported at this time.') @Listener(PacketEvent, State.LOGIN, key='success') def on_login(self, event): packet = event.packet print('LOGIN: Robot "{}:{}" has been logged in.'.format( packet.fields.username, packet.fields.uuid)) self.state = State.PLAY @Listener(PacketEvent, State.LOGIN, key='disconnect') def on_disconnect(self, packet): raise DisconnectException(packet.reason) @Listener(PacketEvent, State.LOGIN, key='compress') def on_compress(self, event): packet = event.packet self.connection.set_compression(packet.threshold) @Listener(PacketEvent, State.PLAY, key='keep_alive') def on_keep_alive(self, event): packet = event.packet response = self.keep_alive_packet() response.fields.keepAliveId = packet.fields.keepAliveId self.connection.send(response) @Listener(PacketEvent, State.PLAY, key='kick_disconnect') def on_kick_disconnect(self, event): raise KickedOutException(event.packet.fields.reason)