def test_zlib_compressed_data(self): import zlib from ralph.util import uncompress_base64_data raw = "Zażółć gęślą jaźń.".encode('utf8') compressed = zlib.compress(raw) self.assertEqual(uncompress_base64_data(compressed), raw)
def test_base64_encoded_data(self): import base64 from ralph.util import uncompress_base64_data raw = "Zażółć gęślą jaźń.".encode('utf8') encoded = base64.b64encode(raw) self.assertEqual(uncompress_base64_data(encoded), raw)
def _parse_lshw(lshw, is_virtual, sn=None): data = uncompress_base64_data(lshw) if sn in SERIAL_BLACKLIST: sn = None device_info = handle_lshw(data, is_virtual) if sn: device_info['serial_number'] = sn return device_info
def handle_facts_os(facts, is_virtual=False): result = {} try: os_name = "%s %s" % ( facts['operatingsystem'], facts['operatingsystemrelease'], ) family = facts['kernel'] except KeyError: return result os_version = facts.get('kernelrelease', '') result['system_label'] = '%s%s' % ( os_name, ' %s' % os_version if os_version else '', ) result['system_family'] = family memory_size = None try: memory_size, unit = re.split('\s+', facts['memorysize'].lower()) if unit == 'tb': memory_size = int(float(memory_size) * 1024 * 1024) elif unit == 'gb': memory_size = int(float(memory_size) * 1024) elif unit == 'mb' or unit == 'mib': memory_size = int(float(memory_size)) except (KeyError, ValueError): pass if memory_size: result['system_memory'] = memory_size cores_key = ('physical' if not is_virtual else '') + 'processorcount' try: cores_count = int(facts.get(cores_key)) except TypeError: pass else: result['system_cores_count'] = cores_count storage_size = _get_storage_size_from_facts(facts) if not storage_size: lshw = facts.get('lshw', None) if lshw: try: lshw = uncompress_base64_data(lshw) except TypeError: pass else: try: lshw = parse_lshw(lshw) except LshwError: pass else: storages = handle_lshw_storage(lshw) storage_size = 0 for storage in storages: storage_size += storage['size'] if storage_size: result['system_storage'] = storage_size return result
def test_base64_encoded_zlib_compressed_data(self): import base64 import zlib from ralph.util import uncompress_base64_data raw = "Zażółć gęślą jaźń.".encode("utf8") compressed = zlib.compress(raw) encoded = base64.b64encode(compressed) self.assertEqual(uncompress_base64_data(encoded), raw)
def test_wrong_way__zlib_compressed_base64_encoded_data(self): """Here the input is made by zlib(base64(raw_data)) instead of base64(zlib(raw_data)). uncompress_base64_data should return the base64 representation.""" import base64 import zlib from ralph.util import uncompress_base64_data raw = "Zażółć gęślą jaźń.".encode('utf8') encoded = base64.b64encode(raw) compressed = zlib.compress(encoded) self.assertEqual(uncompress_base64_data(compressed), encoded)
def parse_lshw(data, facts, is_virtual): data = uncompress_base64_data(data) sn = facts.get("serialnumber") # use a Puppet fact because lshw gives # wrong serial numbers if sn in SERIAL_BLACKLIST: sn = None try: dev = lshw.handle_lshw(data, is_virtual, sn, SAVE_PRIORITY) except lshw.Error as e: return False, unicode(e) ip_addresses, ethernets_facts = handle_facts_ethernets(facts) assign_ips(dev, ip_addresses) return dev, dev.model.name
def parse_packages(facts): data = uncompress_base64_data(facts) if data: packages = data.strip().split(',') for package in packages: try: name, version = package.split(None, 1) except ValueError: continue yield { 'name': name, 'version': version, }
def parse_lshw(data, facts, is_virtual): data = uncompress_base64_data(data) sn = facts.get('serialnumber') # use a Puppet fact because lshw gives # wrong serial numbers if sn in SERIAL_BLACKLIST: sn = None try: dev = lshw.handle_lshw(data, is_virtual, sn, SAVE_PRIORITY) except lshw.Error as e: return False, unicode(e) ip_addresses, ethernets_facts = handle_facts_ethernets(facts) assign_ips(dev, ip_addresses) return dev, dev.model.name
def _parse_packages(facts): data = uncompress_base64_data(facts) if data: packages = data.strip().split(',') for package in packages: try: name, version = package.split(None, 1) except ValueError: continue yield { 'name': name, 'version': version, }
def _parse_smbios(dev, data, facts, is_virtual): data = uncompress_base64_data(data) smb = hardware.parse_smbios(data) hardware.handle_smbios(dev, smb, is_virtual, SAVE_PRIORITY)
def handle_facts_smbios(fact_smbios, is_virtual): raw_smbios = uncompress_base64_data(fact_smbios) smbios = _parse_smbios(raw_smbios) detected_memory = [] for memory_chip in smbios.get('MEMDEVICE', ()): try: size, size_units = memory_chip.get('Size', '').split(' ', 1) size = int(size) size /= units.size_divisor[size_units] size = int(size) except ValueError: continue # empty slot for split_key in ('BANK', 'Slot '): try: bank = memory_chip.get('Bank Locator').split(split_key)[1] bank = int(bank) + 1 break except (IndexError, ValueError): bank = None # unknown bank if bank is None: continue detected_memory.append({ 'label': "{}{} {}".format( 'Virtual ' if is_virtual else '', memory_chip.get( 'Device Locator', memory_chip.get('Location Tag', 'DIMM'), ), memory_chip.get('Part Number', ''), ), 'size': size, }) detected_cpus = [] for cpu in smbios.get('PROCESSOR', ()): m = DENSE_SPEED_REGEX.match(cpu.get('Maximum Speed', '')) if not m: continue if 'enabled' not in cpu.get('Processor Status', ''): continue speed = int(m.group(1)) speed_units = m.group(2) speed /= units.speed_divisor[speed_units] speed = int(speed) label = cpu['Location Tag'] family = cpu['Family'] if '(other)' in family: family = cpu['Manufacturer'] index_parts = [] for cpu_part in cpu['Location Tag'].replace('CPU', '').split(): try: index_parts.append(int(cpu_part.strip())) except ValueError: continue index = reduce(lambda x, y: x * y, index_parts) model_name = " ".join(cpu.get('Version', family).split()) detected_cpus.append({ 'model_name': model_name, 'speed': speed, 'cores': max(1, cores_from_model(model_name)), 'family': family, 'label': label, 'index': index, }) return detected_cpus, detected_memory