This repository has been archived on 2024-05-31. You can view files and clone it, but cannot push or open issues or pull requests.
devicehub-teal/ereuse_devicehub/resources/device/sync.py

417 lines
17 KiB
Python
Raw Normal View History

2022-07-12 09:23:55 +00:00
import copy
import difflib
2018-04-27 17:16:43 +00:00
from contextlib import suppress
from itertools import groupby
from typing import Iterable, Set
2018-04-27 17:16:43 +00:00
import yaml
from flask import g
2018-07-14 14:41:22 +00:00
from sqlalchemy import inspect
from sqlalchemy.exc import IntegrityError
from sqlalchemy.util import OrderedSet
2018-09-07 10:38:02 +00:00
from teal.db import ResourceNotFound
from teal.marshmallow import ValidationError
2018-07-14 14:41:22 +00:00
2018-04-27 17:16:43 +00:00
from ereuse_devicehub.db import db
from ereuse_devicehub.resources.action.models import Remove
2022-06-13 15:33:22 +00:00
from ereuse_devicehub.resources.device.models import (
Component,
Computer,
DataStorage,
Device,
2022-06-28 15:40:00 +00:00
Placeholder,
2022-06-13 15:33:22 +00:00
)
from ereuse_devicehub.resources.tag.model import Tag
2018-04-27 17:16:43 +00:00
2021-11-26 13:08:11 +00:00
DEVICES_ALLOW_DUPLICITY = [
'RamModule',
'Display',
'SoundCard',
'Battery',
'Camera',
'GraphicCard',
]
err_motherboard = "Error: We have detected that a there is a device"
err_motherboard += " in your inventory with this system UUID. "
err_motherboard += "We proceed to block this snapshot to prevent its"
2022-10-24 15:58:25 +00:00
err_motherboard += " information from being updated incorrectly."
err_motherboard += " The solution we offer you to inventory this device "
err_motherboard += "is to do it by creating a placeholder."
2022-06-13 15:33:22 +00:00
2022-10-24 15:58:25 +00:00
2018-04-27 17:16:43 +00:00
class Sync:
"""Synchronizes the device and components with the database."""
2022-06-13 15:33:22 +00:00
def run(
self, device: Device, components: Iterable[Component] or None
) -> (Device, OrderedSet):
"""Synchronizes the device and components with the database.
2018-04-27 17:16:43 +00:00
Identifies if the device and components exist in the database
and updates / inserts them as necessary.
Passed-in parameters have to be transient, or said differently,
not-db-synced objects, or otherwise they would end-up being
added in the session. `Learn more... <http://docs.sqlalchemy.org/
en/latest/orm/session_state_management.html#quickie-intro-to
-object-states>`_.
2018-04-27 17:16:43 +00:00
This performs Add / Remove as necessary.
2018-04-27 17:16:43 +00:00
:param device: The device to add / update to the database.
:param components: Components that are inside of the device.
This method performs Add and Remove actions
2018-04-27 17:16:43 +00:00
so the device ends up with these components.
Components are added / updated accordingly.
If this is empty, all components are removed.
If this is None, it means that we are not
providing info about the components, in which
case we keep the already existing components
of the device we don't touch them.
2018-04-27 17:16:43 +00:00
:return: A tuple of:
2018-04-30 17:58:19 +00:00
1. The device from the database (with an ID) whose
2018-07-14 14:41:22 +00:00
``components`` field contain the db version
2018-04-30 17:58:19 +00:00
of the passed-in components.
2. A list of Add / Remove (not yet added to session).
2018-04-27 17:16:43 +00:00
"""
db_device = self.execute_register(device)
motherboard = None
if components:
for c in components:
if c.type == "Motherboard":
motherboard = c
if motherboard:
for c in db_device.components:
if c.type == "Motherboard" and motherboard.hid != c.hid:
2022-11-16 16:40:35 +00:00
# import pdb; pdb.set_trace()
raise ValidationError(err_motherboard)
db_components, actions = OrderedSet(), OrderedSet()
2018-04-30 17:58:19 +00:00
if components is not None: # We have component info (see above)
if not isinstance(db_device, Computer):
# Until a good reason is given, we synthetically forbid
# non-computers with components
raise ValidationError('Only computers can have components.')
2018-04-30 17:58:19 +00:00
blacklist = set() # type: Set[int]
not_new_components = set()
for component in components:
2022-06-13 15:33:22 +00:00
db_component, is_new = self.execute_register_component(
component, blacklist, parent=db_device
)
db_components.add(db_component)
2018-04-30 17:58:19 +00:00
if not is_new:
not_new_components.add(db_component)
# We only want to perform Add/Remove to not new components
actions = self.add_remove(db_device, not_new_components)
2018-04-30 17:58:19 +00:00
db_device.components = db_components
self.create_placeholder(db_device)
return db_device, actions
2018-04-30 17:58:19 +00:00
2022-06-13 15:33:22 +00:00
def execute_register_component(
self, component: Component, blacklist: Set[int], parent: Computer
):
"""Synchronizes one component to the DB.
2018-04-27 17:16:43 +00:00
This method is a specialization of :meth:`.execute_register`
but for components that are inside parents.
2018-04-30 17:58:19 +00:00
This method assumes components don't have tags, and it tries
to identify a non-hid component by finding a
:meth:`ereuse_devicehub.resources.device.models.Component.
similar_one`.
2018-04-27 17:16:43 +00:00
:param component: The component to sync.
2018-04-27 17:16:43 +00:00
:param blacklist: A set of components already found by
Component.similar_one(). Pass-in an empty Set.
:param parent: For components, the computer that contains them.
Helper used by Component.similar_one().
2018-04-30 17:58:19 +00:00
:return: A tuple with:
- The synced component. See :meth:`.execute_register`
for more info.
- A flag stating if the device is new or it already
existed in the DB.
"""
2022-07-18 14:56:35 +00:00
# if device.serial_number == 'b8oaas048286':
assert inspect(component).transient, 'Component should not be synced from DB'
2021-11-26 13:08:11 +00:00
# if not is a DataStorage, then need build a new one
if component.t in DEVICES_ALLOW_DUPLICITY:
db.session.add(component)
is_new = True
return component, is_new
# if not, then continue with the traditional behaviour
try:
if component.hid:
2022-06-13 15:33:22 +00:00
db_component = Device.query.filter_by(
2022-07-18 14:56:35 +00:00
hid=component.hid, owner_id=g.user.id, placeholder=None
2022-06-13 15:33:22 +00:00
).one()
assert isinstance(
db_component, Device
), '{} must be a component'.format(db_component)
else:
# Is there a component similar to ours?
db_component = component.similar_one(parent, blacklist)
# We blacklist this component so we
# ensure we don't get it again for another component
# with the same physical properties
blacklist.add(db_component.id)
except ResourceNotFound:
db.session.add(component)
# db.session.flush()
db_component = component
is_new = True
else:
self.merge(component, db_component)
is_new = False
return db_component, is_new
def execute_register(self, device: Device) -> Device:
"""Synchronizes one device to the DB.
This method tries to get an existing device using the HID
or one of the tags, and...
2018-07-14 14:41:22 +00:00
- if it already exists it returns a "local synced version"
the same ``device`` you passed-in but with updated values
from the database. In this case we do not
"touch" any of its values on the DB.
- If it did not exist, a new device is created in the db.
This method validates that all passed-in tags (``device.tags``),
if linked, are linked to the same device, ditto for the hid.
Finally it links the tags with the device.
If you pass-in a component that is inside a parent, use
:meth:`.execute_register_component` as it has more specialized
methods to handle them.
:param device: The device to synchronize to the DB.
2018-04-27 17:16:43 +00:00
:raise NeedsId: The device has not any identifier we can use.
To still create the device use
``force_creation``.
:raise DatabaseError: Any other error from the DB.
:return: The synced device from the db with the tags linked.
2018-04-27 17:16:43 +00:00
"""
assert inspect(device).transient, 'Device cannot be already synced from DB'
2022-06-13 15:33:22 +00:00
assert all(
inspect(tag).transient for tag in device.tags
), 'Tags cannot be synced from DB'
db_device = None
if isinstance(device, Computer):
# first search by uuid
if device.system_uuid:
with suppress(ResourceNotFound):
db_device = Computer.query.filter_by(
2022-07-18 14:56:35 +00:00
system_uuid=device.system_uuid,
owner_id=g.user.id,
active=True,
placeholder=None,
).one()
# if no there are any Computer by uuid search by hid
2022-12-12 13:10:17 +00:00
if not db_device:
db_device = device.get_from_db()
2022-06-13 15:33:22 +00:00
elif device.hid:
2022-12-12 13:10:17 +00:00
db_device = device.get_from_db()
2022-06-28 15:40:00 +00:00
if db_device and db_device.allocated:
raise ResourceNotFound('device is actually allocated {}'.format(device))
2018-06-19 16:38:42 +00:00
try:
2022-06-13 15:33:22 +00:00
tags = {
Tag.from_an_id(tag.id).one() for tag in device.tags
} # type: Set[Tag]
2018-06-19 16:38:42 +00:00
except ResourceNotFound:
raise ResourceNotFound('tag you are linking to device {}'.format(device))
linked_tags = {tag for tag in tags if tag.device_id} # type: Set[Tag]
if linked_tags:
sample_tag = next(iter(linked_tags))
for tag in linked_tags:
if tag.device_id != sample_tag.device_id:
2022-06-13 15:33:22 +00:00
raise MismatchBetweenTags(
tag, sample_tag
) # Tags linked to different devices
if db_device: # Device from hid
2022-06-13 15:33:22 +00:00
if (
sample_tag.device_id != db_device.id
): # Device from hid != device from tags
raise MismatchBetweenTagsAndHid(db_device.id, db_device.hid)
else: # There was no device from hid
if sample_tag.device.physical_properties != device.physical_properties:
# Incoming physical props of device != props from tag's device
# which means that the devices are not the same
2022-06-13 15:33:22 +00:00
raise MismatchBetweenProperties(
sample_tag.device.physical_properties,
device.physical_properties,
)
db_device = sample_tag.device
2022-06-28 15:40:00 +00:00
if db_device: # Device from hid or tags
self.merge(device, db_device)
else: # Device is new and tags are not linked to a device
device.tags.clear() # We don't want to add the transient dummy tags
db.session.add(device)
db_device = device
2022-06-13 15:33:22 +00:00
db_device.tags |= (
tags # Union of tags the device had plus the (potentially) new ones
)
2018-06-19 16:38:42 +00:00
try:
db.session.flush()
except IntegrityError as e:
# Manage 'one tag per organization' unique constraint
if 'One tag per organization' in e.args[0]:
# todo test for this
2022-06-13 15:33:22 +00:00
id = int(e.args[0][135 : e.args[0].index(',', 135)])
raise ValidationError(
'The device is already linked to tag {} '
'from the same organization.'.format(id),
field_names=['device.tags'],
)
2018-06-19 16:38:42 +00:00
else:
raise
assert db_device is not None
return db_device
2018-04-27 17:16:43 +00:00
@staticmethod
def merge(device: Device, db_device: Device):
"""Copies the physical properties of the device to the db_device.
This method mutates db_device.
2018-04-27 17:16:43 +00:00
"""
if db_device.owner_id != g.user.id:
2022-06-13 15:33:22 +00:00
return
2022-06-28 15:40:00 +00:00
if device.placeholder and not db_device.placeholder:
return
2018-04-30 17:58:19 +00:00
for field_name, value in device.physical_properties.items():
2018-04-27 17:16:43 +00:00
if value is not None:
2018-04-30 17:58:19 +00:00
setattr(db_device, field_name, value)
2018-04-27 17:16:43 +00:00
# if device.system_uuid and db_device.system_uuid and device.system_uuid != db_device.system_uuid:
# TODO @cayop send error to sentry.io
# there are 2 computers duplicate get db_device for hid
if hasattr(device, 'system_uuid') and device.system_uuid:
db_device.system_uuid = device.system_uuid
2022-07-12 09:23:55 +00:00
@staticmethod
def create_placeholder(device: Device):
"""If the device is new, we need create automaticaly a new placeholder"""
if device.binding:
2022-11-03 17:19:56 +00:00
for c in device.components:
if c.phid():
continue
c_dict = copy.copy(c.__dict__)
c_dict.pop('_sa_instance_state')
c_dict.pop('id', None)
c_dict.pop('devicehub_id', None)
c_dict.pop('actions_multiple', None)
c_dict.pop('actions_one', None)
c_placeholder = c.__class__(**c_dict)
c_placeholder.parent = c.parent.binding.device
c.parent = device
component_placeholder = Placeholder(
device=c_placeholder, binding=c, is_abstract=True
)
db.session.add(c_placeholder)
db.session.add(component_placeholder)
return
2022-11-03 17:19:56 +00:00
2022-07-12 09:23:55 +00:00
dict_device = copy.copy(device.__dict__)
dict_device.pop('_sa_instance_state')
dict_device.pop('id', None)
dict_device.pop('devicehub_id', None)
dict_device.pop('actions_multiple', None)
dict_device.pop('actions_one', None)
dict_device.pop('components', None)
2022-07-12 09:23:55 +00:00
dev_placeholder = device.__class__(**dict_device)
if hasattr(device, 'components'):
for c in device.components:
c_dict = copy.copy(c.__dict__)
c_dict.pop('_sa_instance_state')
c_dict.pop('id', None)
c_dict.pop('devicehub_id', None)
c_dict.pop('actions_multiple', None)
c_dict.pop('actions_one', None)
c_placeholder = c.__class__(**c_dict)
c_placeholder.parent = dev_placeholder
c.parent = device
component_placeholder = Placeholder(
device=c_placeholder, binding=c, is_abstract=True
)
db.session.add(c_placeholder)
db.session.add(component_placeholder)
2022-07-12 09:23:55 +00:00
2022-07-28 15:48:14 +00:00
placeholder = Placeholder(
device=dev_placeholder, binding=device, is_abstract=True
)
2022-07-12 09:23:55 +00:00
db.session.add(dev_placeholder)
db.session.add(placeholder)
2022-06-28 15:40:00 +00:00
@staticmethod
2022-06-13 15:33:22 +00:00
def add_remove(device: Computer, components: Set[Component]) -> OrderedSet:
"""Generates the Add and Remove actions (but doesn't add them to
2018-04-30 17:58:19 +00:00
session).
:param device: A device which ``components`` attribute contains
the old list of components. The components that
are not in ``components`` will be Removed.
:param components: List of components that are potentially to
be Added. Some of them can already exist
on the device, in which case they won't
be re-added.
:return: A list of Add / Remove actions.
2018-04-27 17:16:43 +00:00
"""
# Note that we create the Remove actions before the Add ones
actions = OrderedSet()
2018-04-27 17:16:43 +00:00
old_components = set(device.components)
2018-04-30 17:58:19 +00:00
adding = components - old_components
if adding:
# For the components we are adding, let's remove them from their old parents
2018-06-10 16:47:49 +00:00
def g_parent(component: Component) -> Device:
2022-06-13 15:33:22 +00:00
return component.parent or Device(
id=0
) # Computer with id 0 is our Identity
2018-04-30 17:58:19 +00:00
2022-06-13 15:33:22 +00:00
for parent, _components in groupby(
sorted(adding, key=g_parent), key=g_parent
):
set_components = OrderedSet(_components)
check_owners = (x.owner_id == g.user.id for x in set_components)
# Is not Computer Identity and all components have the correct owner
if parent.id != 0 and all(check_owners):
actions.add(Remove(device=parent, components=set_components))
return actions
class MismatchBetweenTags(ValidationError):
2022-06-13 15:33:22 +00:00
def __init__(self, tag: Tag, other_tag: Tag, field_names={'device.tags'}):
message = '{!r} and {!r} are linked to different devices.'.format(
tag, other_tag
)
super().__init__(message, field_names)
class MismatchBetweenTagsAndHid(ValidationError):
2022-06-13 15:33:22 +00:00
def __init__(self, device_id: int, hid: str, field_names={'device.hid'}):
message = 'Tags are linked to device {} but hid refers to device {}.'.format(
device_id, hid
)
super().__init__(message, field_names)
class MismatchBetweenProperties(ValidationError):
def __init__(self, props1, props2, field_names={'device'}):
message = 'The device from the tag and the passed-in differ the following way:'
message += '\n'.join(
2022-06-13 15:33:22 +00:00
difflib.ndiff(
yaml.dump(props1).splitlines(), yaml.dump(props2).splitlines()
)
)
super().__init__(message, field_names)