class Client1(object): def __init__(self, server_host, server_port): self.sio = SocketIO(server_host, server_port) self.register_handles() print("启动客户端Client1(sent wakeup)") self.sio.emit('client_ready') self.sio.wait() self.blindness self.req_num = 1 def register_handles(self): def req_train(): # self.req_num = self.req_num+1 print('继续请求第' + '次更新:') self.sio.emit('client_ready') def on_connect(): print('connect') def on_disconnect(): print('disconnect') def on_reconnect(): print('reconnect') def on_blind(*args): req = args[0] self.blindness = req['blind'] print('blind=', self.blindness) self.sio._close() self.sio.on('connect', on_connect) self.sio.on('disconnect', on_disconnect) self.sio.on('reconnect', on_reconnect) self.sio.on('blind', on_blind)
class SocketProxy(object): def __init__(self, id, host, port): self.client = SocketIO(host, port, BaseNamespace) self.client.on('log', self.on_log) self.client.on('end', self.on_end) self.client.on('playbook-start', self.on_playbook_start) self.client.on('playbook-stop', self.on_playbook_stop) self.client.on('playbook-error', self.on_playbook_error) self.client.emit('join', id) def on_log(self, message): emit("log", message) def on_end(self, message): emit("end") self.client.disconnect() def on_playbook_start(self, playbook): emit("playbook-start", playbook) def on_playbook_stop(self, playbook): emit("playbook-stop", playbook) def on_playbook_error(self, playbook): emit("playbook-error", playbook) def wait(self): self.client.wait() # seconds=5) # Hack! _close is needed to *really* close the connection self.client._close()
class Client2(object): def __init__(self, server_host, server_port): self.sio = SocketIO(server_host, server_port) self.register_handles() print("启动客户端Client2(sent wakeup)") self.sio.emit('client_req_update') self.sio.wait() self.weights self.priv self.pub self.req_num = 1 def register_handles(self): def on_connect(): print('connect') def on_disconnect(): print('disconnect') def on_reconnect(): print('reconnect') def on_request_update(*args): req = args[0] round_number = req['round_number'] self.priv = pickle_string_to_obj(req['priv']) self.pub = pickle_string_to_obj(req['pub']) print("轮数", round_number) if int(round_number) == 0: self.weights = pickle_string_to_obj(req['current_weights']) else: t11 = time.time() self.weights = client_decrypt( self.priv, self.pub, pickle_string_to_obj(req['current_weights'])) t22 = time.time() with open("client1_log.txt", "a") as f: f.write('解密时长' + str(t22 - t11) + '\n') # print('current_weights=', self.weights) self.sio._close() self.sio.on('connect', on_connect) self.sio.on('disconnect', on_disconnect) self.sio.on('reconnect', on_reconnect) self.sio.on('request_update', on_request_update)
class Client_server(object): def __init__(self, server_host, server_port,weights): self.sio = SocketIO(server_host, server_port) self.register_handles() print("启动客户端Client4(client_update)") self.weights=weights self.req_num = 1 self.sio.emit('client_update',{ 'weights':obj_to_pickle_string(weights) }) def register_handles(self): def req_train(): #self.req_num = self.req_num+1 print('继续请求第' + '次更新:') self.sio.emit('client_ready') def on_connect(): print('connect') def on_disconnect(): print('disconnect') def on_reconnect(): print('reconnect') def on_request_update(*args): req = args[0] self.weights = req['current_weights'] #print('current_weights=', self.weights) self.sio._close() self.sio.on('connect', on_connect) self.sio.on('disconnect', on_disconnect) self.sio.on('reconnect', on_reconnect) self.sio.on('request_update', on_request_update)
class KeyboardReader(object): def __init__(self, args): self.args = args self.device = None self.ws = None signal.signal(signal.SIGTERM, self.__stop_app) signal.signal(signal.SIGINT, self.__stop_app) self.ws = SocketIO(args.hostname, args.port) if args.all_devices: self.read_all_keyboards() else: if args.device_filename: self.device_filename = args.device_filename else: self.device_filename = self.load_device_filename() self.read_keyboard() def connect_keyboard(self): while True: try: if not self.args.silent: print('Openning device {}...'.format(self.device_filename)) self.device = evdev.InputDevice(self.device_filename) break except OSError: if not self.args.silent: print('Can\'t open device. Waiting...') time.sleep(1) xinput.disable_device(self.device_filename) if not self.args.silent: print('Success!'.format(self.device_filename)) def __stop_app(self, signum, frame): print('Trap called, exiting...') if self.device: self.device.close() if self.ws: self.ws._close() xinput.trap_handler(signum, frame) sys.exit(0) def get_all_devices(self): keyboards = os.popen( 'readlink -f /dev/input/by-path/*kbd').read().split('\n') open_devices = [] for keyboard in keyboards: if not keyboard: continue try: device = evdev.InputDevice(keyboard) except OSError: continue try: open_device = evdev.InputDevice(device.fn) except OSError: continue open_devices.append(open_device) return open_devices def send_ws_keyboard_list(self, open_devices): keyboard_package = [{ 'file': keyboard.fn, 'name': keyboard.name } for keyboard in open_devices] if not self.args.silent: print(keyboard_package) self.ws.emit('devices_list', {'devices': keyboard_package}) def read_all_keyboards(self): open_devices = self.get_all_devices() last_time = 0 while True: if time.time() > last_time + 5: open_devices = self.get_all_devices() self.send_ws_keyboard_list(open_devices) last_time = time.time() for num, device in enumerate(open_devices): try: event = device.read_one() except IOError: open_devices = self.get_all_devices() break if event: self.process_event(event, device) def read_keyboard(self): while True: self.connect_keyboard() try: for event in self.device.read_loop(): self.process_event(event) except IOError: if not self.args.silent: print('Device disconected!') def process_event(self, event, device=None): if event.type == evdev.ecodes.EV_KEY: key_event = evdev.categorize(event) package = { 'type': self.get_type(key_event), 'data': key_event.keycode } if device: package['device'] = {'file': device.fn, 'name': device.name} self.ws.emit('hardware_event', package) if not self.args.silent: print(self.get_type(key_event), key_event.keycode) if device: print(device.fn, device.name) def load_device_filename(self): with open(self.args.keyboard_config_file) as config: filename = config.read().replace('\n', '') return filename def get_type(self, key_event): if key_event.keystate == key_event.key_down: return 'DOWN' if key_event.keystate == key_event.key_up: return 'UP' if key_event.keystate == key_event.key_hold: return 'HOLD'
class SimplestConnectionEstablishmentPlayer(Locust): min_wait = 1000 max_wait = 1000 task_set = SimplestConnectionEstablishmentTaskSet def _init_sio_client(self): try: self.client = SocketIO( self.host, self.port, resource='sio', transports=['websocket'], params={ 'userid': self.player_id, 'roomid': self.room_id }, wait_for_connection=False # Disabling auto-reconnection. ) ''' The NodeJs server MUST be using `"socket.io": "1.7.2"` or an error complaining " ... socketIO_client.__init__, in _get_engineIO_session ... ... transport.recv_packet() ... " would be thrown here. ''' self.client.on('connect', self.on_connect) self.client.on('disconnect', self.on_disconnect) self.client.on('message', self.on_message) except ConnectionError: print( "SimplestConnectionEstablishmentPlayer instance for player.id == %s to room_id == %s. The sio-server is down, try again later." % (self.player_id, self.room_id)) raise GreenletExit() except KeyboardInterrupt: raise GreenletExit() def on_connect(self): print( 'SimplestConnectionEstablishmentPlayer instance for player.id == %s to room_id == %s, connected to sio-server.' % (self.player_id, self.room_id)) def on_disconnect(self): ''' A subtlety to be concerned here. ''' if (True == self.client._should_stop_waiting()): # If the execution reaches here by actively calling `self.client.disconnect()`, then one finds "True == self.client._should_stop_waiting() == self.client._wants_to_close". print( '[ACTIVELY DISCONNECTED] SimplestConnectionEstablishmentPlayer for player.id == %s to room_id == %s.' % (self.player_id, self.room_id)) raise StopLocust() # This is within the "main locust". else: # If the execution reaches here passively within `self.client.wait()`, then one finds "False == self.client._should_stop_waiting() == self.client._wants_to_close", and should help terminate the loop in the spawned `self.client.wait()`. See https://github.com/invisibleroads/socketIO-client/blob/master/socketIO_client/__init__.py for details (socketIO_client v0.7.2). print( '[PASSIVELY DISCONNECTED] SimplestConnectionEstablishmentPlayer for player.id == %s to room_id == %s.' % (self.player_id, self.room_id)) self.client._close() gevent.getcurrent().spawning_greenlet().kill() ''' Killing the current `gevent.Greenlet` instance silently. Quoted from http://www.gevent.org/api/gevent.greenlet.html#gevent.GreenletExit for "gevent v1.3.7.dev0". " A special exception that kills the greenlet silently. When a greenlet raises GreenletExit or a subclass, the traceback is not printed and the greenlet is considered successful. The exception instance is available under value property as if it was returned by the greenlet, not raised. " ''' raise GreenletExit( ) # This is within the "spawned greenlet from main locust". def on_message(self, *args): print( 'SimplestConnectionEstablishmentPlayer instance for player.id == %s to room_id == %s, on_message %s.' % (self.player_id, self.room_id, args)) def __init__(self, *args, **kwargs): ''' Note that `self.setup` will run within the immediately following invocation if "False == Locust._setup_has_run", see https://github.com/locustio/locust/blob/master/locust/core.py for details (Locust v0.9). ''' super(SimplestConnectionEstablishmentPlayer, self).__init__(*args, **kwargs) fp = baseoper.get_single_random_player() self.player_id = fp[0] self.room_id = fp[1] sio_server = baseoper.get_sio_server_host_port() self.host = sio_server[0] self.port = int(sio_server[1]) ''' The call to `self._init_sio_client()` SHOULDN'T be put into `"self.setup" or "Locust.setup"` which runs only once for "all locusts spawned by the current OS process", due to "Locust._setup_has_run" being a class-static-variable (unless otherwise hacked via `self._setup_has_run` which is unnecessary), see https://github.com/locustio/locust/blob/master/locust/core.py for details (Locust v0.9). Same argument holds for "Locust.teardown", "TaskSet.setup" and "TaskSet.teardown". ''' self._init_sio_client() def setup(self): print( "SimplestConnectionEstablishmentPlayer.setup completed. I'm called only once for all locusts (NOT `once per locust`) during the lifetime of the current OS process." ) def teardown(self): print( "SimplestConnectionEstablishmentPlayer all instances have been torn down. I'm called only once for all locusts (NOT `once per locust`) during the lifetime of the current OS process." )
class KeyboardReader(object): def __init__(self, args): self.args = args self.device = None self.ws = None signal.signal(signal.SIGTERM, self.__stop_app) signal.signal(signal.SIGINT, self.__stop_app) self.ws = SocketIO(args.hostname, args.port) if args.all_devices: self.read_all_keyboards() else: if args.device_filename: self.device_filename = args.device_filename else: self.device_filename = self.load_device_filename() self.read_keyboard() def connect_keyboard(self): while True: try: if not self.args.silent: print('Openning device {}...'.format(self.device_filename)) self.device = evdev.InputDevice(self.device_filename) break except OSError: if not self.args.silent: print('Can\'t open device. Waiting...') time.sleep(1) xinput.disable_device(self.device_filename) if not self.args.silent: print('Success!'.format(self.device_filename)) def __stop_app(self, signum, frame): print('Trap called, exiting...') if self.device: self.device.close() if self.ws: self.ws._close() xinput.trap_handler(signum, frame) sys.exit(0) def get_all_devices(self): keyboards = os.popen('readlink -f /dev/input/by-path/*kbd').read().split('\n') open_devices = [] for keyboard in keyboards: if not keyboard: continue try: device = evdev.InputDevice(keyboard) except OSError: continue try: open_device = evdev.InputDevice(device.fn) except OSError: continue open_devices.append(open_device) return open_devices def send_ws_keyboard_list(self, open_devices): keyboard_package = [ { 'file': keyboard.fn, 'name': keyboard.name } for keyboard in open_devices ] if not self.args.silent: print(keyboard_package) self.ws.emit('devices_list', { 'devices': keyboard_package }) def read_all_keyboards(self): open_devices = self.get_all_devices() last_time = 0 while True: if time.time() > last_time + 5: open_devices = self.get_all_devices() self.send_ws_keyboard_list(open_devices) last_time = time.time() for num, device in enumerate(open_devices): try: event = device.read_one() except IOError: open_devices = self.get_all_devices() break if event: self.process_event(event, device) def read_keyboard(self): while True: self.connect_keyboard() try: for event in self.device.read_loop(): self.process_event(event) except IOError: if not self.args.silent: print('Device disconected!') def process_event(self, event, device=None): if event.type == evdev.ecodes.EV_KEY: key_event = evdev.categorize(event) package = { 'type': self.get_type(key_event), 'data': key_event.keycode } if device: package['device'] = { 'file': device.fn, 'name': device.name } self.ws.emit('hardware_event', package) if not self.args.silent: print(self.get_type(key_event), key_event.keycode) if device: print(device.fn, device.name) def load_device_filename(self): with open(self.args.keyboard_config_file) as config: filename = config.read().replace('\n', '') return filename def get_type(self, key_event): if key_event.keystate == key_event.key_down: return 'DOWN' if key_event.keystate == key_event.key_up: return 'UP' if key_event.keystate == key_event.key_hold: return 'HOLD'
class WaptTestHost(object): def __init__(self,config_filename = 'c:/wapt/wapt-get.ini'): self.config_filename = config_filename self.config = WaptServiceConfig(config_filename) self.socketio_client = None self.wapt_remote_calls = None def run(self): self.config.reload_if_updated() with Wapt(config_filename = self.config.config_filename) as tmp_wapt: logger.info('Starting socketio on "%s://%s:%s" ...' % (self.config.websockets_proto,self.config.websockets_host,self.config.websockets_port)) logger.debug('Certificate checking : %s' % self.config.websockets_verify_cert) while True: try: if not self.socketio_client and self.config.websockets_host: logger.debug('Creating socketio client') logger.debug('Proxies : %s'%self.config.waptserver.proxies) # bug in socketio... ? we must not pass proxies at all (even None) if we don"t want to switch to polling mode... kwargs = {} if self.config.waptserver.proxies and self.config.waptserver.proxies.get(self.config.websockets_proto,None) is not None: kwargs['proxies'] = self.config.waptserver.proxies if not self.socketio_client: self.socketio_client = SocketIO( host="%s://%s" % (self.config.websockets_proto,self.config.websockets_host), port=self.config.websockets_port, Namespace = WaptSocketIORemoteCalls, verify=self.config.websockets_verify_cert, wait_for_connection = False, transport = ['websocket'], ping_interval = self.config.websockets_ping, hurry_interval_in_seconds = self.config.websockets_hurry_interval, params = {'uuid': tmp_wapt.host_uuid,'login':self.config.websockets_auth}, **kwargs) #self.socketio_client.get_namespace().wapt = tmp_wapt if self.socketio_client and self.config.websockets_host: if not self.socketio_client.connected: self.socketio_client._http_session.params.update({'uuid': tmp_wapt.host_uuid,'login':self.config.websockets_auth}) self.socketio_client.define(WaptSocketIORemoteCalls) #self.socketio_client.get_namespace().wapt = tmp_wapt self.socketio_client.connect('') if self.socketio_client.connected: logger.info('Socket IO listening for %ss' % self.config.websockets_check_config_interval ) self.socketio_client.wait(self.config.websockets_check_config_interval) self.config.reload_if_updated() except Exception as e: print('Error in socket io connection %s' % repr(e)) self.config.reload_if_updated() if self.socketio_client: print('stop sio client') self.socketio_client._close() del self.socketio_client self.socketio_client = None if self.socketio_client and self.config.websockets_host: self.socketio_client._http_session.params.update({'uuid': tmp_wapt.host_uuid,'login':self.config.websockets_auth}) logger.info('Socket IO Stopped, waiting %ss before retrying' % self.config.websockets_retry_delay) time.sleep(self.config.websockets_retry_delay)