def test_meta_machine(self):
tree = copy.deepcopy(self.machine_snapshot)
msc, ms, _ = MachineSnapshotCommit.objects.commit_machine_snapshot_tree(
tree)
tree = copy.deepcopy(self.machine_snapshot2)
msc2, ms2, _ = MachineSnapshotCommit.objects.commit_machine_snapshot_tree(
tree)
tree = copy.deepcopy(self.machine_snapshot3)
msc3, ms3, _ = MachineSnapshotCommit.objects.commit_machine_snapshot_tree(
tree)
mm = MetaMachine(self.serial_number)
self.assertEqual(mm.serial_number, self.serial_number)
self.assertEqual(mm.snapshots, [ms3])
self.assertEqual(mm.platform, MACOS)
tag1, _ = Tag.objects.get_or_create(name="tag111")
tag2, _ = Tag.objects.get_or_create(name="tag222")
MachineTag.objects.create(tag=tag1, serial_number=self.serial_number)
self.assertEqual(
(MACOS, None, {self.meta_business_unit.id}, {tag1.id}),
mm.get_probe_filtering_values())
MetaBusinessUnitTag.objects.create(
tag=tag2, meta_business_unit=self.meta_business_unit)
# cached
self.assertEqual(
(MACOS, None, {self.meta_business_unit.id}, {tag1.id}),
mm.get_probe_filtering_values())
# fresh
mm = MetaMachine(self.serial_number)
self.assertEqual(
(MACOS, None, {self.meta_business_unit.id}, {tag1.id, tag2.id}),
mm.get_probe_filtering_values())
# cached with cache framework
mm = MetaMachine(self.serial_number)
self.assertEqual(
(MACOS, None, {self.meta_business_unit.id}, {tag1.id, tag2.id}),
mm.cached_probe_filtering_values)
self.assertEqual(
(MACOS, None, {self.meta_business_unit.id}, {tag1.id, tag2.id}),
cache.get("mm-probe-fvs_{}".format(
mm.get_urlsafe_serial_number())))
mm.archive()
mm = MetaMachine(self.serial_number)
self.assertEqual(mm.snapshots, [])
self.assertEqual(MachineSnapshot.objects.count(), 3)
self.assertEqual(MachineSnapshotCommit.objects.count(), 3)
self.assertEqual(CurrentMachineSnapshot.objects.count(), 0)
class EventMetadata(object):
def __init__(self, event_type, **kwargs):
self.event_type = event_type
self.uuid = kwargs.pop('uuid', uuid.uuid4())
if isinstance(self.uuid, str):
self.uuid = uuid.UUID(self.uuid)
self.index = int(kwargs.pop('index', 0))
self.created_at = kwargs.pop('created_at', None)
if self.created_at is None:
self.created_at = datetime.utcnow()
elif isinstance(self.created_at, str):
self.created_at = parser.parse(self.created_at)
self.machine_serial_number = kwargs.pop('machine_serial_number', None)
if self.machine_serial_number:
self.machine = MetaMachine(self.machine_serial_number)
else:
self.machine = None
self.observer = kwargs.pop('observer', None)
self.request = kwargs.pop('request', None)
self.tags = kwargs.pop('tags', [])
self.incidents = kwargs.pop('incidents', [])
@classmethod
def deserialize(cls, event_d_metadata):
kwargs = event_d_metadata.copy()
kwargs['event_type'] = kwargs.pop('type')
kwargs['uuid'] = kwargs.pop('id')
observer_d = kwargs.pop('observer', None)
if observer_d:
kwargs['observer'] = EventObserver.deserialize(observer_d)
request_d = kwargs.pop('request', None)
if request_d:
kwargs['request'] = EventRequest.deserialize(request_d)
return cls(**kwargs)
def serialize_machine(self):
machine_d_cache_key = "machine_d_{}".format(
self.machine.get_urlsafe_serial_number())
machine_d = cache.get(machine_d_cache_key)
if not machine_d:
machine_d = {}
for ms in self.machine.snapshots:
source = ms.source
ms_d = {'name': ms.get_machine_str()}
if ms.business_unit:
if not ms.business_unit.is_api_enrollment_business_unit():
ms_d['business_unit'] = {
'reference': ms.business_unit.reference,
'key': ms.business_unit.get_short_key(),
'name': ms.business_unit.name
}
if ms.os_version:
ms_d['os_version'] = str(ms.os_version)
for group in ms.groups.all():
ms_d.setdefault('groups', []).append({
'reference':
group.reference,
'key':
group.get_short_key(),
'name':
group.name
})
key = slugify(source.name)
if key in ms_d:
# TODO: earlier warning in conf check ?
logger.warning('Inventory source slug %s exists already',
key)
machine_d[key] = ms_d
for tag in self.machine.tags:
machine_d.setdefault('tags', []).append({
'id': tag.id,
'name': tag.name
})
for meta_business_unit in self.machine.meta_business_units:
machine_d.setdefault('meta_business_units', []).append({
'name':
meta_business_unit.name,
'id':
meta_business_unit.id
})
if self.machine.platform:
machine_d['platform'] = self.machine.platform
if self.machine.type:
machine_d['type'] = self.machine.type
cache.set(machine_d_cache_key, machine_d,
60) # TODO: Hard coded timeout value
return machine_d
def serialize(self, machine_metadata=True):
d = {
'created_at': self.created_at.isoformat(),
'id': str(self.uuid),
'index': self.index,
'type': self.event_type,
}
if self.observer:
d['observer'] = self.observer.serialize()
if self.request:
d['request'] = self.request.serialize()
if self.tags:
d['tags'] = self.tags
if self.incidents:
d['incidents'] = self.incidents
if self.machine_serial_number:
d['machine_serial_number'] = self.machine_serial_number
if not machine_metadata or not self.machine:
return d
machine_d = self.serialize_machine()
if machine_d:
d['machine'] = machine_d
return d
def add_incident(self, incident):
self.incidents.append(incident.serialize_for_event_metadata())