def import_data(data, token, content_type): """ Import data. :param data: The received data HTTP request, as created by Flask. :param token: The authorization token (JWT). :param content_type: The content_type of request (application/json) :return The status message. :raises HTTPRequestError: If no authorization token was provided (no tenant was informed) :raises HTTPRequestError: If import attribute constraints were violated. This might happen if two attributes have the same name, for instance. """ saved_templates = [] saved_devices = [] try: tenant = init_tenant_context(token, db) ImportHandler.clear_db_config(tenant) original_req_data = copy.copy(data) original_payload = json.loads(original_req_data) data = ImportHandler.replace_ids_by_import_ids(data) json_data, json_payload = parse_payload(content_type, data, import_schema) saved_templates = ImportHandler.save_templates( json_data, json_payload) saved_devices = ImportHandler.save_devices(json_data, original_payload, saved_templates) ImportHandler.restore_db_config() ImportHandler().notifies_creation_to_kafka(saved_devices, tenant) db.session.commit() except IntegrityError as e: LOGGER.error(f' {e}') db.session.rollback() raise HTTPRequestError( 400, 'Template attribute constraints are violated by the request') except Exception as e: LOGGER.error(f' {e}') db.session.rollback() raise HTTPRequestError(400, 'Failed to import data') finally: db.session.close() results = {'message': 'data imported!'} return results
def create(self, device_id, device_type='device'): """ Returns subscription id on success. """ try: svc = json.dumps({ "entities": [{ "type": device_type, "isPattern": "false", "id": device_id }], "reference": self.targetUrl, "duration": "P10Y", "notifyConditions": [{ "type": "ONCHANGE" }] }) response = requests.post(self.baseUrl, headers=self._headers, data=svc) if not (response.status_code == 409 or (200 <= response.status_code < 300)): raise HTTPRequestError(500, "Failed to create subscription") # return the newly created subs reply = response.json() return reply['subscribeResponse']['subscriptionId'] except ValueError: LOGGER.error('Failed to create subscription') raise HTTPRequestError(500, "Failed to create subscription") except requests.ConnectionError: raise HTTPRequestError(500, "Broker is not reachable")
def create(self, device): """ Returns boolean indicating device creation success. """ try: svc = json.dumps({ "services": [{ "resource": "devm", "apikey": self.service, "entity_type": 'device' }] }) response = requests.post(self.baseUrl + '/services', headers=self._headers, data=svc) if not (response.status_code == 409 or (200 <= response.status_code < 300)): error = "Failed to configure ingestion subsystem: service creation failed" raise HTTPRequestError(500, error) except requests.ConnectionError: raise HTTPRequestError( 500, "Cannot reach ingestion subsystem (service)") try: response = requests.post( self.baseUrl + '/devices', headers=self._headers, data=json.dumps({'devices': [self.__get_config(device)]})) if not (200 <= response.status_code < 300): error = "Failed to configure ingestion subsystem: device creation failed" raise HTTPRequestError(500, error) except requests.ConnectionError: raise HTTPRequestError( 500, "Cannot reach ingestion subsystem (device)")
def create_orm_override(attr, orm_device, orm_template): try: target = int(attr['id']) except ValueError: LOGGER.error(f" Unknown attribute {attr['id']} in override list") raise HTTPRequestError( 400, 'Unknown attribute {} in override list'.format(attr['id'])) found = False for orm_attr in orm_template.attrs: if target == orm_attr.id: found = True if 'static_value' in attr and attr['static_value'] is not None: orm_override = DeviceOverride( device=orm_device, attr=orm_attr, static_value=attr['static_value']) db.session.add(orm_override) LOGGER.debug(f" Added overrided form {orm_override}") # Update possible metadata field if 'metadata' in attr: for metadata in attr['metadata']: try: metadata_target = int(metadata['id']) LOGGER.debug(f" Updated metadata {metadata_target}") except ValueError: LOGGER.error( f" metadata attribute {attr['id']} in override list" ) raise HTTPRequestError( 400, 'Unknown metadata attribute {} in override list'. format(metadata['id'])) found = False # WARNING: Adds no-autoflush here, without it metadata override fail during device update with db.session.no_autoflush: for orm_attr_child in orm_attr.children: if metadata_target == orm_attr_child.id: found = True if 'static_value' in metadata and metadata[ 'static_value'] is not None: orm_override = DeviceOverride( device=orm_device, attr=orm_attr_child, static_value=metadata['static_value']) db.session.add(orm_override) LOGGER.debug( f" Added overrided form {orm_override}" ) if not found: LOGGER.error(f" Unknown attribute {attr['id']} in override list") raise HTTPRequestError( 400, 'Unknown attribute {} in override list'.format(target))
def remove(self, subsId): """ Returns boolean indicating subscription removal success. """ try: response = requests.delete(self.baseUrl + '/' + subsId, headers=self._noBodyHeaders) if not (200 <= response.status_code < 300): raise HTTPRequestError(500, "Failed to remove subscription") except requests.ConnectionError: raise HTTPRequestError(500, "Broker is not reachable")
def parse_payload(request, schema): try: content_type = request.headers.get('Content-Type') if (content_type is None) or (content_type != "application/json"): raise HTTPRequestError(400, "Payload must be valid JSON, and Content-Type set accordingly") json_payload = json.loads(request.data) data = schema.load(json_payload) except ValueError: raise HTTPRequestError(400, "Payload must be valid JSON, and Content-Type set accordingly") except ValidationError as errors: results = {'message': 'failed to parse input', 'errors': errors.messages} raise HTTPRequestError(400, results) return data, json_payload
def remove(self, deviceid): """ Returns boolean indicating device removal success. """ try: response = requests.delete(self.baseUrl + '/devices/' + deviceid, headers=self._noBodyHeaders) if 200 <= response.status_code < 300: response = requests.delete('%s/%s' % (self.orionUrl, deviceid), headers=self._noBodyHeaders) if not (200 <= response.status_code < 300): error = "Failed to configure ingestion subsystem: device removal failed" raise HTTPRequestError(500, error) except requests.ConnectionError: raise HTTPRequestError(500, "Cannot reach ingestion subsystem")
def delete_all_templates(token): """ Deletes all templates. :param token: The authorization token (JWT). :raises HTTPRequestError: If this template could not be found in database. """ init_tenant_context(token, db) json_templates = [] try: templates = db.session.query(DeviceTemplate) for template in templates: db.session.delete(template) json_templates.append(template_schema.dump(template)) db.session.commit() except IntegrityError: raise HTTPRequestError(400, "Templates cannot be removed as they are being used by devices") results = { 'result': 'ok', 'removed': json_templates } return results
def remove_template(template_id, token): """ Deletes a single template. :param template_id: The template to be removed. :param token: The authorization token (JWT). :return The removed template. :rtype JSON :raises HTTPRequestError: If no authorization token was provided (no tenant was informed) :raises HTTPRequestError: If this template could not be found in database. :raises HTTPRequestError: If the template is being currently used by a device. """ init_tenant_context(token, db) tpl = assert_template_exists(template_id) json_template = template_schema.dump(tpl) try: db.session.delete(tpl) db.session.commit() except IntegrityError: raise HTTPRequestError(400, "Templates cannot be removed as they are being used by devices") results = { 'result': 'ok', 'removed': json_template } return results
def load_attrs(attr_list, parent_template, base_type, db): """ :rtype: """ for attr in attr_list: try: entity = attr_schema.load(attr) try: children = entity.pop('children') except KeyError: children = [] orm_entity = base_type(template=parent_template, **entity) db.session.add(orm_entity) for child in children: orm_child = DeviceAttr(parent=orm_entity, **child) db.session.add(orm_child) except ValidationError as errors: results = { 'message': 'failed to parse attr', 'errors': errors.messages } raise HTTPRequestError(400, results)
def create_template(req): """ Creates a new template. :param req: The received HTTP request, as created by Flask. :return The created template. :raises HTTPRequestError: If no authorization token was provided (no tenant was informed) :raises HTTPRequestError: If template attribute constraints were violated. This might happen if two attributes have the same name, for instance. """ init_tenant_context(req, db) tpl, json_payload = parse_payload(req, template_schema) loaded_template = DeviceTemplate(**tpl) load_attrs(json_payload['attrs'], loaded_template, DeviceAttr, db) db.session.add(loaded_template) try: db.session.commit() LOGGER.debug(f" Created template in database") except IntegrityError as e: LOGGER.error(f' {e}') raise HTTPRequestError( 400, 'Template attribute constraints are violated by the request') results = { 'template': template_schema.dump(loaded_template), 'result': 'ok' } return results
def flask_copy_psk(device_id, attr_label): try: # retrieve the authorization token token = retrieve_auth_token(request) # retrieve the parameters if ((not 'from_dev_id' in request.args.keys()) or (not 'from_attr_label' in request.args.keys())): raise HTTPRequestError(400, "Missing mandatory parameter: from_dev_id " "or/and from_attr_label") from_dev_id = request.args['from_dev_id'] from_attr_label = request.args['from_attr_label'] DeviceHandler.copy_psk(token, from_dev_id, from_attr_label, device_id, attr_label) return make_response("", 204) except HTTPRequestError as e: if isinstance(e.message, dict): return make_response(jsonify(e.message), e.error_code) return format_response(e.error_code, e.message)
def flask_gen_psk(device_id): try: # retrieve the authorization token token = retrieve_auth_token(request) # retrieve the key_length parameter (mandatory) if not 'key_length' in request.args.keys(): raise HTTPRequestError(400, "Missing key_length parameter") key_length = int(request.args['key_length']) # retrieve the attrs parameter (optional) target_attributes = None if 'attrs' in request.args.keys(): target_attributes = request.args['attrs'].split(",") result = DeviceHandler.gen_psk(token, device_id, key_length, target_attributes) LOGGER.info(f' Successfully generated psk for the device: {device_id}.') return make_response(jsonify(result), 200) except HTTPRequestError as e: LOGGER.error(f' {e.message} - {e.error_code}.') if isinstance(e.message, dict): return make_response(jsonify(e.message), e.error_code) return format_response(e.error_code, e.message)
def assert_device_relation_exists(device_id, template_id): try: return DeviceTemplateMap.query.filter_by( device_id=device_id, template_id=template_id).one() except sqlalchemy.orm.exc.NoResultFound: raise HTTPRequestError( 404, "Device %s is not associated with template %s" % (device_id, template_id))
def init_tenant_context(request, db): try: token = request.headers['authorization'] except KeyError: raise HTTPRequestError(401, "No authorization token has been supplied") tenant = get_allowed_service(token) init_tenant(tenant, db) return tenant
def update_device(cls, params, device_id, token): """ Updated the information about a particular device :param params: Parameters received from request (content_type, data) as created by Flask :param device_id: The device to be updated. :param token: The authorization token (JWT). :return The updated device. :rtype JSON :raises HTTPRequestError: If no authorization token was provided (no tenant was informed) :raises HTTPRequestError: If this device could not be found in database. """ try: content_type = params.get('content_type') data_request = params.get('data') device_data, json_payload = parse_payload(content_type, data_request, device_schema) validate_repeated_attrs(json_payload) tenant = init_tenant_context(token, db) old_orm_device = assert_device_exists(device_id) db.session.delete(old_orm_device) db.session.flush() # handled separately by parse_template_list device_data.pop('templates') updated_orm_device = Device(**device_data) parse_template_list(json_payload.get('templates', []), updated_orm_device) auto_create_template(json_payload, updated_orm_device) updated_orm_device.id = device_id updated_orm_device.updated = datetime.now() updated_orm_device.created = old_orm_device.created db.session.add(updated_orm_device) db.session.commit() except IntegrityError as error: handle_consistency_exception(error) except ValidationError as error: raise HTTPRequestError(400, error.messages) full_device = serialize_full_device(updated_orm_device, tenant) kafka_handler_instance = cls.kafka.getInstance(cls.kafka.kafkaNotifier) kafka_handler_instance.update(full_device, meta={"service": tenant}) result = { 'message': 'device updated', 'device': serialize_full_device(updated_orm_device, tenant) } return result
def assert_template_exists(template_id, session=None): try: if session: with session.no_autoflush: return session.query(DeviceTemplate).filter_by( id=template_id).one() else: return DeviceTemplate.query.filter_by(id=template_id).one() except sqlalchemy.orm.exc.NoResultFound: raise HTTPRequestError(404, "No such template: %s" % template_id)
def configure_device(cls, params, device_id, token): """ Send actuation commands to the device :param params: Parameters received from request (data) as created by Flask :param device_id: The device which should receive the actuation message :param token: The authorization token (JWT). :return A status on whether the message was sent to the device or not. Note that this is not a guarantee that the device actually performed what was requested. :rtype JSON """ # Meta information to be published along with device actuation message meta = {'service': ''} invalid_attrs = [] meta['service'] = init_tenant_context(token, db) meta['timestamp'] = int(time.time() * 1000) orm_device = assert_device_exists(device_id) full_device = serialize_full_device(orm_device, meta['service']) LOGGER.debug(f" Full device: {json.dumps(full_device)}") data = params.get('data') payload = json.loads(data) LOGGER.debug(f' Parsed request payload: {json.dumps(payload)}') payload['id'] = orm_device.id for attr in payload['attrs']: if find_attribute(full_device, attr, 'actuator') is None: invalid_attrs.append(attr) if not invalid_attrs: LOGGER.debug(f' Sending configuration message through Kafka.') kafka_handler_instance = cls.kafka.getInstance( cls.kafka.kafkaNotifier) kafka_handler_instance.configure(payload, meta) LOGGER.debug(f' Configuration sent.') result = {f' status': 'configuration sent to device'} else: LOGGER.warning( f' invalid attributes detected in command: {invalid_attrs}') result = { 'status': 'some of the attributes are not configurable', 'attrs': invalid_attrs } raise HTTPRequestError(403, result) return result
def assert_device_exists(device_id, session=None): """ Assert that a device exists, returning the object retrieved from the database. """ try: if session: with session.no_autoflush: return session.query(Device).filter_by(id=device_id).one() else: return Device.query.filter_by(id=device_id).one() except sqlalchemy.orm.exc.NoResultFound: raise HTTPRequestError(404, "No such device: %s" % device_id)
def auto_create_template(json_payload, new_device): if ('attrs' in json_payload) and (new_device.templates is None): device_template = DeviceTemplate(label="device.%s template" % new_device.id) db.session.add(device_template) new_device.templates = [device_template] load_attrs(json_payload['attrs'], device_template, DeviceAttr, db) # TODO: perhaps it'd be best if all ids were random hex strings? if ('attrs' in json_payload) and (new_device.templates is not None): for attr in json_payload['attrs']: orm_template = find_template(new_device.templates, attr['template_id']) if orm_template is None: raise HTTPRequestError( 400, 'Unknown template "{}" in attr list'.format(orm_template)) try: target = int(attr['id']) except ValueError: raise HTTPRequestError( 400, "Unkown attribute \"{}\" in override list".format( attr['id'])) found = False for orm_attr in orm_template.attrs: if target == orm_attr.id: found = True orm_override = DeviceOverride( device=new_device, attr=orm_attr, static_value=attr['static_value']) db.session.add(orm_override) if not found: raise HTTPRequestError( 400, "Unkown attribute \"{}\" in override list".format(target))
def load_attrs(attr_list, parent_template, base_type, db): """ :rtype: """ for attr in attr_list: try: entity = attr_schema.load(attr).data except ValidationError as errors: results = {'message': 'failed to parse attr', 'errors': errors} raise HTTPRequestError(400, results) orm_attr = base_type(template=parent_template, **entity) db.session.add(orm_attr)
def auto_create_template(json_payload, new_device): if ('attrs' in json_payload) and (new_device.templates is None): device_template = DeviceTemplate( label="device.%s template" % new_device.id) db.session.add(device_template) LOGGER.debug(f" Adding auto-created template {device_template} into database") new_device.templates = [device_template] load_attrs(json_payload['attrs'], device_template, DeviceAttr, db) # TODO: perhaps it'd be best if all ids were random hex strings? if ('attrs' in json_payload) and (new_device.templates is not None): for attr in json_payload['attrs']: orm_template = find_template(new_device.templates, attr['template_id']) if orm_template is None: LOGGER.error(f" Unknown template {orm_template} in attr list") raise HTTPRequestError(400, 'Unknown template "{}" in attr list'.format(orm_template)) create_orm_override(attr, new_device, orm_template)
def generate_device_id(): """ Creates a new device id :return The new ID :rtype int :raises HTTPRequestError: If this function can't generate a new valid ID after 10 attempts. """ # TODO this is awful, makes me sad, but for now also makes demoing # easier We might want to look into an auto-configuration feature for # devices, such that ids are not input manually on devices _attempts = 0 generated_id = '' while _attempts < 10 and len(generated_id) == 0: _attempts += 1 new_id = create_id() if Device.query.filter_by(id=new_id).first() is None: return new_id raise HTTPRequestError(500, "Failed to generate unique device_id")
def update_log_level(self, LEVEL): levelToName = ['CRITICAL', 'ERROR', 'WARNING', 'INFO', 'DEBUG'] try: self.log = logging.getLogger('device-manager.' + __name__) for hdlr in self.log.handlers[:]: self.log.removeHandler(hdlr) self.stream = logging.StreamHandler() self.stream.setLevel(LEVEL) self.stream.setFormatter(self.formatter) self.log.setLevel(LEVEL) self.log.addHandler(self.stream) self.log.handler_set = True self.level = LEVEL except ValueError: raise HTTPRequestError( 400, "Unknown level: {} valid are {}".format(LEVEL, levelToName))
def create_update_device(self, device, type_descr, is_update=True): target_url = "%s/%s/attrs?type=%s&options=keyValues" % ( self.baseUrl, device['id'], type_descr) body = json.dumps(OrionHandler.parse_device(device, not is_update)) if not is_update: target_url = self.baseUrl try: LOGGER.info("about to create device in ctx broker") LOGGER.debug("%s", body) response = requests.post(target_url, headers=self._headers, data=body) if 200 <= response.status_code < 300: LOGGER.debug("Broker update successful") else: LOGGER.info("Failed to update ctx broker: %d", response.status_code) try: LOGGER.debug("%s", response.json()) except Exception as e: LOGGER.error(e) except requests.ConnectionError: raise HTTPRequestError(500, "Broker is not reachable")
def create_device(cls, params, token): """ Creates and configures the given device. :param params: Parameters received from request (count, verbose, content_type, data) :param token: The authorization token (JWT). :return The created device or a list of device summary. This depends on which value the verbose (/?verbose=true) has - if true, only one device can be created ("count" argument can't be used or - at least - it must be exactly "1") and the full device is returned. If false, "count" can be used with higher values and only the devices summary (a structure containing all device IDs and their labels) is returned. :raises HTTPRequestError: If no authorization token was provided (no tenant was informed) :raises HTTPRequestError: If verbose is used with multiple device creation request. :raises HTTPRequestError: If count argument ("?count=X") is provided and it is not an integer. """ tenant = init_tenant_context(token, db) try: count = int(params.get('count')) except ValueError as e: LOGGER.error(e) raise HTTPRequestError(400, "If provided, count must be integer") c_length = len(str(count)) verbose = params.get('verbose') in ['true', '1', 'True'] if verbose and count != 1: raise HTTPRequestError( 400, "Verbose can only be used for single device creation") devices = [] full_device = None orm_devices = [] try: for i in range(0, count): content_type = params.get('content_type') data_request = params.get('data') device_data, json_payload = parse_payload( content_type, data_request, device_schema) validate_repeated_attrs(json_payload) device_data['id'] = DeviceHandler.generate_device_id() device_data['label'] = DeviceHandler.indexed_label( count, c_length, device_data['label'], i) device_data.pop('templates', None) orm_device = Device(**device_data) parse_template_list(json_payload.get('templates', []), orm_device) auto_create_template(json_payload, orm_device) db.session.add(orm_device) orm_devices.append(orm_device) db.session.commit() except IntegrityError as error: handle_consistency_exception(error) except ValidationError as error: raise HTTPRequestError(400, error.messages) for orm_device in orm_devices: devices.append({'id': orm_device.id, 'label': orm_device.label}) full_device = serialize_full_device(orm_device, tenant) # Updating handlers kafka_handler_instance = cls.kafka.getInstance( cls.kafka.kafkaNotifier) kafka_handler_instance.create(full_device, meta={"service": tenant}) if verbose: result = {'message': 'device created', 'devices': [full_device]} else: result = {'message': 'devices created', 'devices': devices} return result
def handle_consistency_exception(error): raise HTTPRequestError(400, error.orig.diag.message_primary)
def create_device(req): """ Creates and configures the given device. :param req: The received HTTP request, as created by Flask. :return The created device or a list of device summary. This depends on which value the verbose (/?verbose=true) has - if true, only one device can be created ("count" argument can't be used or - at least - it must be exactly "1") and the full device is returned. If false, "count" can be used with higher values and only the devices summary (a structure containing all device IDs and their labels) is returned. :raises HTTPRequestError: If no authorization token was provided (no tenant was informed) :raises HTTPRequestError: If verbose is used with multiple device creation request. :raises HTTPRequestError: If count argument ("?count=X") is provided and it is not an integer. """ tenant = init_tenant_context(req, db) try: count = int(req.args.get('count', '1')) except ValueError as e: LOGGER.error(e) raise HTTPRequestError(400, "If provided, count must be integer") c_length = len(str(count)) verbose = req.args.get('verbose', 'false') in ['true', '1', 'True'] if verbose and count != 1: raise HTTPRequestError( 400, "Verbose can only be used for single device creation") devices = [] # Handlers kafka_handler = KafkaHandler() if CONFIG.orion: ctx_broker_handler = OrionHandler(service=tenant) subs_handler = PersistenceHandler(service=tenant) else: ctx_broker_handler = None subs_handler = None full_device = None orm_devices = [] for i in range(0, count): device_data, json_payload = parse_payload(req, device_schema) device_data['id'] = DeviceHandler.generate_device_id() device_data['label'] = DeviceHandler.indexed_label(count, c_length, device_data['label'], i) # handled separately by parse_template_list device_data.pop('templates', None) orm_device = Device(**device_data) parse_template_list(json_payload.get('templates', []), orm_device) auto_create_template(json_payload, orm_device) db.session.add(orm_device) orm_devices.append(orm_device) try: db.session.commit() except IntegrityError as error: handle_consistency_exception(error) for orm_device in orm_devices: devices.append( { 'id': orm_device.id, 'label': orm_device.label } ) full_device = serialize_full_device(orm_device, tenant) # Updating handlers kafka_handler.create(full_device, meta={"service": tenant}) if CONFIG.orion: # Generating 'device type' field for history type_descr = "template" for dev_type in full_device['attrs'].keys(): type_descr += "_" + str(dev_type) # TODO remove this in favor of kafka as data broker.... ctx_broker_handler.create(full_device, type_descr) sub_id = subs_handler.create(full_device['id'], type_descr) orm_device.persistence = sub_id if verbose: result = { 'message': 'device created', 'device': full_device } else: result = { 'message': 'devices created', 'devices': devices } return result
def gen_psk(token, device_id, key_length, target_attributes=None): """ Generates pre shared keys to a specifics device :param token: The authorization token (JWT). :param device_id: The target device. :param key_length: The key length to be generated. :param target_attributes: A list with the target attributes, None means all suitable attributes. :return The keys generated. :rtype JSON :raises HTTPRequestError: If no authorization token was provided (no tenant was informed) :raises HTTPRequestError: If this device could not be found in database. """ tenant = init_tenant_context2(token, db) device_orm = assert_device_exists(device_id, db.session) if not device_orm: raise HTTPRequestError(404, "No such device: {}".format(device_id)) device = serialize_full_device(device_orm, tenant, True) # checks if the key length has been specified # todo remove this magic number if key_length > 1024 or key_length <= 0: raise HTTPRequestError(400, "key_length must be greater than 0 and lesser than {}".format(1024)) is_all_psk_attr_valid = False target_attrs_data = [] # find the target attributes # first case: if there are specified attributes if target_attributes: for template_id in device["templates"]: for attr in device["attrs"][template_id]: if attr["value_type"] == "psk" and attr["label"] in target_attributes: target_attrs_data.append(attr) is_all_psk_attr_valid = True if not is_all_psk_attr_valid: raise HTTPRequestError(400, "Not found some attributes, " "please check them") if len(target_attributes) != len(target_attrs_data): if not is_all_psk_attr_valid: raise HTTPRequestError(400, "Some attribute is not a 'psk' type_value") else: raise HTTPRequestError(400, "Not found some attributes, " "please check them") else: # second case: if there are not specified attributes for template_id in device["templates"]: for attr in device["attrs"][template_id]: if attr["value_type"] == "psk": target_attrs_data.append(attr) is_all_psk_attr_valid = True if not is_all_psk_attr_valid: # there is no psk key, do not worry it is not a problem raise HTTPRequestError(204, "") # generate the pre shared key on selected attributes result = [] for attr in target_attrs_data: psk = secrets.token_hex(key_length) psk_hex = psk attr["static_value"] = psk_hex encrypted_psk = encrypt(psk) psk_entry = DeviceAttrsPsk.query.filter_by(device_id=device["id"], attr_id=attr["id"]).first() if not psk_entry: db.session.add(DeviceAttrsPsk(device_id=device["id"], attr_id=attr["id"], psk=encrypted_psk)) else: psk_entry.psk = encrypted_psk result.append( {'attribute': attr["label"], 'psk': psk_hex} ) device_orm.updated = datetime.now() db.session.commit() # send an update message on kafka kafka_handler = KafkaHandler() kafka_handler.update(device, meta={"service": tenant}) return result
def copy_psk(token, src_device_id, src_attr, dest_device_id, dest_attr): """ Copies a pre shared key from a device attribute to another :param token: The authorization token (JWT). :param src_device_id: The source device (from). :param src_attr: The source attribute (from). :param dest_device_id: The destination device (to). :param dest_attr: The destination attribute (to). :return None. :raises HTTPRequestError: If no authorization token was provided (no tenant was informed) todo list the others exceptions """ tenant = init_tenant_context2(token, db) src_device_orm = assert_device_exists(src_device_id, db.session) if not src_device_orm: raise HTTPRequestError(404, "No such device: {}".format(src_device_id)) src_device = serialize_full_device(src_device_orm, tenant, True) found_attr = False src_attr_ref = None for template_id in src_device["templates"]: for attr in src_device["attrs"][template_id]: if attr["label"] == src_attr: if attr["value_type"] == "psk": found_attr = True src_attr_ref = attr break else: raise HTTPRequestError(400, "Attribute {} is not a 'psk' type_value".format(src_attr)) if not found_attr: raise HTTPRequestError(404, "Not found attributes {}".format(src_attr)) dest_device_orm = assert_device_exists(dest_device_id, db.session) if not dest_device_orm: raise HTTPRequestError(404, "No such device: {}".format(dest_device_id)) dest_device = serialize_full_device(dest_device_orm, tenant, True) found_attr = False dest_attr_ref = None for template_id in dest_device["templates"]: for attr in dest_device["attrs"][template_id]: if attr["label"] == dest_attr: if attr["value_type"] == "psk": found_attr = True dest_attr_ref = attr break else: raise HTTPRequestError(400, "Attribute {} is not a 'psk' type_value".format(dest_attr)) if not found_attr: raise HTTPRequestError(404, "Not found attributes {}".format(dest_attr)) # copy the pre shared key src_psk_entry = DeviceAttrsPsk.query.filter_by(device_id=src_device["id"], attr_id=src_attr_ref["id"]).first() if not src_psk_entry: raise HTTPRequestError(400, "There is not a psk generated to {}".format(src_attr)) dest_psk_entry = DeviceAttrsPsk.query.filter_by(device_id=dest_device["id"], attr_id=dest_attr_ref["id"]).first() if not dest_psk_entry: db.session.add(DeviceAttrsPsk(device_id=dest_device["id"], attr_id=dest_attr_ref["id"], psk=src_psk_entry.psk)) else: dest_psk_entry.psk = src_psk_entry.psk dest_device_orm.updated = datetime.now() db.session.commit() dest_attr_ref['static_value'] = src_attr_ref['static_value'] # send an update message on kafka kafka_handler = KafkaHandler() kafka_handler.update(dest_device, meta={"service": tenant}) return None