def clean_up(a, b, c):
file_util.delete_paths(str(wheel_dir))
def init(root, ingestion_strategy, name, host_type):
"""
Creates a valid plugin in a given directory. The plugin created will be
able to be built and uploaded immediately.
This command is designed to help novice plugin developers. There are
decisions made, such as what the entry point file looks like, in order to
make it easier for authors to get started. The command is expected to be
used by experienced developers, but they are not the primary audience.
Args:
root (str): The path of the plugin's root directory
ingestion_strategy (str): The plugin type. Either DIRECT or STAGED
name (str): The name of the plugin to display.
host_type (list of str): The host type supported by the plugin
"""
logger.info('Initializing directory: %s', root)
logger.debug(
'init parameters: %s', {
'Root': root,
'Ingestion Strategy': ingestion_strategy,
'Name': name,
'Host Types': host_type
})
# Files paths based on 'root' to be used throughout
src_dir_path = os.path.join(root, DEFAULT_SRC_DIRECTORY)
config_file_path = os.path.join(root, DEFAULT_PLUGIN_CONFIG_FILE)
schema_file_path = os.path.join(root, DEFAULT_SCHEMA_FILE)
entry_point_file_path = os.path.join(src_dir_path,
DEFAULT_ENTRY_POINT_FILE)
# Make sure nothing is overwritten
file_util.validate_paths_do_not_exist(config_file_path, schema_file_path,
src_dir_path)
# Make an UUID for the plugin
plugin_id = str(uuid.uuid4())
logger.debug("Using %s as the plugin id.", plugin_id)
# if name is not provided the name will be equal to plugin_id.
if not name:
name = plugin_id
#
# Some magic to get the yaml module to maintain the order when dumping
# an OrderedDict
#
yaml.add_representer(
OrderedDict, lambda dumper, data: dumper.represent_mapping(
'tag:yaml.org,2002:map', data.items()))
logger.debug("Using %s as the plugin's entry point.", DEFAULT_ENTRY_POINT)
try:
#
# Create the source directory. We've already validated that this
# directory doesn't exist.
#
logger.info('Creating source directory at %r.', src_dir_path)
os.mkdir(src_dir_path)
#
# Copy the schema file template into the root directory. The schema
# file is static and doesn't depend on any input so it can just be
# copied. By copying we can also avoid dealing with ordering issues.
#
logger.info('Writing schema file at %s.', schema_file_path)
shutil.copyfile(SCHEMA_TEMPLATE_PATH, schema_file_path)
# Read and valida the schema file
result = plugin_util.read_and_validate_schema_file(
schema_file_path, False)
# Generate the definitions based on the schema file
codegen.generate_python(name, src_dir_path,
os.path.dirname(config_file_path),
result.plugin_schemas)
#
# Create the plugin config file. The config file relies on input from
# the user, so it's easier to deal with a dictionary than a file. This
# must be done only after both the schema file and src dir have been
# created since the paths need to exist.
#
logger.info('Writing config file at %s.', config_file_path)
with open(config_file_path, 'w+') as f:
config = _get_default_plugin_config(plugin_id, ingestion_strategy,
name, DEFAULT_ENTRY_POINT,
DEFAULT_SRC_DIRECTORY,
DEFAULT_SCHEMA_FILE, host_type)
yaml.dump(config, f, default_flow_style=False)
#
# Copy the entry point template into the root directory. The entry
# point file is static and doesn't depend on any input so it can just
# be copied.
#
logger.info('Writing entry file at %s.', entry_point_file_path)
with open(entry_point_file_path, 'w+') as f:
entry_point_content = _get_entry_point_contents(
plugin_id, ingestion_strategy, host_type)
f.write(entry_point_content)
except Exception as e:
logger.debug('Attempting to cleanup after failure. %s', e)
file_util.delete_paths(config_file_path, schema_file_path,
src_dir_path)
raise exceptions.UserError(
'Failed to initialize plugin directory {}: {}.'.format(root, e))
def test_delete_paths(plugin_config_file, schema_file, src_dir):
file_util.delete_paths(plugin_config_file, schema_file, src_dir)
assert not os.path.exists(plugin_config_file)
assert not os.path.exists(schema_file)
assert not os.path.exists(src_dir)
def test_delete_paths_none_values(plugin_config_file):
file_util.delete_paths(plugin_config_file, None)
assert not os.path.exists(plugin_config_file)
def clean_up(a, b, c):
file_util.delete_paths(wheel_dir.as_posix())