def _init_websocket(self): if self.namespace is None: self.socket = socketIO_client.SocketIO(self.url) else: self.socket = socketIO_client.SocketIO(self.url, Namespace=self.namespace) self.socket.on('m', self._on_message) if self.sub_strings is not None: self.subscribe(sub_strings=self.sub_strings[:])
def run(stream_url, ores_url, metrics_collector, config, delay, notify, verbose): if verbose: log_level = logging.DEBUG else: log_level = logging.INFO logging.basicConfig( level=log_level, format='%(asctime)s %(levelname)s:%(name)s -- %(message)s') # Make requests and socketIO_client be quiet. They are very noisy. logging.getLogger("requests").setLevel(logging.WARNING) logging.getLogger("socketIO_client").setLevel(logging.ERROR) # SHUT UP! requests.packages.urllib3.disable_warnings() # If we're using logging for metrics collection, show it. logging.getLogger("ores.metrics_collectors").setLevel(logging.DEBUG) if not notify: logger.info('Not being ran as a service, watchdog disabled') score_on = build_score_on(config) RCNamespace = build_RCNamespace(stream_url, score_on, ores_url, MAX_WORKERS, metrics_collector, delay, notify) socketIO = socketIO_client.SocketIO(stream_url, 80) socketIO.define(RCNamespace, '/rc') try: socketIO.wait(seconds=sys.maxsize) except KeyboardInterrupt: print("Keyboard interrupt detected. Shutting down.") socketIO.disconnect()
def main(): global TOPIC global TS time.sleep(1) # take care of fast restarts # Configure ourselves TOKEN = os.getenv("APP_TOKEN") if TOKEN is None: sys.stderr.write("%s - Please set APP_TOKEN env variable\n" % datetime.datetime.today()) sys.exit(1) TOPIC = os.getenv("APP_TOPIC") if TOPIC is None: sys.stderr.write("%s - Please set APP_TOPIC env variable\n" % datetime.datetime.today()) sys.exit(1) # Set up our Timberslide client sys.stderr.write("%s - Connecting to timberslide\n" % datetime.datetime.today()) TS = Timberslide(TOKEN) TS.connect() # Start up the feed sys.stderr.write("%s - Starting\n" % datetime.datetime.today()) while 1: try: sys.stderr.write("%s - Connecting to wikimedia\n" % datetime.datetime.today()) socketIO = socketIO_client.SocketIO('https://stream.wikimedia.org') sys.stderr.write("%s - Setting up socketio namespace\n" % datetime.datetime.today()) socketIO.define(WikiNamespace, '/rc') sys.stderr.write("%s - In wait\n" % datetime.datetime.today()) socketIO.wait() except Exception as err: sys.stderr.write("%s - %s\n" % (datetime.datetime.today(), err)) time.sleep(1)
def start_and_wait(name, token, slurk_host, slurk_context, slurk_port, image_directory): """Start the game master bot.""" if slurk_port == "None": slurk_port = None if slurk_port: slurk_port = int(slurk_port) if image_directory == "None": image_directory = None if name == "None": avatar_name = AvatarBot.NAME else: avatar_name = AvatarBot.NAME + "-" + name custom_headers = {"Authorization": token, "Name": avatar_name} socket_url = build_url(slurk_host, slurk_context) print("Try to connect to: ", socket_url) sio = socketIO_client.SocketIO(socket_url, slurk_port, headers=custom_headers, Namespace=AvatarBot) # NOTE: YOU SHOULD REFERENCE YOUR MODEL HERE avatar_model = SimpleAvatar(image_directory) sio.get_namespace().set_agent(avatar_model) print("Connected and everything set. Waiting for incoming traffic...") sio.wait()
def __init__(self, sio_host, sio_port, player_num): super(SIORacket, self).__init__() # Save parameters self.sio_host = sio_host self.sio_port = sio_port self.player_num = player_num # socketio config self._sio = sio.SocketIO(self.sio_host, self.sio_port) # socketio callbacks # Basic self._sio.on('connect', self.on_sio_connect) self._sio.on('disconnect', self.on_sio_disconnect) # Game-based - Listening self._sio.on('init_color_reject', self.on_sio_init_color_reject) self._sio.on('init_color_confirm', self.on_sio_init_color_confirm) self._sio.on('game_is_server', self.on_sio_game_is_server) self._sio.on('game_missed_ball', self.on_sio_game_missed_ball) self._sio.on('game_hit_ball', self.on_sio_game_hit_ball) self._sio.on('game_won_rally', self.on_sio_game_won_rally) self._sio.on('game_over', self.on_sio_game_over) print 'socketio: init' # Other parameters self.state = GameState.COLOR_SELECTION self.state_data = None self.color_choice = None self.enable_swings = False print 'racket: init'
def __init__(self, server='localhost', port='8000', options=None): """ Connect to server with given game name, id and player id. Request initial synchronization. """ opts = { 'game_name': 'default', 'game_id': 'default', 'player_id': '1', 'num_players': 2 } opts.update(options or {}) self.game_id = opts['game_name'] + ':' + opts['game_id'] self.player_id = opts['player_id'] self.num_players = opts['num_players'] # open websocket socket = io.SocketIO(server, port, wait_for_connection=False) self.io_namespace = socket.define(Namespace, '/' + opts['game_name']) self.io_namespace.set_bot_info(self) self.socket = socket # request initial sync self.io_namespace.emit('sync', self.game_id, self.player_id, self.num_players)
def listen_on_watch_queue(self, wq, result_callback=None, error_callback=None): """\ Listen to the various messages of a currently running submission's watch queue Required: wq : ID of the watch queue to listen for result_callback : Callback function when receiveing a result cache key error_callback : Callback function when receiveing a error cache key This function wait indefinitely and calls the appropriate callback for each messages returned """ if result_callback is None and error_callback is None: raise ClientError("At least one of the callbacks needs to be defined...", 400) self._sio = socketIO_client.SocketIO(self._server, port=self._port, headers=self._header, verify=False) self._stop_on_warning.set_sio(self._sio) if result_callback: self._sio.on("cachekey", result_callback) if error_callback: self._sio.on("cachekeyerr", error_callback) self._sio.on("stop", self._stop_callback) self._sio.on("error", self._error_callback) self._sio.emit('listen', {"status": "start", "client": "assemblyline_client", "wq_id": wq, 'from_start': True}) self._sio.wait()
def listen_on_dashboard_messages(self, dispatcher_msg_callback=None, ingest_msg_callback=None, service_msg_callback=None): """\ Listen to the various messages you would find on the UI dashboard. Required (one of): dispatcher_msg_callback : Callback function when a dispatcher message is received ingest_msg_callback : Callback function when a ingest message is received service_msg_callback : Callback function when a service message is received This function wait indefinitely and calls the appropriate callback for each messages returned """ if dispatcher_msg_callback is None and ingest_msg_callback is None and service_msg_callback is None: raise ClientError("At least one of the callbacks needs to be defined...", 400) self._sio = socketIO_client.SocketIO(self._server, port=self._port, headers=self._header, verify=False) self._stop_on_warning.set_sio(self._sio) if dispatcher_msg_callback: self._sio.on("DispHeartbeat", dispatcher_msg_callback) if ingest_msg_callback: self._sio.on("IngestHeartbeat", ingest_msg_callback) if service_msg_callback: self._sio.on("SvcHeartbeat", service_msg_callback) self._sio.emit('monitor', {"status": "start", "client": "assemblyline_client"}) self._sio.wait()
def run(self) -> None: print(self.username + ': Loading Bot AI') print(self.username + ': Loaded ' + self.botCls.BOT_NAME) # type: ignore self.conn = socketIO_client.SocketIO('keldon.net', 32221) self.conn.on('message', self.on_message) print(self.username + ': Connected to keldon.net') passBytes = b'Hanabi password ' + self.password.encode() passSha: str passSha = hashlib.sha256(passBytes).hexdigest() try: login: dict = {'username': self.username, 'password': passSha} self.conn.emit('message', {'type': 'login', 'resp': login}) while currentTableId is None: self.conn.wait(seconds=1) d = {'type': 'join_table', 'resp': {'table_id': currentTableId}} self.conn.emit('message', d) self.conn.wait(seconds=1) assert currentTableId is not None self.conn.wait(seconds=1) while self.game is None: self.conn.wait(seconds=waitTime) while self.game is not None: self.conn.wait(seconds=waitTime) finally: self.conn.disconnect() print(self.username + ': Ended')
def __init__(self): super(GATDSource, self).__init__() socketio_host = self.params['socketio_host'] socketio_port = self.params['socketio_port'] socketio_namespace = self.params['socketio_namespace'] query = self.params['query'] class stream_receiver(sioc.BaseNamespace): self.buffer = [] def on_reconnect (self): if 'time' in query: del query['time'] stream_namespace.emit('query', query) def on_connect (self): stream_namespace.emit('query', query) def on_data (self, *args): pkt = args[0] self.buffer.append(str(pkt)) stream_receiver.buffer = self.receive_buffer socketIO = sioc.SocketIO(socketio_host, socketio_port) stream_namespace = socketIO.define(stream_receiver, '/{}'.format(socketio_namespace)) socketIO.wait()
def __init__(self, wikihost, rchost, rcport=80, rcpath='/rc', total=None): """Constructor for RcListenerThread.""" super(RcListenerThread, self).__init__() self.rchost = rchost self.rcport = rcport self.rcpath = rcpath self.wikihost = wikihost self.daemon = True self.running = False self.queue = Queue() self.warn_queue_length = 100 self.total = total self.count = 0 import socketIO_client debug('Opening connection to %r' % self, _logger) self.client = socketIO_client.SocketIO(rchost, rcport) thread = self class RCListener(socketIO_client.BaseNamespace): def on_change(self, change): debug('Received change %r' % change, _logger) if not thread.running: debug('Thread in shutdown mode; ignoring change.', _logger) return thread.count += 1 thread.queue.put(change) if thread.queue.qsize() > thread.warn_queue_length: warning('%r queue length exceeded %i' % (thread, thread.warn_queue_length), _logger=_logger) thread.warn_queue_length = thread.warn_queue_length + 100 if thread.total is not None and thread.count >= thread.total: thread.stop() return def on_connect(self): debug( 'Connected to %r; subscribing to %s' % (thread, thread.wikihost), _logger) self.emit('subscribe', thread.wikihost) debug('Subscribed to %s' % thread.wikihost, _logger) def on_reconnect(self): debug('Reconnected to %r' % (thread, ), _logger) self.on_connect() class GlobalListener(socketIO_client.BaseNamespace): def on_heartbeat(self): self._transport.send_heartbeat() self.client.define(RCListener, rcpath) self.client.define(GlobalListener)
def socketio(self): socketIO = sioc.SocketIO(self.SOCKETIO_HOST, self.SOCKETIO_PORT) stream_namespace = socketIO.define( self.stream_receiver, '/{}'.format(self.SOCKETIO_NAMESPACE)) stream_namespace.emit('query', { 'profile_id': self.MONJOLO_PID, 'type': 'coilcube_raw' }) socketIO.wait()
def run_update(): socketIO = socketIO_client.SocketIO('https://streamer.cryptocompare.com') socketIO.on('connect', on_connect) socketIO.on('disconnect', on_disconnect) socketIO.on('m', on_subadd_response) subs = [] for coin in list_coins: for exchange in list_exchanges: current = '2~' + exchange + '~' + coin + '~' + 'USD' subs.append(current) socketIO.emit('SubAdd',{ 'subs': subs}) socketIO.wait()
def run(self): while True: try: socketIO = sioc.SocketIO(self.SOCKETIO_HOST, self.SOCKETIO_PORT) self.stream_namespace = socketIO.define( StreamReceiver, '/{}'.format(self.SOCKETIO_NAMESPACE)) self.stream_namespace.set_data(self.query, self.data_type, self.message_queue, self.stream_namespace) socketIO.wait() except sioc.exceptions.ConnectionError: # ignore error and continue socketIO.disconnect()
def listen_on_submissions_ingested(self, submission_callback): """\ Listen to the various submission ingested messages in the system and call the callback for each of them Required: submission_callback : Callback function for when submission ingested messages are received This function wait indefinitely and calls the appropriate callback for each messages returned """ self._sio = socketIO_client.SocketIO(self._server, port=self._port, headers=self._header, verify=False) self._stop_on_warning.set_sio(self._sio) self._sio.on("SubmissionIngested", submission_callback) self._sio.emit('submission', {"status": "start", "client": "assemblyline_client"}) self._sio.wait()
def listen_on_alerts_created(self, alert_callback): """\ Listen to the various alerts created messages in the system and call the callback for each alerts Required: alert_callback : Callback function for when alerts created messages are received This function wait indefinitely and calls the appropriate callback for each messages returned """ self._sio = socketIO_client.SocketIO(self._server, port=self._port, headers=self._header, verify=False) self._stop_on_warning.set_sio(self._sio) self._sio.on("AlertCreated", alert_callback) self._sio.emit('alert', {"status": "start", "client": "assemblyline_client"}) self._sio.wait()
def run(self) -> None: print(self.username + ': Loading Bot AI') print(self.username + ': Loaded ' + self.botCls.BOT_NAME) # type: ignore self.conn = socketIO_client.SocketIO('keldon.net', 32221) self.conn.on('message', self.on_message) print(self.username + ': Connected to keldon.net') passBytes = b'Hanabi password ' + self.password.encode() passSha: str passSha = hashlib.sha256(passBytes).hexdigest() d: dict try: login: dict = {'username': self.username, 'password': passSha} self.conn.emit('message', {'type': 'login', 'resp': login}) self.conn.wait(seconds=1) try: d = {'type': 'create_table', 'resp': {'name': gameName, 'max': self.numPlayers, 'variant': self.variant.value, 'allow_spec': spectators}} self.conn.emit('message', d) self.conn.wait(seconds=1) assert currentTableId is not None while (not terminate and not self.readyToStart and len(self.tablePlayers) != self.numPlayers): self.conn.wait(seconds=1) except: self.conn.emit('message', {'type': 'leave_table', 'resp': {}}) return self.conn.emit('message', {'type': 'start_game', 'resp': {}}) while self.game is None: self.conn.wait(seconds=waitTime) while self.game is not None: self.conn.wait(seconds=waitTime) finally: self.conn.disconnect() print(self.username + ': Ended')
def start(): try: thread = Thread(target=socketio.run, args=(app, )) thread.start() socket = socketIO_client.SocketIO('https://streamer.cryptocompare.com') socket.emit( 'SubAdd', { 'subs': [ '5~CCCAGG~XRP~BTC', '5~CCCAGG~ETH~BTC', '5~CCCAGG~NEO~BTC', '5~CCCAGG~LTC~BTC', '5~CCCAGG~NEO~ETH', '5~CCCAGG~XRP~ETH', '5~CCCAGG~ETH~LTC' ] }) socket.on('m', on_m_response) socket.wait() except: logging.warning('The server is down. Restarting in 10 seconds.') time.sleep(10) start()
async def get_balance(self, loop, address, token, callback=None): io = socketIO_client.SocketIO(self._URL) future = loop.create_future() io.once('addressInfo', lambda _data: future.set_result(_data)) io.emit('start', {'type': "address", 'address': address}) elapsed = 0 while not future.done(): try: io.wait(seconds=1) elapsed += 1 if elapsed == self._timeout: raise TimeoutError except Exception as e: logger.error('Could not fetch byteball balance:', e) return token, 0 response = await future decimals = self._decimals.get(token, 0) amount = float(response.get('objBalance').get('bytes')) / (10** decimals) if callback is not None: callback(token, amount) return token, amount
def __init__(self, task_configuration, wsclient_addr, logfile): """ Worker Service client, that uses socketIO_client library to communicate with Worker Service: send task and get results (communication based on events). :param task_configuration: Dictionary. Represents "TaskConfiguration" of BRISE configuration file. :param wsclient_addr: String. Network address of Worker Service (including port). :param logfile: String. Path to file, where Worker Service Client will store results of each experiment. """ self.logger = logging.getLogger(__name__) # Creating the SocketIO object and connecting to main node namespace - "/main_node" self.logger.info("INFO: Connecting to the Worker Service at '%s' ..." % wsclient_addr) # Configuring logging for SocketIO client [logging.getLogger('socketIO-client').addHandler(handler) for handler in logging.getLogger().handlers] self.socketIO = socketIO_client.SocketIO(wsclient_addr) self.socketIO.define(socketIO_client.LoggingSocketIONamespace, "/main_node") self.servername = wsclient_addr # Properties that holds general task configuration (shared between task runs). self._exp_config = task_configuration self._task_name = task_configuration["TaskName"] self._task_parameters = task_configuration["TaskParameters"] self._result_structure = task_configuration["ResultStructure"] self._result_data_types = task_configuration["ResultDataTypes"] self._scenario = task_configuration["Scenario"] self._time_for_one_task_running = task_configuration["MaxTimeToRunTask"] if "MaxTimeToRunTask" in task_configuration else float("inf") self._log_file_path = logfile self._number_of_workers = 0 self._got_ping_response = False # Properties that holds current task data. self.cur_tasks_ids = [] self.current_results = [] # Defining events that will be processed by the Worker Service Client. self.socketIO.on("ping_response", self.__ping_response, path="/main_node") self.socketIO.on("task_accepted", self.__task_accepted, path="/main_node") self.socketIO.on("wrong_task_structure", self.__wrong_task_structure, path="/main_node") self.socketIO.on("task_results", self.__task_results, path="/main_node") self.connect()
def start_and_wait(token, slurk_host, slurk_context, slurk_port, image_server_host, image_server_context, image_server_port, image_server_auth): print("Start the game master bot.") if slurk_port == "None": slurk_port = None if slurk_port: slurk_port = int(slurk_port) if image_server_port == "None": image_server_port = None if image_server_port: image_server_port = int(image_server_port) if image_server_auth == "None": image_server_auth = None custom_headers = {"Authorization": token, "Name": GameMaster.NAME} socket_url = build_url(slurk_host, slurk_context) print("Try to connect to: ", socket_url) sio = socketIO_client.SocketIO(socket_url, slurk_port, headers=custom_headers, Namespace=GameMaster) image_url = build_url(image_server_host, image_server_context, image_server_port) sio.get_namespace().set_base_image_url(image_url) if image_server_auth: # encode as base64, but keep as string print("Setting image server auth: ", image_server_auth) image_server_auth = base64.b64encode( image_server_auth.encode("utf-8")).decode("utf-8") sio.get_namespace().set_image_server_auth(image_server_auth) print("Connected and everything set. Waiting for incoming traffic...") sio.wait()
def __init__(self, server='localhost', port='8000', game_name='default', game_id='default', player_id='1', num_players=2): """ Connect to server with given game name, id and player id. Request initial synchronization. """ self.game_id = game_name + ':' + game_id self.player_id = player_id self.num_players = num_players # open websocket socket = io.SocketIO(server, port, wait_for_connection=False) self.io_namespace = socket.define(Namespace, '/' + game_name) self.io_namespace.set_bot_info(self) self.socket = socket # request initial sync self.io_namespace.emit('sync', self.game_id, player_id, self.num_players)
def kitConnectSocket(host, port, args): kitConsole('connecting sockets(host={}, port={}, args={})'.format( host, port, args)) connection = socketIO_client.SocketIO(host=host, port=port, params=args) kitConsole('socket connected.') return connection
def drop_connection(): socketIO = socketIO_client.SocketIO('https://streamer.cryptocompare.com') socketIO.emit('SubRemove') socketIO.wait(1)
def __init__(self, host="localhost", port=9000): self.socket = socketIO_client.SocketIO(host, port)
logging.basicConfig() SOCKETIO_HOST = 'inductor.eecs.umich.edu' SOCKETIO_PORT = 8082 SOCKETIO_NAMESPACE = 'stream' query = {'profile_id': 'HthZRrHnlC', 'time': 2000000} pp = pprint.PrettyPrinter(indent=4) class stream_receiver (sioc.BaseNamespace): def on_reconnect (self): del query['time'] stream_namespace.emit('query', query) def on_connect (self): stream_namespace.emit('query', query) def on_data (self, *args): pkt = args[0] pp.pprint(pkt) socketIO = sioc.SocketIO(SOCKETIO_HOST, SOCKETIO_PORT) stream_namespace = socketIO.define(stream_receiver, '/{}'.format(SOCKETIO_NAMESPACE)) #stream_namespace.emit('query', query) socketIO.wait()
def _run_event_thread(self): class Namespace(socketIO_client.BaseNamespace): """Class top allow socket_io error callbacks.""" def on_disconnect(inner_self): # pylint: disable=no-self-argument if self.thread_exit: return if self.connected_ok: self.reconnect_needed = True return LOG.error('Could not connect to https://www.your-loop.com') LOG.error('Please check your keys are correct. Terminating') self.terminate() LOG.info('Started LoopEnergy thread') while not self.thread_exit: try: if self.reconnect_needed: LOG.warning('Retrying socket connection') else: LOG.info('Opening socket connection') with socketIO_client.SocketIO(LOOP_SERVER, LOOP_PORT, Namespace) as socket_io: self.reconnect_needed = False socket_io.on('electric_realtime', self._update_elec) socket_io.on('gas_interval', self._update_gas) socket_io.emit( 'subscribe_electric_realtime', { 'serial': self.elec_serial, 'clientIp': '127.0.0.1', 'secret': self.elec_secret }) if self.gas_serial is not None: socket_io.emit( 'subscribe_gas_interval', { 'serial': self.gas_serial, 'clientIp': '127.0.0.1', 'secret': self.gas_secret }) intervals_without_update = 0 while not (self.thread_exit or self.reconnect_needed): self.updated_in_interval = False socket_io.wait(seconds=WAIT_BEFORE_POLL) if self.updated_in_interval: intervals_without_update = 0 else: intervals_without_update += 1 time_without_update = (intervals_without_update * WAIT_BEFORE_POLL) if time_without_update > RECONNECT_AFTER: self.reconnect_needed = True LOG.warning('No updates for %s - reconnecting', RECONNECT_AFTER) LOG.debug('LoopEnergy thread poll') except (ValueError, AttributeError, socketIO_client.exceptions.SocketIOError, requests.exceptions.RequestException) as ex: # Looks like ValueError comes from an # invalid HTTP packet return # Looks like AttributeError comes from a # failed SSL connection LOG.warning('Exception (will try to reconnect) - %s', ex) self.reconnect_needed = True LOG.info('Exiting LoopEnergy thread')
import socketIO_client import time import threading import os import pty import subprocess io = socketIO_client.SocketIO('witcoin.ru', 4000) io.emit('auth', 'test3') master, slave = pty.openpty() if not os.path.exists('tmp'): os.mkdir('tmp') videoPipeName = 'tmp/video.avi' if not os.path.exists(videoPipeName): os.mkfifo(videoPipeName) def send_video(): video_in = os.open(videoPipeName, os.O_RDONLY) while True: data = os.read(video_in, 10000) if len(data): io.emit('video.data', bytearray(data)) threading.Thread(target=send_video).start() def send_console(): while True:
def main(): global LOCATION global stream_namespace global usage SOCKETIO_HOST = 'gatd.eecs.umich.edu' SOCKETIO_PORT = 8082 SOCKETIO_NAMESPACE = 'stream' LOCATION = "" #Get this as a system argument DOOR_TRIGGERED = False #Get this as a system argument try: door_sensors = get_door_locations() except urllib2.URLError: print("Connection to inductor unavailable. Running in test mode") LOCATION = 'test' # get location if not LOCATION: if len(sys.argv) != 2: print(USAGE) index = 0 for sensor_loc in door_sensors: print(" [" + str(index) + "]: " + sensor_loc) index += 1 print("") user_input = raw_input("Select a location or enter a new one: ") if user_input == '': print("Invalid selection") exit() if user_input.isdigit(): user_input = int(user_input) if 0 <= user_input < index: LOCATION = door_sensors[user_input] else: print("Invalid selection") exit() else: LOCATION = user_input else: LOCATION = sys.argv[1] if LOCATION == 'test': print('Scanning for fitbits...') test = FitbitMonitor() present_fitbits = test.get_present_fitbits() for key in present_fitbits.keys(): print(str(key) + ' : ' + str(present_fitbits[key])) exit() print("Running fitbitfinder at " + LOCATION) # also start periodic polling print("\nStarting polling monitor") PollingMonitor(10 * 60) # poll every 10 mins + time to find devices # if location has door sensor, trigger on it as well for sensor_loc in door_sensors: if sensor_loc == LOCATION: DOOR_TRIGGERED = True query['location_str'] = LOCATION # door/gatd triggered logic if DOOR_TRIGGERED: print("\nStarting door-triggered monitor") socketIO = sioc.SocketIO(SOCKETIO_HOST, SOCKETIO_PORT) stream_namespace = socketIO.define(EventDrivenMonitor, '/{}'.format(SOCKETIO_NAMESPACE)) socketIO.wait() # loop forever while polling and possibly door callbacks are occurring while (True): pass
def __init__(self, host="localhost", port=80): print "SIO", host, port self.sio = socketIO_client.SocketIO(host, port) self.sio.on("periscope", self.onPeriscopeResponse) self.sio.on("chat", self.onChatResponse)