def test_child_result_bubbles_up(self, report_start, report_finish):
parent = reporting.ReportEventStack("topname", "topdesc")
child = reporting.ReportEventStack("c_name", "c_desc", parent=parent)
with parent:
with child:
child.result = reporting.status.WARN
report_finish.assert_called_with("topname", "topdesc",
reporting.status.WARN)
def test_reporting_child_default_to_parent(self, report_start,
report_finish):
parent = reporting.ReportEventStack("pname",
"pdesc",
reporting_enabled=False)
child = reporting.ReportEventStack("cname", "cdesc", parent=parent)
with parent:
with child:
pass
pass
self.assertEqual(report_start.call_count, 0)
self.assertEqual(report_finish.call_count, 0)
def test_child_fullname_respects_parent(self, report_start):
parent_name = "topname"
c1_name = "c1name"
c2_name = "c2name"
c2_expected_fullname = '/'.join([parent_name, c1_name, c2_name])
c1_expected_fullname = '/'.join([parent_name, c1_name])
parent = reporting.ReportEventStack(parent_name, "topdesc")
c1 = reporting.ReportEventStack(c1_name, "c1desc", parent=parent)
c2 = reporting.ReportEventStack(c2_name, "c2desc", parent=c1)
with c1:
report_start.assert_called_with(c1_expected_fullname, "c1desc")
with c2:
report_start.assert_called_with(c2_expected_fullname, "c2desc")
def _get_data_source(self):
if self.datasource is not NULL_DATA_SOURCE:
return self.datasource
with reporting.ReportEventStack(
name="check-cache",
description="attempting to read from cache",
parent=self.reporter) as myrep:
ds = self._restore_from_cache()
if ds:
LOG.debug("Restored from cache, datasource: %s", ds)
myrep.description = "restored from cache"
else:
myrep.description = "no cache found"
if not ds:
(cfg_list, pkg_list) = self._get_datasources()
# Deep copy so that user-data handlers can not modify
# (which will affect user-data handlers down the line...)
(ds,
dsname) = sources.find_source(self.cfg, self.distro, self.paths,
copy.deepcopy(self.ds_deps),
cfg_list, pkg_list, self.reporter)
LOG.info("Loaded datasource %s - %s", dsname, ds)
self.datasource = ds
# Ensure we adjust our path members datasource
# now that we have one (thus allowing ipath to be used)
self._reset()
return ds
def test_reporting_event_has_sane_repr(self):
myrep = reporting.ReportEventStack("fooname",
"foodesc",
reporting_enabled=True).__repr__()
self.assertIn("fooname", myrep)
self.assertIn("foodesc", myrep)
self.assertIn("True", myrep)
def test_message_used_in_finish(self, report_finish):
with reporting.ReportEventStack("myname",
"mydesc",
message="mymessage"):
pass
self.assertEqual(
[mock.call("myname", "mymessage", reporting.status.SUCCESS)],
report_finish.call_args_list)
def test_start_and_finish_success(self, report_start, report_finish):
with reporting.ReportEventStack(name="myname", description="mydesc"):
pass
self.assertEqual([mock.call('myname', 'mydesc')],
report_start.call_args_list)
self.assertEqual(
[mock.call('myname', 'mydesc', reporting.status.SUCCESS)],
report_finish.call_args_list)
def consume_data(self, frequency=PER_INSTANCE):
# Consume the userdata first, because we need want to let the part
# handlers run first (for merging stuff)
with reporting.ReportEventStack("consume-user-data",
"reading and applying user-data",
parent=self.reporter):
self._consume_userdata(frequency)
with reporting.ReportEventStack("consume-vendor-data",
"reading and applying vendor-data",
parent=self.reporter):
self._consume_vendordata(frequency)
# Perform post-consumption adjustments so that
# modules that run during the init stage reflect
# this consumed set.
#
# They will be recreated on future access...
self._reset()
def __init__(self, init, cfg_files=None, reporter=None):
self.init = init
self.cfg_files = cfg_files
# Created on first use
self._cached_cfg = None
if reporter is None:
reporter = reporting.ReportEventStack(name="module-reporter",
description="module-desc",
reporting_enabled=False)
self.reporter = reporter
def test_finish_exception_defaults_fail(self, report_start, report_finish):
name = "myname"
desc = "mydesc"
try:
with reporting.ReportEventStack(name, description=desc):
raise ValueError("This didnt work")
except ValueError:
pass
self.assertEqual([mock.call(name, desc)], report_start.call_args_list)
self.assertEqual([mock.call(name, desc, reporting.status.FAIL)],
report_finish.call_args_list)
def __init__(self, datasource, paths, cfg, distro, runners, reporter=None):
self.datasource = datasource
self.paths = paths
self.distro = distro
self._cfg = cfg
self._runners = runners
if reporter is None:
reporter = reporting.ReportEventStack(
name="unnamed-cloud-reporter",
description="unnamed-cloud-reporter",
reporting_enabled=False)
self.reporter = reporter
def test_result_on_exception_used(self, report_start, report_finish):
name = "myname"
desc = "mydesc"
try:
with reporting.ReportEventStack(
name, desc, result_on_exception=reporting.status.WARN):
raise ValueError("This didnt work")
except ValueError:
pass
self.assertEqual([mock.call(name, desc)], report_start.call_args_list)
self.assertEqual([mock.call(name, desc, reporting.status.WARN)],
report_finish.call_args_list)
def __init__(self, ds_deps=None, reporter=None):
if ds_deps is not None:
self.ds_deps = ds_deps
else:
self.ds_deps = [sources.DEP_FILESYSTEM, sources.DEP_NETWORK]
# Created on first use
self._cfg = None
self._paths = None
self._distro = None
# Changed only when a fetch occurs
self.datasource = NULL_DATA_SOURCE
if reporter is None:
reporter = reporting.ReportEventStack(name="init-reporter",
description="init-desc",
reporting_enabled=False)
self.reporter = reporter
def _run_modules(self, mostly_mods):
cc = self.init.cloudify()
# Return which ones ran
# and which ones failed + the exception of why it failed
failures = []
which_ran = []
for (mod, name, freq, args) in mostly_mods:
try:
# Try the modules frequency, otherwise fallback to a known one
if not freq:
freq = mod.frequency
if freq not in FREQUENCIES:
freq = PER_INSTANCE
LOG.debug("Running module %s (%s) with frequency %s", name,
mod, freq)
# Use the configs logger and not our own
# TODO(harlowja): possibly check the module
# for having a LOG attr and just give it back
# its own logger?
func_args = [name, self.cfg, cc, config.LOG, args]
# Mark it as having started running
which_ran.append(name)
# This name will affect the semaphore name created
run_name = "config-%s" % (name)
desc = "running %s with frequency %s" % (run_name, freq)
myrep = reporting.ReportEventStack(name=run_name,
description=desc,
parent=self.reporter)
with myrep:
ran, _r = cc.run(run_name,
mod.handle,
func_args,
freq=freq)
if ran:
myrep.message = "%s ran successfully" % run_name
else:
myrep.message = "%s previously ran" % run_name
except Exception as e:
util.logexc(LOG, "Running module %s (%s) failed", name, mod)
failures.append((name, e))
return (which_ran, failures)
def test_set_invalid_result_raises_value_error(self):
f = reporting.ReportEventStack("myname", "mydesc")
self.assertRaises(ValueError, setattr, f, "result", "BOGUS")
def test_message_updatable(self, report_finish):
with reporting.ReportEventStack("myname", "mydesc") as c:
c.message = "all good"
self.assertEqual(
[mock.call("myname", "all good", reporting.status.SUCCESS)],
report_finish.call_args_list)
def test_reporting_disabled_does_not_report_events(self, report_start,
report_finish):
with reporting.ReportEventStack("a", "b", reporting_enabled=False):
pass
self.assertEqual(report_start.call_count, 0)
self.assertEqual(report_finish.call_count, 0)
