def add_device(self,device):
"""
Add a new device, regardless of its connection status
"""
# TODO set status to connected/disconnected on device creation Yann?
status = device.get("statusInfo")
if status:
if status.get("status") == "ONLINE":
logger.info("'{}' is online trying to add ...".format(device.get("label")))
device_type_json_formatted = self.get_device_type_json(device)
found_on_platform, device_type_patform_id = self.get_platform_id(device_type_json_formatted)
logger.info("device type " + json.loads(device_type_json_formatted).get("name") + " found on platform? " + str(found_on_platform))
# if platform id exists then the device type was created already
if found_on_platform:
logger.info("found device type: " + str(device_type_patform_id))
else:
# device_type_patform_id = self.create_type_on_platform(device_type_json_formatted)
logger.info("generated device type: " + str(device_type_patform_id))
if device_type_patform_id:
formatted_device = self.format(device, device_type_patform_id)
Client.add(formatted_device)
logger.info("added new device")
else:
logger.info("'{}' is offline - no further action".format(device.get("label")))
def render_POST(self, request):
logger.info("RD: POST to /rd from {host}:{port}".format(
host=request.source[0], port=request.source[1]))
print(request.pretty_print())
logger.info("RD: Payload: {payload}".format(payload=request.payload))
res = RDResource()
if request.payload:
informations = {
"host": request.source[0],
"port": request.source[1],
"query_parameters":
request_helper.get_query_parameter(request),
"links": core_link_format_helper.parse_links(request.payload),
}
ep = informations.get("query_parameters").get("ep")
if not DB.DB.endpoint_exists(ep): # todo check ip change
DB.DB.create(informations)
logger.info(
'RD: Endpoint not found -> created in local db and register on platform'
)
id = DB.DB.get_endpoint_id(ep)
device = DB.DB.get(id)
res.location_path = "/rd/{id}".format(
id=id) # todo nicht da in respone
Client.add(device)
else:
logger.info("RD: Endpoint exists -> return found id")
# todo reconnect by Client.add() ?
res.location_path = "/rd/" + str(DB.DB.get_endpoint_id(ep))
return res
def _evaluate(self, unknown_devices, init):
missing_devices, new_devices, changed_devices = self._diff(__class__._known_devices, unknown_devices)
if missing_devices:
for missing_device_id in missing_devices:
logger.info("can't find '{}' with id '{}'".format(__class__._known_devices[missing_device_id].get('name'), missing_device_id))
del __class__.bridge_map[missing_device_id]
if init:
DevicePool.remove(missing_device_id)
else:
Client.disconnect(missing_device_id)
if new_devices:
for new_device_id in new_devices:
name = unknown_devices[new_device_id].get('name')
logger.info("found '{}' with id '{}'".format(name, new_device_id))
__class__.bridge_map[new_device_id] = (unknown_devices[new_device_id].get('LIGHT_KEY'), Converter(get_light_gamut(unknown_devices[new_device_id].get('modelid'))))
device = Device(new_device_id, SEPL_DEVICE_TYPE, name)
device.addTag('type', unknown_devices[new_device_id].get('type'))
device.addTag('manufacturer', unknown_devices[new_device_id].get('manufacturername'))
if init:
DevicePool.add(device)
else:
Client.add(device)
if changed_devices:
for changed_device_id in changed_devices:
device = DevicePool.get(changed_device_id)
name = unknown_devices[changed_device_id].get('name')
if not name == device.name:
device.name = name
if init:
DevicePool.update(device)
else:
Client.update(device)
logger.info("name of '{}' changed to {}".format(changed_device_id, name))
__class__._known_devices = unknown_devices
def ping(self, device_id):
response = self.openhab_api_manager.get_thing(device_id)
status = response.get("statusInfo")
if status:
if status.get("status") == "OFFLINE":
Client.disconnect(device_id)
elif status == "ONLINE":
device = device_pool.DevicePool.get(device_id)
Client.add(device)
def __on_connect(self, client, userdata, flags, rc):
if rc == 0:
logger.info("connected to broker '{}' on '{}'".format(self.ip_address, self.port))
self.mqtt_c.subscribe("{0}/{1}/status/current".format(self.device.product_type, self.device.id))
try:
Client.add(self.device)
except AttributeError:
DevicePool.add(self.device)
self.__requestDeviceStates()
self.device_sensor_request.start()
else:
logger.error("could not connect to broker '{}' on '{}' - reason '{}'".format(self.ip_address, self.port, rc))
def handle_mutlicast_responses(self, response):
print(response.pretty_print())
if not DB.DB.host_exists(response.source[0]): # todo check ip change
informations = {
"host": response.source[0],
"port": response.source[1],
"query_parameters": {
"ep": "Unknown Name"
},
"links": core_link_format_helper.parse_links(response.payload),
}
id = DB.DB.create(informations)
device = DB.DB.get(id)
Client.add(device)
def _evaluate(self, unknown_devices):
missing_devices, new_devices, changed_devices = self._diff(__class__._known_devices, unknown_devices)
if missing_devices:
for missing_device_id in missing_devices:
logger.info("can't find '{}' with id '{}'".format(__class__._known_devices[missing_device_id].get('label'), missing_device_id))
try:
Client.delete(missing_device_id)
except AttributeError:
DevicePool.remove(missing_device_id)
if new_devices:
for new_device_id in new_devices:
name = unknown_devices[new_device_id].get('label')
logger.info("found '{}' with id '{}'".format(name, new_device_id))
device = Device(new_device_id, SEPL_DEVICE_TYPE, name)
product = unknown_devices[new_device_id].get('product')
device.addTag('type', 'Extended color light')
device.addTag('product', product.get('name'))
device.addTag('manufacturer', product.get('company'))
try:
Client.add(device)
except AttributeError:
DevicePool.add(device)
if changed_devices:
for changed_device_id in changed_devices:
seconds_since_seen = unknown_devices[changed_device_id].get('seconds_since_seen')
if seconds_since_seen >= 60:
try:
Client.disconnect(changed_device_id)
except AttributeError:
DevicePool.remove(changed_device_id)
del unknown_devices[changed_device_id]
else:
device = DevicePool.get(changed_device_id)
name = unknown_devices[changed_device_id].get('label')
if not name == device.name:
device.name = name
try:
Client.update(device)
except AttributeError:
DevicePool.update(device)
logger.info("name of '{}' changed to {}".format(changed_device_id, name))
__class__._known_devices = unknown_devices
def run(self):
logger.debug("starting serial controller for device '{}'".format(
self._id))
self._writeSerialLog('serial connection open')
self._writeSerialLog(self._greeting, 'D')
if self._waitFor('RDY'):
self._writeSerialLog('RDY', 'D')
logger.info("started serial controller for device '{}'".format(
self._id))
logger.debug(self._serial_con)
if self._configureDevice(init=True):
try:
Client.add(self._device)
except AttributeError:
DevicePool.add(self._device)
if self._strt:
self.startDetection()
while True:
try:
command, callbk, kwargs = self._commands.get(timeout=1)
if command != self._stopAction:
if kwargs:
command(callbk, **kwargs)
else:
command(callbk)
else:
callbk(409)
except Empty:
pass
except __class__.Interrupt:
break
try:
Client.disconnect(self._device)
except AttributeError:
DevicePool.remove(self._device)
else:
logger.error("device '{}' not ready".format(self._id))
self._closeConnection()
logger.info("serial controller for device '{}' exited".format(
self._id))
def _evaluate(self, unknown_devices, init):
missing_devices, new_devices, changed_devices = self._diff(
__class__._known_devices, unknown_devices)
if missing_devices:
for missing_device_id in missing_devices:
logger.info("can't find '{}' with id '{}'".format(
__class__._known_devices[missing_device_id].get(
'deviceName'), missing_device_id))
if init:
DevicePool.remove(missing_device_id)
else:
Client.disconnect(missing_device_id)
if new_devices:
for new_device_id in new_devices:
name = unknown_devices[new_device_id].get('deviceName')
logger.info("found '{}' with id '{}'".format(
name, new_device_id))
device = BleboxDevice(new_device_id, SEPL_DEVICE_TYPE, name,
unknown_devices[new_device_id].get('ip'))
device.addTag('type',
unknown_devices[new_device_id].get('type'))
if init:
DevicePool.add(device)
else:
Client.add(device)
if changed_devices:
for changed_device_id in changed_devices:
device = DevicePool.get(changed_device_id)
name = unknown_devices[changed_device_id].get('deviceName')
if not name == device.name:
device.name = name
if init:
DevicePool.update(device)
else:
Client.update(device)
logger.info("name of '{}' changed to {}".format(
changed_device_id, name))
__class__._known_devices = unknown_devices
if 5 in tests:
time.sleep(0.5)
logger.info('------ disconnect existing device ------')
Client.disconnect(id_1)
if 6 in tests:
time.sleep(0.5)
logger.info('------ delete existing device ------')
Client.delete(id_3)
if 7 in tests:
time.sleep(0.5)
logger.info('------ add new device ------')
new_device = Device(id_4, 'iot#1740e97f-1ae1-4547-a757-a62018083d3f',
'Dummy Device 4')
Client.add(new_device)
if 8 in tests:
time.sleep(0.5)
logger.info('------ push 5 events ------')
for event in range(5):
data = json.dumps({'str_field': 'dummy event', 'int_field': event})
response = Client.event(id_4, 'dummy-event', data,
'dummy metadata {}'.format(event))
logger.info("event response '{}'".format(response.payload))
if 9 in tests:
time.sleep(0.5)
logger.info('------ receive command and respond ------')
msg_obj = Client.receive()
device_id = msg_obj.payload.get('device_url')
def run(self):
while True:
#todo die disconnected auf connected umstellen wenn wieder da,
# allles auf connected stellen wenn nicht eh schon auf connected
time.sleep(10)
local_coap_client = HelperClient(server=("127.0.0.1", 5683))
response = local_coap_client.get("/rd-lookup/ep")
if response.payload:
known_devices = core_link_format_helper.parse_links(
response.payload)
# ping unicast instead of multicast, dont know if the device listens on multicast
missing_devices = []
reconnected_devices = []
for device in known_devices:
url = request_helper.parse_url(device.get("path"))
device_was_connected = None
print(device)
if device.get("status") == '1':
device_was_connected = True
elif device.get("status") == '0':
device_was_connected = False
is_online = self.ping(url.hostname, url.port)
if not is_online and device_was_connected:
missing_devices.append(device)
if is_online and not device_was_connected:
reconnected_devices.append(device)
for device in missing_devices:
id = device.get("id")
logger.info(
"PINGER: device {id} is not online -> disconnect".
format(id=id))
device = DB.DB.get(id)
try:
Client.disconnect(device)
logger.info(
"PINGER: device {id} was disconnected from RD and platform"
.format(id=id))
except Exception as e:
logger.error(
"PINGER: device {id} was not successful disconnected"
.format(id=id))
logger.error(e)
for device in reconnected_devices:
id = device.get("id")
logger.info(
"PINGER: device {id} is online -> reconnect".format(
id=id))
device = DB.DB.get(id)
try:
# For reconnect, use add() - maybe connect() better ?
Client.add(device)
logger.info(
"PINGER: device {id} was added to platform".format(
id=id))
except Exception as e:
logger.error(
"PINGER: device {id} was not successful added to platform"
.format(id=id))