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)