def driver_get_all(self, ctx, driver_names, action, retry_on_fault=False):
"""Call get_all for specified drivers"""
LOG.debug("run drivers get_all: %s %s", driver_names, action)
drivers = utils.get_drivers_by_name(self.conf, driver_names)
fault_interval = self.conf.datasources.snapshot_interval_on_fault
def run_driver(driver):
ok = True
try:
return ok, driver.get_all(action)
except Exception as e:
LOG.exception('driver failed %s', e)
return not ok, driver
result = list(self.pool.map(run_driver, drivers))
failed_drivers = [driver for success, driver in result if not success]
if failed_drivers and retry_on_fault:
LOG.info('retrying failed drivers in %s seconds', fault_interval)
time.sleep(fault_interval)
result.extend(list(self.pool.map(run_driver, failed_drivers)))
events = [e for success, events in result if success for e in events]
if self.async_persistor:
self.async_persistor(events)
LOG.debug("run drivers get_all done.")
return events
def init(self):
driver_names = utils.get_push_drivers_names(self._conf)
push_drivers = utils.get_drivers_by_name(self._conf, driver_names)
for driver in push_drivers:
for event in driver.get_event_types():
self._enrich_event_methods[event].append(driver.enrich_event)
return self
def test_datasource_update_method_push(self):
driver_names = ds_utils.get_push_drivers_names()
push_drivers = ds_utils.get_drivers_by_name(driver_names)
self.assertSequenceEqual({utils.import_class(
self.conf[NOVA_INSTANCE_DATASOURCE].driver), utils.import_class(
self.conf[ZABBIX_DATASOURCE_PUSH].driver)},
set(d.__class__ for d in push_drivers))
def driver_get_changes(self, ctx, driver_name):
"""Call get_changes for a specific driver"""
LOG.debug("run driver get_changes: %s", driver_name)
drivers = utils.get_drivers_by_name(self.conf, [driver_name])
events = drivers[0].get_changes(DatasourceAction.UPDATE)
LOG.debug("run driver get_changes: %s done.", driver_name)
return events
def get_all(self, driver_name, action):
try:
LOCK_BY_DRIVER.acquire(driver_name)
driver = utils.get_drivers_by_name([driver_name])[0]
LOG.info("run driver get_all: %s", driver_name)
now = format_utcnow()
events = driver.get_all(action)
count = self.process_output_func(events)
LOG.info("run driver get_all: %s done (%s events)", driver_name,
count)
if driver.should_delete_outdated_entities():
vertices_to_delete = \
self._find_vertices_to_delete(driver_name, now)
if vertices_to_delete:
delete_events = self._to_events(vertices_to_delete)
count_deleted = self.process_output_func(delete_events)
LOG.info(
"run driver delete outdated vertices: %s done "
"(%s events)", driver_name, count_deleted)
count += count_deleted
return count
except Exception:
LOG.exception("run driver get_all: %s Failed", driver_name)
finally:
LOCK_BY_DRIVER.release(driver_name)
return 0
def _create_callbacks_by_events_dict(cls, conf):
ret = defaultdict(list)
driver_names = utils.get_push_drivers_names(conf)
push_drivers = utils.get_drivers_by_name(conf, driver_names)
for driver in push_drivers:
for event in driver.get_event_types():
ret[event].append(driver.enrich_event)
return ret
def get_all(self, driver_name, action):
try:
LOCK_BY_DRIVER.acquire(driver_name)
driver = utils.get_drivers_by_name(self.conf, [driver_name])[0]
LOG.info("run driver get_all: %s", driver_name)
events = driver.get_all(action)
count = self.process_output_func(events)
LOG.info("run driver get_all: %s done (%s events)", driver_name,
count)
return count
except Exception:
LOG.exception("run driver get_all: %s Failed", driver_name)
finally:
LOCK_BY_DRIVER.release(driver_name)
return 0
def get_changes(self, driver_name):
if not LOCK_BY_DRIVER.acquire(driver_name, blocking=False):
LOG.info("%s get_changes canceled during get_all execution",
driver_name)
return 0
try:
driver = utils.get_drivers_by_name(self.conf, [driver_name])[0]
LOG.info("run driver get_changes: %s", driver_name)
events = driver.get_changes(DatasourceAction.UPDATE)
count = self.process_output_func(events)
LOG.info("run driver get_changes: %s done (%s events)",
driver_name, count)
return count
except Exception:
LOG.exception("run driver get_changes: %s Failed", driver_name)
finally:
LOCK_BY_DRIVER.release(driver_name)
return 0