def map_user_input_to_available_plugins(self):
parsed_plugin_list = [self.parsed_disruptor_config,
self.parsed_monitor_config,
self.parsed_runner_config]
for parsed_config_data in parsed_plugin_list:
for plugin in parsed_config_data:
plugin_data = parsed_config_data.get(plugin, None)
if plugin_data:
for plugin_data_item in plugin_data:
for plugin_item, item_data in \
plugin_data[plugin_data_item].items():
plugin_key = plugin + "::" + plugin_data_item
self.node_plugin_map[plugin_item] = \
plugin_data_item
if self.plugin_input_data.get(plugin_key, None):
self.plugin_input_data.get(plugin_key).\
append({plugin_item: item_data})
else:
self.plugin_input_data[plugin_key] = \
[{plugin_item: item_data}]
else:
LOG.warning("No input data given for plugin %s", plugin)
common.dump_on_console(self.node_plugin_map, "Node Plugin Map")
def __init__(self, parser):
"""
Get the resource form haparser as input parameter and creates
all the objects that are needed to run the executor.
"""
# Resoruce from haparser
self.executor_threads = []
self.executor_data = parser.parsed_executor_config
self.plugin_to_class_map = parser.plugin_to_class_map
self.node_plugin_map = parser.node_plugin_map
self.module_plugin_map = parser.module_plugin_map
self.sync_objects = {}
self.finish_execution_objects = {}
self.open_pipes = []
if self.executor_data:
ha_infra.dump_on_console(self.executor_data, "Executor Data")
ha_infra.dump_on_console(self.plugin_to_class_map,
"Plugins to Class map")
def __init__(self, parser):
"""
Get the resource form haparser as input parameter and creates
all the objects that are needed to run the executor.
"""
# Resoruce from haparser
self.executor_threads = []
self.executor_data = parser.parsed_executor_config
self.plugin_to_class_map = parser.plugin_to_class_map
self.node_plugin_map = parser.node_plugin_map
self.module_plugin_map = parser.module_plugin_map
self.sync_objects = {}
self.finish_execution_objects = {}
self.open_pipes = []
if self.executor_data:
ha_infra.dump_on_console(self.executor_data, "Executor Data")
ha_infra.dump_on_console(self.plugin_to_class_map,
"Plugins to Class map")
def __init__(self, cfg_file=None):
"""
:param cfg_file: input configuration file for the HA framework
"""
self.user_input_file = cfg_file
self.parsed_disruptor_config = {}
self.parsed_runner_config = {}
self.parsed_executor_config = {}
self.parsed_monitor_config = {}
self.plugin_input_data = {}
self.resource_dirs = []
self.plugin_to_class_map = {}
self.node_plugin_map = {}
self.module_plugin_map = {}
# base
self.openstack_config = {}
infra_source_path = os.environ.get('HAPATH', None)
if infra_source_path is None:
LOG.critical("Run the install.sh ** source install.sh **")
common.ha_exit(0)
self.parsed_executor_config = self.parse_and_load_input_file(
self.user_input_file)
self.parsed_disruptor_config = \
self.parse_and_load_input_file(infra_source_path +
"/configs/disruptors.yaml")
self.parsed_monitor_config = \
self.parse_and_load_input_file(infra_source_path +
"/configs/monitors.yaml")
self.parsed_runner_config = \
self.parse_and_load_input_file(infra_source_path +
"/configs/runners.yaml")
# dump the parsed info from the user on the console
common.dump_on_console(self.parsed_executor_config, "Executor Config")
common.dump_on_console(self.parsed_disruptor_config, "Disruptor Config")
common.dump_on_console(self.parsed_monitor_config, "Monitor Config")
common.dump_on_console(self.parsed_runner_config, "Runner Config")
self.load_plugins_and_create_map()
def map_plugins_to_class_and_create_instances(self):
if self.resource_dirs is None:
LOG.critical('Unable to map type and resources, can not proceed')
common.ha_exit(0)
# Load all the plugin modules defined under the Framework dir
plugin_dirs = []
for path in self.resource_dirs:
for dirpath, dirname, filenames in os.walk(path):
dirpath_split = dirpath.split('/')
if dirpath_split[len(dirpath_split)-1] in FRAMEWORK_MODULES:
LOG.info("Loading all the plugins under %s ", dirpath)
plugin_dirs.append(dirpath + "/plugins")
for plugin_dir in plugin_dirs:
for filename in os.listdir(plugin_dir):
if filename.endswith('.py') and "__init__" not in filename:
try:
module = filename[:-3]
plugin_dir_name = plugin_dir.split("/")[-2]
self.module_plugin_map[module.lower()] = \
plugin_dir_name.lower()
module_name = plugin_dir_name+".plugins."+filename[:-3]
LOG.info("Loading the plugin %s", module_name)
loaded_mod = __import__(module_name,
fromlist=[module_name])
# Load class from imported module
# class_name = self.get_class_name(module_name)
class_names = inspect.getmembers(loaded_mod,
inspect.isclass)
for clas_name in class_names:
if clas_name[0].lower().startswith('base'):
base_class_name = clas_name[0]
LOG.info("Loading the Class %s",
base_class_name)
try:
loaded_base_class = \
getattr(loaded_mod, base_class_name)
break
except AttributeError as err:
LOG.critical("Cannot load base class %s "
"from mod %s",
base_class_name, loaded_mod)
for clas_name in class_names:
if not clas_name[0].lower().startswith('base'):
class_name = clas_name[0]
LOG.info("Loading the Class %s", class_name)
try:
loaded_class = getattr(loaded_mod,
class_name)
if issubclass(loaded_class,
loaded_base_class):
break
except AttributeError as err:
LOG.critical("Cannot load class %s "
"from mod %s",
class_name, loaded_mod)
# Create an instance of the class
file_mod_name = filename[:-3]
input_arg_key = plugin_dir_name + "::" + file_mod_name
input_arguments = self.plugin_input_data.get(
input_arg_key, None)
instance = loaded_class(input_arguments)
if instance:
self.plugin_to_class_map[filename[:-3]] = instance
except OSError as err:
if DEBUG:
LOG.debug("Loading Module %s failed, error = %s",
module, err)
common.ha_exit(0)
# in the end if type_resource is empty, nothing to run exit
if not self.plugin_to_class_map:
LOG.critical('Cannot map plugins and load the class')
common.ha_exit(0)
else:
LOG.info('All plugins and classes loaded successfully')
common.dump_on_console(self.plugin_to_class_map, "Plugin to Class Map")
return self.plugin_to_class_map