def start(self):
super().start()
if self.polling_interval().total_seconds() > 0:
self._poll_job = Job(self.poll, self.polling_interval(), True)
spawn(self.poll)
else:
self.logger.info("No poll job")
def connect(self):
connecting_to = []
for addr in self._configs:
if addr not in self._tags:
connecting_to.append(addr)
spawn(self._connect_tag, self._configs[addr])
return connecting_to
def _connect_tag(self, cfg, read_on_connect=False):
addy = cfg["address"]
name = cfg["name"]
try:
self.logger.info("Push {} side button NOW".format(name))
self.logger.info("Connecting to device {}".format(addy))
self._notify_status_signal('Connecting', addy)
tag = SensorTag(addy)
self._enable_sensors(addy, tag)
# Save the tag to the list after connection and sensors enabled.
self._tags[addy] = tag
except Exception as e:
self.logger.exception(
"Failed to connect to {} ({}). Retrying...".format(name, addy))
self._notify_status_signal('Retrying', addy)
# Make sure to remove tag if connect fails
self._tags.pop(addy, None)
sleep(5)
self._connect_tag(cfg)
else:
self.logger.info("Connected to device {}".format(addy))
self._notify_status_signal('Connected', addy)
self._read_counter = 0
if cfg["sensors"].get('keypress', False):
self.logger.info(
"Enabling notification listening for keypress")
spawn(self._listen_for_notifications, addy)
if read_on_connect:
self.logger.debug(
"Reading from sensors on reconnect")
self._read_from_tag(addy)
def connect(self):
connecting_to = []
for addr in self._configs:
if addr not in self._tags:
connecting_to.append(addr)
spawn(self._connect_tag, self._configs[addr])
return connecting_to
def _connect_tag(self, cfg, read_on_connect=False):
addy = cfg["address"]
name = cfg["name"]
try:
self.logger.info("Push {} side button NOW".format(name))
self.logger.info("Connecting to device {}".format(addy))
self._notify_status_signal('Connecting', addy)
tag = SensorTag(addy)
self._enable_sensors(addy, tag)
# Save the tag to the list after connection and sensors enabled.
self._tags[addy] = tag
except Exception as e:
self.logger.exception(
"Failed to connect to {} ({}). Retrying...".format(name, addy))
self._notify_status_signal('Retrying', addy)
# Make sure to remove tag if connect fails
self._tags.pop(addy, None)
sleep(5)
self._connect_tag(cfg)
else:
self.logger.info("Connected to device {}".format(addy))
self._notify_status_signal('Connected', addy)
self._read_counter = 0
if cfg["sensors"].get('keypress', False):
self.logger.info(
"Enabling notification listening for keypress")
spawn(self._listen_for_notifications, addy)
if read_on_connect:
self.logger.debug(
"Reading from sensors on reconnect")
self._read_from_tag(addy)
def register_request(self, timeout):
""" Register a request in a new thread and return the ID and resp """
req_id = str(uuid4())
mock_rsp = self.get_mocked_response()
mock_req = self.get_mocked_request()
RequestResponseBroker.register_request(
req_id, mock_req, mock_rsp, timeout)
spawn(RequestResponseBroker.wait_for_response, req_id)
return req_id, mock_rsp
def start(self):
super().start()
self._authorize()
self._start()
spawn(self._run_stream)
self._notify_job = Job(
self._notify_results,
self.notify_freq(),
True
)
def start(self):
super().start()
if self.polling_interval().total_seconds() > 0:
self._poll_job = Job(
self.poll,
self.polling_interval(),
True
)
spawn(self.poll)
else:
self.logger.info("No poll job")
def _place_calls(self, signal):
try:
msg = self.message(signal)
msg_id = uuid4().hex
self._messages[msg_id] = msg
for rcp in self.recipients():
spawn(target=self._call, recipient=rcp, message_id=msg_id)
except Exception as e:
self.logger.error(
"Message evaluation failed: {0}: {1}".format(
type(e).__name__, str(e))
)
def _place_calls(self, signal):
try:
msg = self.message(signal)
msg_id = uuid4().hex
self._messages[msg_id] = msg
for rcp in self.recipients():
spawn(target=self._call, recipient=rcp, message_id=msg_id)
except Exception as e:
self.logger.error(
"Message evaluation failed: {0}: {1}".format(
type(e).__name__, str(e))
)
def before_retry(self, *args, **kwargs):
self.logger.warning('Failed to send {}, reconnecting'.format(args))
self._main_thread.join(1)
if self._conn:
self._cleanup()
self._connect()
self._main_thread = spawn(self._receive)
def start(self):
self._main_thread = spawn(self._server)
self.logger.debug('server started on localhost:{}'.format(self.port()))
self.data = self.data_dict_to_data_list(self.data_dict)
figure = {'data': self.data, 'layout': {'title': self.title()}}
app_layout = [
dcc.Graph(id=self.title(), figure=figure),
dcc.Interval(id='interval-component', interval=self.update_interval() * 1000)
]
self.app.layout = html.Div(app_layout)
@self.app.callback(Output(self.title(), 'figure'),
events=[Event('interval-component', 'interval')])
def update_graph_live():
return {'data': self.data, 'layout': {'title': self.title()}}
@self.app.server.route('/shutdown', methods=['GET'])
def shutdown():
shutdown_server()
return 'OK'
def shutdown_server():
func = request.environ.get('werkzeug.server.shutdown')
if func is None:
self.logger.warning('Not running with the Werkzeug Server')
func()
super().start()
def test_table_lock(self, put_func, count_func, create_func, connect_func):
""" Make sure that if a table is creating it locks """
# We should return the error that the table is not found.
# We should only see this error returned once though, subsequent calls
# should use the cached version of the table.
count_func.side_effect = [
JSONResponseError(
400,
"{'message': 'Requested resource not found: Table: T notfound', "
"'__type': 'com.amazonaws.dynamodb.v20120810"
"#ResourceNotFoundException'}")
]
blk = SaveCounterDynamoDB()
self.configure_block(blk, {'log_level': 'DEBUG', 'hash_key': 'hash'})
# Simulate a table that is creating for a while
blk._get_table_status = MagicMock(
side_effect=['CREATING', 'CREATING', 'ACTIVE'])
# Send two threads to process signals at once
spawn(blk.process_signals, [Signal({'hash': 'value1'})])
spawn(blk.process_signals, [Signal({'hash': 'value2'})])
# We shouldn't have any save calls until the table creates.
# That takes 1.5 seconds, so let's see what we have after some of that.
sleep(0.7)
self.assertEqual(blk._count, 0)
# Give the table time to create...
sleep(1)
# Make sure the table create function only gets called once. This
# should happen due to the presence of the lock around _get_table
self.assertEqual(create_func.call_count, 1)
# Ok, it's created, we should see both signals get saved
self.assertEqual(blk._count, 2)
def _tcp_server(self):
self.logger.debug('started server thread')
buffer_size = 1024
with socket.socket(socket.AF_INET, socket.SOCK_STREAM) as s:
s.bind((self.host(), self.port()))
s.listen(1)
while not self._kill:
self.logger.debug('listening for connections')
conn, addr = s.accept()
host = addr[0]
# keep track of all accepted connections
if host not in self._connections:
# new connection
self._connections[host] = conn
else:
# the address has already been connected to, and it never
# closed itself (likely due to power loss).
# Tear down the old connection and make a new one on the
# same address
# closing the connection should cause the thread used by
# that connection to exit
self.logger.debug('Accepted a connection from an address '
'already in use: {}, closing connection '
'object: {}'.format(
host, self._connections[host]))
self._connections[host].close()
try:
self._recv_threads[host].join()
except:
self.logger.debug('recv thread already exited before '
'join')
self._connections[host] = conn
self.logger.debug('{} connected'.format(addr))
recv_thread = spawn(self._recv, conn, addr, buffer_size)
self._recv_threads[host] = recv_thread
def start(self):
self._main_thread = spawn(self._server)
self.logger.debug('server started on localhost:8050')
super().start()
self.data_dict = {
s.name(): {'x': [], 'y': [], 'name': s.name()}
for s in self.graph_series()
}
self.data = self.data_dict_to_data_list(self.data_dict)
figure = {'data': self.data, 'layout': {'title': self.title()}}
app_layout = [
dcc.Graph(id=self.title(), figure=figure),
dcc.Interval(id='interval-component', interval=1 * 1000)
]
self.app.layout = html.Div(app_layout)
@self.app.callback(Output(self.title(), 'figure'),
events=[Event('interval-component', 'interval')])
def update_graph_live():
return {'data': self.data, 'layout': {'title': self.title()}}
def start(self):
super().start()
self._main_thread = spawn(self._tcp_server)
def start(self):
super().start()
if self._server:
spawn(self._server.serve_forever)
else:
self.logger.warning("Server did not exist, so it was not started")
def _reconnect(self, addy, read_on_connect=True):
spawn(self._reconnect_thread, addy, read_on_connect)
def _reconnect(self):
self.logger.debug(
'Attempting reconnect in {} seconds'.format(self._reconnect_delay))
sleep(self._reconnect_delay)
self._reconnect_delay *= 2
spawn(self._connect)
def start(self):
super().start()
# start gathering messages
self._stop_message_loop_event = Event()
self._message_loop_thread = spawn(self._receive_messages)
def start(self):
super().start()
if self._server:
spawn(self._server.serve_forever)
else:
self.logger.warning("Server did not exist, so it was not started")
def start(self):
super().start()
self._connect_thread = spawn(self._connect_gage)
def _reconnect(self):
self.logger.debug('Attempting reconnect in {} seconds'.format(
self._reconnect_delay))
sleep(self._reconnect_delay)
self._reconnect_delay *= 2
spawn(self._connect)
def _reconnect(self, addy, read_on_connect=True):
spawn(self._reconnect_thread, addy, read_on_connect)
def start(self):
super().start()
self._connect()
self._main_thread = spawn(self._receive)
