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)
