def test_last_image_sync(self): owner = factory.make_admin() handler = ControllerHandler(owner, {}) node = factory.make_RackController(owner=owner) result = handler.list({}) self.assertEqual(1, len(result)) self.assertEqual(NODE_TYPE.RACK_CONTROLLER, result[0].get('node_type')) self.assertEqual(result[0].get( 'last_image_sync'), dehydrate_datetime(node.last_image_sync)) data = handler.get({"system_id": node.system_id}) self.assertEqual(data.get("last_image_sync"), dehydrate_datetime( node.last_image_sync))
def dehydrate_space(self, space): data = { "id": space.id, "name": space.get_name(), "description": space.description, "updated": dehydrate_datetime(space.updated), "created": dehydrate_datetime(space.created), "subnet_ids": sorted(subnet.id for subnet in space.subnet_set.all()), "vlan_ids": sorted(vlan.id for vlan in space.vlan_set.all()), } return data
def dehydrate_fabric(self, fabric): data = { "id": fabric.id, "name": fabric.get_name(), "description": fabric.description, "class_type": fabric.class_type, "updated": dehydrate_datetime(fabric.updated), "created": dehydrate_datetime(fabric.created), "vlan_ids": sorted([vlan.id for vlan in fabric.vlan_set.all()]), } data["default_vlan_id"] = data["vlan_ids"][0] return data
def dehydrate_domain(self, domain, for_list=False): if domain.id == 0: displayname = "%s (default)" % domain.name else: displayname = domain.name data = { "id": domain.id, "name": domain.name, "displayname": displayname, "authoritative": domain.authoritative, "ttl": domain.ttl, "updated": dehydrate_datetime(domain.updated), "created": dehydrate_datetime(domain.created), } ip_map = StaticIPAddress.objects.get_hostname_ip_mapping( domain, raw_ttl=True) rr_map = DNSData.objects.get_hostname_dnsdata_mapping( domain, raw_ttl=True) domainname_len = len(domain.name) for name, info in ip_map.items(): name = name[:-domainname_len - 1] if info.system_id is not None: rr_map[name].system_id = info.system_id for ip in info.ips: if IPAddress(ip).version == 4: rr_map[name].rrset.add((info.ttl, 'A', ip)) else: rr_map[name].rrset.add((info.ttl, 'AAAA', ip)) rrsets = [ { 'name': hostname, 'system_id': info.system_id, 'node_type': info.node_type, 'ttl': ttl, 'rrtype': rrtype, 'rrdata': rrdata, } for hostname, info in rr_map.items() for ttl, rrtype, rrdata in info.rrset ] data['resource_count'] = len(rrsets) hosts = set() for record in rrsets: if record['system_id'] is not None: hosts.add(record['system_id']) data['hosts'] = len(hosts) if not for_list: data.update({ "rrsets": rrsets, }) return data
def dehydrate_script_result(self, script_result, handler): results = script_result.read_results().get("results", {}) data = { "id": script_result.id, "updated": dehydrate_datetime(script_result.updated), "script": script_result.script_id, "parameters": script_result.parameters, "physical_blockdevice": script_result.physical_blockdevice_id, "script_version": script_result.script_version_id, "status": script_result.status, "status_name": script_result.status_name, "exit_status": script_result.exit_status, "started": dehydrate_datetime(script_result.started), "ended": dehydrate_datetime(script_result.ended), "runtime": script_result.runtime, "starttime": script_result.starttime, "endtime": script_result.endtime, "estimated_runtime": script_result.estimated_runtime, "name": script_result.name, "result_type": script_result.script_set.result_type, "hardware_type": script_result.script.hardware_type, "tags": ", ".join(script_result.script.tags), "results": [{ "name": key, "title": key, "description": "", "value": value, "surfaced": False, } for key, value in results.items()], } return data
def dehydrate_iprange(self, iprange, for_list=False): data = { "id": iprange.id, "created": dehydrate_datetime(iprange.created), "updated": dehydrate_datetime(iprange.updated), "subnet": iprange.subnet_id, "start_ip": iprange.start_ip, "end_ip": iprange.end_ip, "comment": iprange.comment, "user": iprange.user.username if iprange.user else "", "type": iprange.type, "vlan": iprange.subnet.vlan_id if iprange.subnet else None, } return data
def MatchesRenderedNotification(ntfn): """Return a matcher for a rendered notification.""" return MatchesDict( { "id": Equals(ntfn.id), "ident": Is(None) if ntfn.ident is None else Equals(ntfn.ident), "user": Is(None) if ntfn.user_id is None else Equals(ntfn.user_id), "users": Is(ntfn.users), "admins": Is(ntfn.admins), "updated": Equals(dehydrate_datetime(ntfn.updated)), "created": Equals(dehydrate_datetime(ntfn.created)), "message": Equals(ntfn.render()), "category": Equals(ntfn.category), } )
def dehydrate_event(self, event): data = { "id": event.id, "node_id": event.node.id, "action": event.action, "description": event.description, "type": { "level": dehydrate_event_type_level(event.type.level), "name": event.type.name, "description": event.type.description, }, "updated": dehydrate_datetime(event.updated), "created": dehydrate_datetime(event.created), } return data
def dehydrate_script(self, script): return { 'id': script.id, 'name': script.name, 'title': script.title, 'description': script.description, 'script_type': script.script_type, 'tags': script.tags, 'timeout': '0%s' % str(script.timeout), 'destructive': script.destructive, 'default': script.default, 'script': script.script_id, 'created': dehydrate_datetime(script.created), 'updated': dehydrate_datetime(script.updated), }
def dehydrate_service(self, service, for_list=False): data = { "id": service.id, "node": service.node.id, "name": service.name, "status": service.status, "status_info": service.status_info, "updated": dehydrate_datetime(service.updated), "created": dehydrate_datetime(service.created), } if for_list: del data["node"] del data["updated"] del data["created"] return data
def dehydrate(self, package_repository): return { 'id': package_repository.id, 'name': package_repository.name, 'url': package_repository.url, 'distributions': package_repository.distributions, 'disabled_pockets': package_repository.disabled_pockets, 'disabled_components': package_repository.disabled_components, 'components': package_repository.components, 'arches': package_repository.arches, 'key': package_repository.key, 'default': package_repository.default, 'enabled': package_repository.enabled, 'updated': dehydrate_datetime(package_repository.updated), 'created': dehydrate_datetime(package_repository.created), }
def dehydrate_discovery(self, discovery: Discovery, for_list=False): data = { "discovery_id": discovery.discovery_id, "fabric": discovery.fabric_id, "fabric_name": discovery.fabric_name, "hostname": discovery.hostname, "id": discovery.id, "ip": discovery.ip, "is_external_dhcp": discovery.is_external_dhcp, "mdns": discovery.mdns_id, "mac_address": discovery.mac_address, "mac_organization": discovery.mac_organization, "neighbour": discovery.neighbour_id, "observer": discovery.observer_id, "observer_hostname": discovery.observer_hostname, "observer_interface": discovery.observer_interface_id, "observer_interface_name": discovery.observer_interface_name, "observer_system_id": discovery.observer_system_id, "subnet": discovery.subnet_id, "subnet_cidr": discovery.subnet_cidr, "vid": discovery.vid, "vlan": discovery.vlan_id, "first_seen": str( time.mktime(discovery.first_seen.timetuple()) + discovery.first_seen.microsecond / 1e6 ), "last_seen": dehydrate_datetime(discovery.last_seen), } return data
def test_get_history(self): user = factory.make_User() handler = NodeResultHandler(user, {}, None) node = factory.make_Node(owner=user) script = factory.make_Script() script_results = [] for _ in range(10): script_set = factory.make_ScriptSet(node=node) script_results.append(factory.make_ScriptResult( script=script, script_set=script_set, status=SCRIPT_STATUS.PASSED)) latest_script_result = script_results[-1] script_results = sorted( script_results, key=lambda i: i.id, reverse=True) queries = CountQueries() with queries: ret = handler.get_history({'id': latest_script_result.id}) self.assertEqual(4, queries.num_queries) for script_result, out in zip(script_results, ret): self.assertDictEqual({ 'id': script_result.id, 'updated': dehydrate_datetime(script_result.updated), 'status': script_result.status, 'status_name': script_result.status_name, 'runtime': script_result.runtime, 'starttime': script_result.starttime, 'endtime': script_result.endtime, 'estimated_runtime': script_result.estimated_runtime, 'suppressed': script_result.suppressed, }, out)
def dehydrate_last_image_sync(self, last_image_sync): """Return formatted datetime.""" return ( dehydrate_datetime(last_image_sync) if last_image_sync is not None else None )
def test_get(self): user = factory.make_User() handler = ResourcePoolHandler(user, {}, None) pool = factory.make_ResourcePool() result = handler.get({"id": pool.id}) self.assertEqual( {'id': pool.id, 'name': pool.name, 'description': pool.description, 'is_default': False, 'created': dehydrate_datetime(pool.created), 'updated': dehydrate_datetime(pool.updated), 'machine_total_count': 0, 'machine_ready_count': 0, 'permissions': []}, result)
def dehydrate_events(self, obj): """Dehydrate the node events. The latests 50 not including DEBUG events will be dehydrated. The `EventsHandler` needs to be used if more are required. """ events = ( Event.objects.filter(node=obj) .exclude(type__level=logging.DEBUG) .select_related("type") .order_by("-id")[:50] ) return [ { "id": event.id, "type": { "id": event.type.id, "name": event.type.name, "description": event.type.description, "level": dehydrate_event_type_level(event.type.level), }, "description": event.description, "created": dehydrate_datetime(event.created), } for event in events ]
def get_history(self, params): """Return a list of historic results.""" id = params.get("id") script_result = (ScriptResult.objects.filter(id=id).only( "status", "script_id", "script_set_id", "physical_blockdevice_id", "interface_id", "script_name", ).first()) history_qs = script_result.history.only( "id", "updated", "status", "started", "ended", "script_id", "script_name", "script_set_id", "physical_blockdevice_id", "interface_id", "suppressed", ) return [{ "id": history.id, "updated": dehydrate_datetime(history.updated), "status": history.status, "status_name": history.status_name, "runtime": history.runtime, "starttime": history.starttime, "endtime": history.endtime, "estimated_runtime": history.estimated_runtime, "suppressed": history.suppressed, } for history in history_qs]
def dehydrate_user(self, user, sshkeys_count=0, for_self=False): data = { "id": user.id, "username": user.username, "first_name": user.first_name, "last_name": user.last_name, "email": user.email, "is_superuser": user.is_superuser, "sshkeys_count": sshkeys_count, "last_login": dehydrate_datetime(user.last_login), "is_local": user.userprofile.is_local, "completed_intro": user.userprofile.completed_intro, "machines_count": user.node_set.count(), } if for_self: permissions = [] if user.has_perm(NodePermission.admin): permissions.append("machine_create") if user.has_perm(NodePermission.view): permissions.append("device_create") if user.has_perm(ResourcePoolPermission.create): permissions.append("resource_pool_create") if user.has_perm(ResourcePoolPermission.delete): permissions.append("resource_pool_delete") if user.has_perm(PodPermission.create): permissions.append("pod_create") data["global_permissions"] = permissions return data
def dehydrate(self, package_repository): return { "id": package_repository.id, "name": package_repository.name, "url": package_repository.url, "distributions": package_repository.distributions, "disabled_pockets": package_repository.disabled_pockets, "disabled_components": package_repository.disabled_components, "disable_sources": package_repository.disable_sources, "components": package_repository.components, "arches": package_repository.arches, "key": package_repository.key, "default": package_repository.default, "enabled": package_repository.enabled, "updated": dehydrate_datetime(package_repository.updated), "created": dehydrate_datetime(package_repository.created), }
def test_get(self): user = factory.make_User() handler = ResourcePoolHandler(user, {}, None) pool = factory.make_ResourcePool() result = handler.get({"id": pool.id}) self.assertEqual( { "id": pool.id, "name": pool.name, "description": pool.description, "is_default": False, "created": dehydrate_datetime(pool.created), "updated": dehydrate_datetime(pool.updated), "machine_total_count": 0, "machine_ready_count": 0, "permissions": [], }, result, )
def dehydrate_subnet(self, subnet, for_list=False): data = { "id": subnet.id, "updated": dehydrate_datetime(subnet.updated), "created": dehydrate_datetime(subnet.created), "name": subnet.name, "description": subnet.description, "dns_servers": (" ".join(sorted(subnet.dns_servers)) if subnet.dns_servers is not None else ""), "vlan": subnet.vlan_id, "space": subnet.vlan.space_id, "rdns_mode": subnet.rdns_mode, "allow_dns": subnet.allow_dns, "allow_proxy": subnet.allow_proxy, "cidr": subnet.cidr, "gateway_ip": subnet.gateway_ip, "active_discovery": subnet.active_discovery, "managed": subnet.managed, } full_range = subnet.get_iprange_usage() metadata = IPRangeStatistics(full_range) data["statistics"] = metadata.render_json(include_ranges=True, include_suggestions=True) data["version"] = IPNetwork(subnet.cidr).version if not for_list: data["ip_addresses"] = subnet.render_json_for_related_ips( with_username=True, with_summary=True) return data
def dehydrate_script(self, script): return { 'id': script.id, 'name': script.name, 'title': script.title, 'description': script.description, 'tags': script.tags, 'script_type': script.script_type, 'hardware_type': script.hardware_type, 'parallel': script.parallel, 'results': json.dumps(script.results), 'parameters': json.dumps(script.parameters), 'packages': json.dumps(script.packages), 'timeout': '0%s' % str(script.timeout), 'destructive': script.destructive, 'default': script.default, 'script': script.script_id, 'created': dehydrate_datetime(script.created), 'updated': dehydrate_datetime(script.updated), }
def dehydrate_node_device(self, node_device): return { "id": node_device.id, "created": dehydrate_datetime(node_device.created), "updated": dehydrate_datetime(node_device.updated), "bus": node_device.bus, "hardware_type": node_device.hardware_type, "vendor_id": node_device.vendor_id, "product_id": node_device.product_id, "vendor_name": node_device.vendor_name, "product_name": node_device.product_name, "commissioning_driver": node_device.commissioning_driver, "bus_number": node_device.bus_number, "device_number": node_device.device_number, "pci_address": node_device.pci_address, "physical_blockdevice_id": node_device.physical_blockdevice_id, "physical_interface_id": node_device.physical_interface_id, "numa_node_id": node_device.numa_node_id, "node_id": node_device.node_id, }
def dehydrate_vlan(self, vlan, for_list=False): data = { "id": vlan.id, "name": vlan.name, "description": vlan.description, "vid": vlan.vid, "mtu": vlan.mtu, "fabric": vlan.fabric_id, "space": vlan.space_id, "updated": dehydrate_datetime(vlan.updated), "created": dehydrate_datetime(vlan.created), "dhcp_on": vlan.dhcp_on, "external_dhcp": vlan.external_dhcp, "primary_rack": vlan.primary_rack, "secondary_rack": vlan.secondary_rack, "relay_vlan": vlan.relay_vlan_id, } data["rack_sids"] = sorted( list( { interface.node.system_id for interface in vlan.interface_set.all() if interface.node_id is not None and interface.node.is_rack_controller } ) ) if not for_list: data["node_ids"] = sorted( list( { interface.node_id for interface in vlan.interface_set.all() if interface.node_id is not None } ) ) data["space_ids"] = sorted( {subnet.space.id for subnet in vlan.subnet_set.all()} ) return data
def dehydrate(self, obj, data, for_list=False): data.update({ 'sshkeys_count': obj.sshkeys_count, 'is_local': obj.userprofile.is_local, 'machines_count': obj.machines_count, 'last_login': dehydrate_datetime(obj.last_login) }) if obj.id == self.user.id: # User is reading information about itself, so provide the global # permissions. data['global_permissions'] = self._get_global_permissions() return data
def dehydrate_event(self, event): data = { "id": event.id, "node_id": event.node.id, "node_hostname": event.node_hostname, "user": event.user.id, "username": event.username, "ip_address": event.ip_address, "endpoint": event.endpoint, "user_agent": event.user_agent, "action": event.action, "description": event.description, "type": { "level": dehydrate_event_type_level(event.type.level), "name": event.type.name, "description": event.type.description, }, "updated": dehydrate_datetime(event.updated), "created": dehydrate_datetime(event.created), } return data
def dehydrate(self, obj, data, for_list=False): data.update({ "sshkeys_count": obj.sshkeys_count, "is_local": obj.userprofile.is_local, "completed_intro": obj.userprofile.completed_intro, "machines_count": obj.machines_count, "last_login": dehydrate_datetime(obj.last_login), }) if obj.id == self.user.id: # User is reading information about itself, so provide the global # permissions. data["global_permissions"] = self._get_global_permissions() return data
def dehydrate_dhcp_snippet(self, dhcp_snippet): node_system_id = None subnet_id = None iprange_id = None if dhcp_snippet.subnet is not None: subnet_id = dhcp_snippet.subnet.id if dhcp_snippet.iprange is not None: iprange_id = dhcp_snippet.iprange.id elif dhcp_snippet.node is not None: node_system_id = dhcp_snippet.node.system_id return { "id": dhcp_snippet.id, "name": dhcp_snippet.name, "description": dhcp_snippet.description, "value": dhcp_snippet.value.data, "history": [{ "id": value.id, "value": value.data, "created": format_datetime(value.created), } for value in dhcp_snippet.value.previous_versions()], "enabled": dhcp_snippet.enabled, "node": node_system_id, "subnet": subnet_id, "iprange": iprange_id, "updated": dehydrate_datetime(dhcp_snippet.updated), "created": dehydrate_datetime(dhcp_snippet.created), }
def dehydrate_script(self, script): return { "id": script.id, "name": script.name, "title": script.title, "description": script.description, "tags": script.tags, "script_type": script.script_type, "hardware_type": script.hardware_type, "parallel": script.parallel, "results": script.results, "parameters": script.parameters, "packages": script.packages, "timeout": "0%s" % str(script.timeout), "destructive": script.destructive, "default": script.default, "script": script.script_id, "for_hardware": script.for_hardware, "may_reboot": script.may_reboot, "recommission": script.recommission, "apply_configured_networking": script.apply_configured_networking, "created": dehydrate_datetime(script.created), "updated": dehydrate_datetime(script.updated), }
def dehydrate_script(self, script): return { 'id': script.id, 'name': script.name, 'title': script.title, 'description': script.description, 'tags': script.tags, 'script_type': script.script_type, 'hardware_type': script.hardware_type, 'parallel': script.parallel, 'results': json.dumps(script.results), 'parameters': json.dumps(script.parameters), 'packages': json.dumps(script.packages), 'timeout': '0%s' % str(script.timeout), 'destructive': script.destructive, 'default': script.default, 'script': script.script_id, 'for_hardware': script.for_hardware, 'may_reboot': script.may_reboot, 'recommission': script.recommission, 'apply_configured_networking': script.apply_configured_networking, 'created': dehydrate_datetime(script.created), 'updated': dehydrate_datetime(script.updated), }