def __init__(self, test_run_factory, **kwargs):
self.test_run_factory = test_run_factory
self.test_run_kwargs = kwargs
self.dispatcher = DispatcherQueue()
# Register handlers to incrementally add information
register = self.dispatcher.registerHandler
register(("cpu", "architecture",), self.addCpuArchitecture)
register(("identifier",), self.addIdentifier)
register(("test_run", "attachment",), self.addAttachment)
register(("test_run", "device",), self.addDeviceState)
register(("test_run", "dmi_device",), self.addDmiDeviceState)
register(("test_run", "distribution",), self.setDistribution)
register(("test_run", "package_version",), self.addPackageVersion)
register(("test_run", "test_result",), self.addTestResult)
# Register handlers to set information once
register(("architecture",), self.setArchitecture, count=1)
register(
("cpuinfo", "machine", "cpuinfo_result",),
self.setCpuinfo, count=1)
register(
("meminfo", "meminfo_result",),
self.setMeminfo, count=1)
register(
("project", "series",),
self.setTestRun, count=1)
register(
("test_run", "architecture",),
self.setArchitectureState, count=1)
register(
("test_run", "kernel",),
self.setKernelState, count=1)
register(
("test_run", "memory",),
self.setMemoryState, count=1)
register(
("test_run", "processor",),
self.setProcessorState, count=1)
register(
("udevadm", "bits", "udevadm_result",),
self.setUdevadm, count=1)
# Publish events passed as keyword arguments
if "project" in kwargs:
self.dispatcher.publishEvent("project", kwargs.pop("project"))
self.dispatcher.publishEvent("series", kwargs.pop("series", None))
class SubmissionResult:
def __init__(self, test_run_factory, **kwargs):
self.test_run_factory = test_run_factory
self.test_run_kwargs = kwargs
self.dispatcher = DispatcherQueue()
# Register handlers to incrementally add information
register = self.dispatcher.registerHandler
register(("cpu", "architecture",), self.addCpuArchitecture)
register(("identifier",), self.addIdentifier)
register(("test_run", "attachment",), self.addAttachment)
register(("test_run", "device",), self.addDeviceState)
register(("test_run", "dmi_device",), self.addDmiDeviceState)
register(("test_run", "distribution",), self.setDistribution)
register(("test_run", "package_version",), self.addPackageVersion)
register(("test_run", "test_result",), self.addTestResult)
# Register handlers to set information once
register(("architecture",), self.setArchitecture, count=1)
register(
("cpuinfo", "machine", "cpuinfo_result",),
self.setCpuinfo, count=1)
register(
("meminfo", "meminfo_result",),
self.setMeminfo, count=1)
register(
("project", "series",),
self.setTestRun, count=1)
register(
("test_run", "architecture",),
self.setArchitectureState, count=1)
register(
("test_run", "memory",),
self.setMemoryState, count=1)
register(
("test_run", "processor",),
self.setProcessorState, count=1)
register(
("udevadm", "bits", "udevadm_result",),
self.setUdevadm, count=1)
# Publish events passed as keyword arguments
if "project" in kwargs:
self.dispatcher.publishEvent("project", kwargs.pop("project"))
self.dispatcher.publishEvent("series", kwargs.pop("series", None))
def addAttachment(self, test_run, attachment):
test_run.addAttachment(**attachment)
def addContext(self, text, command=None):
if text.strip() == "Command not found.":
return
self.dispatcher.publishEvent(
"attachment", {"name": command, "content": text})
context_parsers = {
"/proc/cpuinfo": self.parseCpuinfo,
"meminfo": self.parseMeminfo,
"dmidecode": DmidecodeParser,
"udevadm": self.parseUdevadm,
"efi": EfiParser,
}
for context, parser in context_parsers.items():
if context in command:
if hasattr(text, "decode"):
text = text.decode("utf-8")
stream = StringIO(text)
p = parser(stream)
p.run(self)
def addCpu(self, cpu):
self.dispatcher.publishEvent("cpu", cpu)
def addCpuArchitecture(self, cpu, architecture):
if cpu["debian_name"] == architecture:
self.dispatcher.publishEvent("machine", cpu["gnu_name"])
self.dispatcher.publishEvent("bits", cpu["bits"])
def addDevice(self, device):
self.dispatcher.publishEvent("device", device)
def addDeviceState(self, test_run, device):
test_run.addDeviceState(
bus_name=device.bus, category_name=device.category,
product_name=device.product, vendor_name=device.vendor,
product_id=device.product_id, vendor_id=device.vendor_id,
subproduct_id=device.subproduct_id,
subvendor_id=device.subvendor_id,
driver_name=device.driver, path=device.path)
def addDmiDevice(self, device):
if device.serial:
self.dispatcher.publishEvent("identifier", device.serial)
if device.category in ("BOARD", "SYSTEM") \
and device.vendor != device.product \
and device.product is not None:
self.dispatcher.publishEvent("model", device.product)
self.dispatcher.publishEvent("make", device.vendor)
self.dispatcher.publishEvent("version", device.version)
if device.category != "DEVICE":
self.dispatcher.publishEvent("dmi_device", device)
def addDmiDeviceState(self, test_run, dmi_device):
test_run.addDeviceState(
bus_name="dmi", category_name=dmi_device.category,
product_name=dmi_device.product, vendor_name=dmi_device.vendor,
product_id=None, vendor_id=None,
subproduct_id=None, subvendor_id=None,
driver_name=None, path=dmi_device.path)
def addIdentifier(self, identifier):
try:
self.identifiers.append(identifier)
except AttributeError:
self.identifiers = [identifier]
self.dispatcher.publishEvent("identifiers", self.identifiers)
def addPackage(self, package):
package_version = {
"name": package["name"],
"version": package["properties"]["version"],
}
self.dispatcher.publishEvent("package_version", package_version)
def addPackageVersion(self, test_run, package_version):
test_run.addPackageVersion(**package_version)
def addQuestion(self, question):
answer_to_status = {
"fail": FAIL,
"no": FAIL,
"pass": PASS,
"skip": UNTESTED,
"uninitiated": UNINITIATED,
"unresolved": UNRESOLVED,
"unsupported": UNSUPPORTED,
"untested": UNTESTED,
"yes": PASS,
}
test_result = dict(
name=question["name"],
output=question["comment"],
status=answer_to_status[question["answer"]["value"]],
)
test_result.update(self.test_run_kwargs)
self.dispatcher.publishEvent("test_result", test_result)
def addTestResult(self, test_run, test_result):
test_run.addTestResult(**test_result)
def addSummary(self, name, value):
if name == "architecture":
self.dispatcher.publishEvent("architecture", value)
elif name == "distribution":
self.dispatcher.publishEvent("project", value)
elif name == "distroseries":
self.dispatcher.publishEvent("series", value)
def parseCpuinfo(self, cpuinfo):
self.dispatcher.publishEvent("cpuinfo", cpuinfo)
return DeferredParser(self.dispatcher, "cpuinfo_result")
def parseMeminfo(self, meminfo):
self.dispatcher.publishEvent("meminfo", meminfo)
return DeferredParser(self.dispatcher, "meminfo_result")
def parseUdevadm(self, udevadm):
self.dispatcher.publishEvent("udevadm", udevadm)
return DeferredParser(self.dispatcher, "udevadm_result")
def setArchitecture(self, architecture):
string = resource_string(parsers.__name__, "cputable")
stream = StringIO(string.decode("utf-8"))
parser = CputableParser(stream)
parser.run(self)
def setArchitectureState(self, test_run, architecture):
test_run.setArchitectureState(architecture)
def setCpuinfo(self, cpuinfo, machine, cpuinfo_result):
parser = CpuinfoParser(cpuinfo, machine)
parser.run(cpuinfo_result)
def setEfiDevice(self, device):
self.dispatcher.publishEvent("dmi_device", device)
def setMeminfo(self, meminfo, meminfo_result):
parser = MeminfoParser(meminfo)
parser.run(meminfo_result)
def setDistribution(self, test_run, distribution):
test_run.setDistribution(**distribution)
def setLSBRelease(self, lsb_release):
self.dispatcher.publishEvent("distribution", lsb_release)
def setMemory(self, memory):
self.dispatcher.publishEvent("memory", memory)
def setMemoryState(self, test_run, memory):
test_run.setMemoryState(**memory)
def setProcessor(self, processor):
self.dispatcher.publishEvent("processor", processor)
def setProcessorState(self, test_run, processor):
test_run.setProcessorState(
platform_name=processor["platform"],
make=processor["type"], model=processor["model"],
model_number=processor["model_number"],
model_version=processor["model_version"],
model_revision=processor["model_revision"],
cache=processor["cache"], other=processor["other"],
bogomips=processor["bogomips"], speed=processor["speed"],
count=processor["count"])
def setTestRun(self, project, series):
test_run = self.test_run_factory(
**self.test_run_kwargs)
self.dispatcher.publishEvent("test_run", test_run)
def setUdevadm(self, udevadm, bits, udevadm_result):
parser = UdevadmParser(udevadm, bits)
parser.run(udevadm_result)
def __init__(self, test_run_factory, **kwargs):
self.test_run_factory = test_run_factory
self.test_run_kwargs = kwargs
self.dispatcher = DispatcherQueue()
# Register handlers to incrementally add information
register = self.dispatcher.registerHandler
register((
"cpu",
"architecture",
), self.addCpuArchitecture)
register(("identifier", ), self.addIdentifier)
register((
"test_run",
"attachment",
), self.addAttachment)
register((
"test_run",
"device",
), self.addDeviceState)
register((
"test_run",
"dmi_device",
), self.addDmiDeviceState)
register((
"test_run",
"distribution",
), self.setDistribution)
register((
"test_run",
"package_version",
), self.addPackageVersion)
register((
"test_run",
"test_result",
), self.addTestResult)
# Register handlers to set information once
register(("architecture", ), self.setArchitecture, count=1)
register((
"cpuinfo",
"machine",
"cpuinfo_result",
),
self.setCpuinfo,
count=1)
register((
"meminfo",
"meminfo_result",
), self.setMeminfo, count=1)
register((
"project",
"series",
), self.setTestRun, count=1)
register((
"test_run",
"architecture",
),
self.setArchitectureState,
count=1)
register((
"test_run",
"kernel",
), self.setKernelState, count=1)
register((
"test_run",
"memory",
), self.setMemoryState, count=1)
register((
"test_run",
"processor",
), self.setProcessorState, count=1)
register((
"udevadm",
"bits",
"udevadm_result",
),
self.setUdevadm,
count=1)
# Publish events passed as keyword arguments
if "project" in kwargs:
self.dispatcher.publishEvent("project", kwargs.pop("project"))
self.dispatcher.publishEvent("series", kwargs.pop("series", None))
class SubmissionResult:
def __init__(self, test_run_factory, **kwargs):
self.test_run_factory = test_run_factory
self.test_run_kwargs = kwargs
self.dispatcher = DispatcherQueue()
# Register handlers to incrementally add information
register = self.dispatcher.registerHandler
register((
"cpu",
"architecture",
), self.addCpuArchitecture)
register(("identifier", ), self.addIdentifier)
register((
"test_run",
"attachment",
), self.addAttachment)
register((
"test_run",
"device",
), self.addDeviceState)
register((
"test_run",
"dmi_device",
), self.addDmiDeviceState)
register((
"test_run",
"distribution",
), self.setDistribution)
register((
"test_run",
"package_version",
), self.addPackageVersion)
register((
"test_run",
"test_result",
), self.addTestResult)
# Register handlers to set information once
register(("architecture", ), self.setArchitecture, count=1)
register((
"cpuinfo",
"machine",
"cpuinfo_result",
),
self.setCpuinfo,
count=1)
register((
"meminfo",
"meminfo_result",
), self.setMeminfo, count=1)
register((
"project",
"series",
), self.setTestRun, count=1)
register((
"test_run",
"architecture",
),
self.setArchitectureState,
count=1)
register((
"test_run",
"kernel",
), self.setKernelState, count=1)
register((
"test_run",
"memory",
), self.setMemoryState, count=1)
register((
"test_run",
"processor",
), self.setProcessorState, count=1)
register((
"udevadm",
"bits",
"udevadm_result",
),
self.setUdevadm,
count=1)
# Publish events passed as keyword arguments
if "project" in kwargs:
self.dispatcher.publishEvent("project", kwargs.pop("project"))
self.dispatcher.publishEvent("series", kwargs.pop("series", None))
def addAttachment(self, test_run, attachment):
test_run.addAttachment(**attachment)
def addContext(self, text, command=None):
if text.strip() == "Command not found.":
return
self.dispatcher.publishEvent("attachment", {
"name": command,
"content": text
})
context_parsers = {
"/proc/cpuinfo": self.parseCpuinfo,
"meminfo": self.parseMeminfo,
"dmidecode": DmidecodeParser,
"udevadm": self.parseUdevadm,
"efi": EfiParser,
}
for context, parser in context_parsers.items():
if context in command:
if hasattr(text, "decode"):
text = text.decode("utf-8")
stream = StringIO(text)
p = parser(stream)
p.run(self)
def addCpu(self, cpu):
self.dispatcher.publishEvent("cpu", cpu)
def addCpuArchitecture(self, cpu, architecture):
if cpu["debian_name"] == architecture:
self.dispatcher.publishEvent("machine", cpu["gnu_name"])
self.dispatcher.publishEvent("bits", cpu["bits"])
def addDevice(self, device):
self.dispatcher.publishEvent("device", device)
def addDeviceState(self, test_run, device):
test_run.addDeviceState(bus_name=device.bus,
category_name=device.category,
product_name=device.product,
vendor_name=device.vendor,
product_id=device.product_id,
vendor_id=device.vendor_id,
subproduct_id=device.subproduct_id,
subvendor_id=device.subvendor_id,
driver_name=device.driver,
path=device.path)
def addDmiDevice(self, device):
if device.serial:
self.dispatcher.publishEvent("identifier", device.serial)
if device.category in ("BOARD", "SYSTEM") \
and device.vendor != device.product \
and device.product is not None:
self.dispatcher.publishEvent("model", device.product)
self.dispatcher.publishEvent("make", device.vendor)
self.dispatcher.publishEvent("version", device.version)
if device.category != "DEVICE":
self.dispatcher.publishEvent("dmi_device", device)
def addDmiDeviceState(self, test_run, dmi_device):
test_run.addDeviceState(bus_name="dmi",
category_name=dmi_device.category,
product_name=dmi_device.product,
vendor_name=dmi_device.vendor,
product_id=None,
vendor_id=None,
subproduct_id=None,
subvendor_id=None,
driver_name=None,
path=dmi_device.path)
def addIdentifier(self, identifier):
try:
self.identifiers.append(identifier)
except AttributeError:
self.identifiers = [identifier]
self.dispatcher.publishEvent("identifiers", self.identifiers)
def addPackage(self, package):
package_version = {
"name": package["name"],
"version": package["properties"]["version"],
}
self.dispatcher.publishEvent("package_version", package_version)
def addPackageVersion(self, test_run, package_version):
test_run.addPackageVersion(**package_version)
def addQuestion(self, question):
answer_to_status = {
"fail": FAIL,
"no": FAIL,
"pass": PASS,
"skip": UNTESTED,
"uninitiated": UNINITIATED,
"unresolved": UNRESOLVED,
"unsupported": UNSUPPORTED,
"untested": UNTESTED,
"yes": PASS,
}
test_result = dict(
name=question["name"],
output=question["comment"],
status=answer_to_status[question["answer"]["value"]],
)
test_result.update(self.test_run_kwargs)
self.dispatcher.publishEvent("test_result", test_result)
def addTestResult(self, test_run, test_result):
test_run.addTestResult(**test_result)
def addSummary(self, name, value):
if name == "architecture":
self.dispatcher.publishEvent("architecture", value)
elif name == "distribution":
self.dispatcher.publishEvent("project", value)
elif name == "distroseries":
self.dispatcher.publishEvent("series", value)
elif name == "kernel-release":
self.dispatcher.publishEvent("kernel", value)
def parseCpuinfo(self, cpuinfo):
self.dispatcher.publishEvent("cpuinfo", cpuinfo)
return DeferredParser(self.dispatcher, "cpuinfo_result")
def parseMeminfo(self, meminfo):
self.dispatcher.publishEvent("meminfo", meminfo)
return DeferredParser(self.dispatcher, "meminfo_result")
def parseUdevadm(self, udevadm):
self.dispatcher.publishEvent("udevadm", udevadm)
return DeferredParser(self.dispatcher, "udevadm_result")
def setArchitecture(self, architecture):
string = resource_string(parsers.__name__, "cputable")
stream = StringIO(string.decode("utf-8"))
parser = CputableParser(stream)
parser.run(self)
def setArchitectureState(self, test_run, architecture):
test_run.setArchitectureState(architecture)
def setKernelState(self, test_run, kernel):
test_run.setKernelState(kernel)
def setCpuinfo(self, cpuinfo, machine, cpuinfo_result):
parser = CpuinfoParser(cpuinfo, machine)
parser.run(cpuinfo_result)
def setEfiDevice(self, device):
self.dispatcher.publishEvent("dmi_device", device)
def setMeminfo(self, meminfo, meminfo_result):
parser = MeminfoParser(meminfo)
parser.run(meminfo_result)
def setDistribution(self, test_run, distribution):
test_run.setDistribution(**distribution)
def setLSBRelease(self, lsb_release):
self.dispatcher.publishEvent("distribution", lsb_release)
def setMemory(self, memory):
self.dispatcher.publishEvent("memory", memory)
def setMemoryState(self, test_run, memory):
test_run.setMemoryState(**memory)
def setProcessor(self, processor):
self.dispatcher.publishEvent("processor", processor)
def setProcessorState(self, test_run, processor):
test_run.setProcessorState(platform_name=processor["platform"],
make=processor["type"],
model=processor["model"],
model_number=processor["model_number"],
model_version=processor["model_version"],
model_revision=processor["model_revision"],
cache=processor["cache"],
other=processor["other"],
bogomips=processor["bogomips"],
speed=processor["speed"],
count=processor["count"])
def setTestRun(self, project, series):
test_run = self.test_run_factory(**self.test_run_kwargs)
self.dispatcher.publishEvent("test_run", test_run)
def setUdevadm(self, udevadm, bits, udevadm_result):
parser = UdevadmParser(udevadm, bits)
parser.run(udevadm_result)
