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 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 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 _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 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_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 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
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
