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())