def publish(self) -> None:
# pylint: disable=import-outside-toplevel; to avoid cyclic imports
from sdcm.sct_events.events_device import get_events_main_device
if not self._ready_to_publish:
LOGGER.warning("[SCT internal warning] %s is not ready to be published", self)
return
get_events_main_device(_registry=self._events_processes_registry).publish_event(self)
self._ready_to_publish = False
def test_start_get_events_main_device(self):
self.assertIsNone(
get_events_main_device(_registry=self.events_processes_registry))
start_events_main_device(_registry=self.events_processes_registry)
events_device = get_events_main_device(
_registry=self.events_processes_registry)
try:
self.assertIsInstance(events_device, EventsDevice)
self.assertEqual(events_device.events_counter, 0)
self.assertTrue(events_device.is_alive())
self.assertTrue(events_device.subscribe_address)
finally:
events_device.stop(timeout=1)
def publish_or_dump(self, default_logger: Optional[logging.Logger] = None) -> None:
# pylint: disable=import-outside-toplevel; to avoid cyclic imports
from sdcm.sct_events.events_device import get_events_main_device
if not self._ready_to_publish:
LOGGER.warning("[SCT internal warning] %s is not ready to be published", self)
return
if proc := get_events_main_device(_registry=self._events_processes_registry):
if proc.is_alive():
self.publish()
else:
from sdcm.sct_events.file_logger import get_events_logger
get_events_logger(_registry=self._events_processes_registry).write_event(self)
def publish_or_dump(self,
default_logger: Optional[logging.Logger] = None,
warn_not_ready: bool = True) -> None:
# pylint: disable=import-outside-toplevel; to avoid cyclic imports
from sdcm.sct_events.events_device import get_events_main_device
if not self._ready_to_publish:
if warn_not_ready:
LOGGER.warning(
"[SCT internal warning] %s is not ready to be published",
self)
return
try:
proc = get_events_main_device(
_registry=self._events_processes_registry)
except RuntimeError:
LOGGER.exception("Unable to get events main device")
proc = None
if proc:
if proc.is_alive():
self.publish()
else:
from sdcm.sct_events.file_logger import get_events_logger
get_events_logger(_registry=self._events_processes_registry
).write_event(self)
elif default_logger:
default_logger.error(str(self))
self._ready_to_publish = False
def __init__(self, _registry: EventsProcessesRegistry):
base_dir: Path = get_events_main_device(_registry=_registry).events_log_base_dir
self.events_log = base_dir / EVENTS_LOG
self.events_logs_by_severity = {
Severity.CRITICAL: base_dir / CRITICAL_LOG,
Severity.ERROR: base_dir / ERROR_LOG,
Severity.WARNING: base_dir / WARNING_LOG,
Severity.NORMAL: base_dir / NORMAL_LOG,
Severity.DEBUG: base_dir / DEBUG_LOG,
}
self.events_summary = collections.defaultdict(int)
self.events_summary_log = base_dir / SUMMARY_LOG
super().__init__(_registry=_registry)
def setup_events_processes(cls, events_device: bool,
events_main_device: bool,
registry_patcher: bool):
"""Setup own copy of Events Device machinery."""
cls.temp_dir = tempfile.mkdtemp()
cls.events_processes_registry = EventsProcessesRegistry(
log_dir=cls.temp_dir)
if registry_patcher:
cls.events_processes_registry_patcher = \
unittest.mock.patch("sdcm.sct_events.base.SctEvent._events_processes_registry",
cls.events_processes_registry)
cls.events_processes_registry_patcher.start()
if events_device:
start_events_device(_registry=cls.events_processes_registry)
elif events_main_device:
start_events_main_device(_registry=cls.events_processes_registry)
time.sleep(EVENTS_DEVICE_START_DELAY)
cls.events_main_device = get_events_main_device(
_registry=cls.events_processes_registry)
def get_raw_events_log(cls):
return get_events_main_device(
_registry=cls.events_processes_registry).raw_events_log
