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)
