def test_read_write_file(fx_mk_temp_dir): temp_file = os.path.join(mock_paths.TEST_TEMP_DIR, "mock_file.txt") sdk_helpers.write_file(temp_file, mock_data.mock_file_contents) assert os.path.isfile(temp_file) file_lines = sdk_helpers.read_file(temp_file) assert mock_data.mock_file_contents in file_lines
def _mk_app_config(): write_path = os.path.join(mock_paths.TEST_TEMP_DIR, "app.config") resilient_mock = "{0}.{1}".format( os.path.join(mock_paths.SHARED_MOCK_DATA_DIR, "resilient_api_mock"), "ResilientAPIMock") app_configs = """ [resilient] #api_key_id=xxx #api_key_secret=xxx host=192.168.56.1 port=443 org=Test Organization [email protected] password=PassWord_;) #componentsdir=~/.resilient/components logdir=~/.resilient/logs/ logfile=app.log loglevel=DEBUG cafile=false resilient_mock={0}""".format(resilient_mock) sdk_helpers.write_file(write_path, app_configs) return write_path
def test_rename_file(fx_mk_temp_dir): temp_file = os.path.join(mock_paths.TEST_TEMP_DIR, "mock_file.txt") sdk_helpers.write_file(temp_file, mock_data.mock_file_contents) sdk_helpers.rename_file(temp_file, "new_file_name.txt") path_renamed_file = os.path.join(mock_paths.TEST_TEMP_DIR, "new_file_name.txt") assert os.path.isfile(path_renamed_file) is True
def test_validate_file_paths(fx_mk_temp_dir): non_exist_file = "/non_exits/path/non_exist_file.txt" with pytest.raises(SDKException, match=r"Could not find file: " + non_exist_file): sdk_helpers.validate_file_paths(None, non_exist_file) exists_file = os.path.join(mock_paths.TEST_TEMP_DIR, "mock_existing_file.txt") sdk_helpers.write_file(exists_file, mock_data.mock_file_contents) sdk_helpers.validate_file_paths(None, exists_file)
def test_rename_to_bak_file(fx_mk_temp_dir): temp_file = os.path.join(mock_paths.TEST_TEMP_DIR, "mock_file.txt") sdk_helpers.write_file(temp_file, mock_data.mock_file_contents) sdk_helpers.rename_to_bak_file(temp_file) files_in_dir = os.listdir(mock_paths.TEST_TEMP_DIR) regex = re.compile(r'^mock_file\.txt-\d+\d+\d+\d+\d+\d+\d+\.bak$') matched_file_name = list(filter(regex.match, files_in_dir))[0] assert regex.match(matched_file_name)
def test_has_permissions(fx_mk_temp_dir): temp_permissions_file = os.path.join(mock_paths.TEST_TEMP_DIR, "mock_permissions.txt") sdk_helpers.write_file(temp_permissions_file, mock_data.mock_file_contents) # Set permissions to Read only os.chmod(temp_permissions_file, stat.S_IRUSR) with pytest.raises(SDKException, match=r"User does not have WRITE permissions"): sdk_helpers.has_permissions(os.W_OK, temp_permissions_file) # Set permissions to Write only os.chmod(temp_permissions_file, stat.S_IWUSR) with pytest.raises(SDKException, match=r"User does not have READ permissions"): sdk_helpers.has_permissions(os.R_OK, temp_permissions_file)
def render_jinja_mapping(jinja_mapping_dict, jinja_env, target_dir, package_dir): """ Write all the Jinja Templates specified in jinja_mapping_dict that are found in the jinja_env to the target_dir. Returns a Tuple of newly generated files and files that were skipped :param jinja_mapping_dict: e.g. {"file_to_write.py": ("name_of_template.py.jinja2", jinja_data)} :param jinja_env: Jinja Environment :param target_dir: Path to write Templates to :return: newly_generated_files, files_skipped: a Tuple of newly generated files and files skipped :rtype: tuple """ newly_generated_files = [] files_skipped = [] for (file_name, file_info) in jinja_mapping_dict.items(): if isinstance(file_info, dict): # This is a sub directory sub_dir_mapping_dict = file_info path_sub_dir = os.path.join(target_dir, file_name) try: os.makedirs(path_sub_dir) # Skip this error, which is generally a 'File Exists' error except OSError: pass new_files, skipped_files = CmdCodegen.render_jinja_mapping( jinja_mapping_dict=sub_dir_mapping_dict, jinja_env=jinja_env, target_dir=path_sub_dir, package_dir=package_dir) newly_generated_files += new_files files_skipped += skipped_files elif isinstance(file_info, str) and os.path.isfile(file_info): # It is just a path to a file, copy it to the target_file target_file = os.path.join(target_dir, file_name) if os.path.exists(target_file): # If file already exists skip copy. files_skipped.append(os.path.relpath(target_file, start=package_dir)) continue newly_generated_files.append(os.path.relpath(target_file, start=package_dir)) shutil.copy(file_info, target_file) else: # Get path to Jinja2 template path_template = file_info[0] # Get data dict for this Jinja2 template template_data = file_info[1] target_file = os.path.join(target_dir, file_name) if os.path.exists(target_file): files_skipped.append(os.path.relpath(target_file, start=package_dir)) continue jinja_template = jinja_env.get_template(path_template) jinja_rendered_text = jinja_template.render(template_data) newly_generated_files.append(os.path.relpath(target_file, start=package_dir)) sdk_helpers.write_file(target_file, jinja_rendered_text) return newly_generated_files, files_skipped
def _set_version(args): new_version = args.set_version if not sdk_helpers.is_valid_version_syntax(new_version): raise SDKException( "{0} is not a valid version".format(new_version)) new_version_int = list(map(int, (re.findall(r"\d+", new_version)))) # Get absolute path_to_src path_to_src = os.path.abspath(args.package) # Get path to setup.py file path_setup_py_file = os.path.join(path_to_src, package_helpers.BASE_NAME_SETUP_PY) # Parse the setup.py file setup_py_attributes = package_helpers.parse_setup_py( path_setup_py_file, package_helpers.SUPPORTED_SETUP_PY_ATTRIBUTE_NAMES) package_name = setup_py_attributes.get("name", "") LOG.info("Setting Resilient Platform version for %s to %s", package_name, new_version) # Get the customize file location. path_customize_py = package_helpers.get_configuration_py_file_path( "customize", setup_py_attributes) # Get customize.py ImportDefinition customize_py_import_definition = package_helpers.get_import_definition_from_customize_py( path_customize_py) old_version = customize_py_import_definition["server_version"][ "version"] LOG.info("Old Version: %s", old_version) LOG.info("New Version: %s", new_version) # Set the new version customize_py_import_definition["server_version"][ "version"] = new_version customize_py_import_definition["server_version"][ "major"] = new_version_int[0] customize_py_import_definition["server_version"][ "minor"] = new_version_int[1] customize_py_import_definition["server_version"][ "build_number"] = new_version_int[2] LOG.info("Loading old customize.py file") # Load the customize.py module customize_py_module = package_helpers.load_customize_py_module( path_customize_py, warn=False) # Get the 'old_params' from customize.py old_params = customize_py_module.codegen_reload_data() # Rename the old customize.py with .bak path_customize_py_bak = sdk_helpers.rename_to_bak_file( path_customize_py) # If local export file exists then save it to a .bak file. # (Older packages may not have the /util/data/export.res file) # Figure out the path of the files first dir_customize_py = os.path.dirname(path_customize_py) path_local_export_res = os.path.join( dir_customize_py, package_helpers.PATH_LOCAL_EXPORT_RES) path_local_export_res_bak = None if os.path.isfile(path_local_export_res): path_local_export_res_bak = sdk_helpers.rename_to_bak_file( path_local_export_res) try: jinja_data = sdk_helpers.get_from_export( customize_py_import_definition, message_destinations=old_params.get("message_destinations"), functions=old_params.get("functions"), workflows=old_params.get("workflows"), rules=old_params.get("actions"), fields=old_params.get("incident_fields"), artifact_types=old_params.get("incident_artifact_types"), datatables=old_params.get("datatables"), tasks=old_params.get("automatic_tasks"), scripts=old_params.get("scripts")) jinja_data["export_data"] = sdk_helpers.minify_export( customize_py_import_definition, message_destinations=sdk_helpers.get_object_api_names( ResilientObjMap.MESSAGE_DESTINATIONS, jinja_data.get("message_destinations")), functions=sdk_helpers.get_object_api_names( ResilientObjMap.FUNCTIONS, jinja_data.get("functions")), workflows=sdk_helpers.get_object_api_names( ResilientObjMap.WORKFLOWS, jinja_data.get("workflows")), rules=sdk_helpers.get_object_api_names( ResilientObjMap.RULES, jinja_data.get("rules")), fields=jinja_data.get("all_fields"), artifact_types=sdk_helpers.get_object_api_names( ResilientObjMap.INCIDENT_ARTIFACT_TYPES, jinja_data.get("artifact_types")), datatables=sdk_helpers.get_object_api_names( ResilientObjMap.DATATABLES, jinja_data.get("datatables")), tasks=sdk_helpers.get_object_api_names( ResilientObjMap.TASKS, jinja_data.get("tasks")), phases=sdk_helpers.get_object_api_names( ResilientObjMap.PHASES, jinja_data.get("phases")), scripts=sdk_helpers.get_object_api_names( ResilientObjMap.SCRIPTS, jinja_data.get("scripts"))) # Add package_name to jinja_data jinja_data["package_name"] = package_name # Add version jinja_data["version"] = setup_py_attributes.get( "version", package_helpers.MIN_SETUP_PY_VERSION) # Instansiate Jinja2 Environment with path to Jinja2 templates for customize.py jinja_env = sdk_helpers.setup_jinja_env( "data/codegen/templates/package_template/package/util") jinja_template = jinja_env.get_template("customize.py.jinja2") LOG.info("Writing new customize.py file") # Render & write jinja2 template jinja_rendered_text = jinja_template.render(jinja_data) sdk_helpers.write_file(path_customize_py, jinja_rendered_text) # Instansiate Jinja2 Environment with path to Jinja2 templates for /util/dat/export.res #jinja_env = sdk_helpers.setup_jinja_env("data/codegen/templates/package_template/package/util/data") jinja_template = jinja_env.get_template("/data/export.res.jinja2") LOG.debug("Writing new /util/data/export.res file") # Render jinja2 template jinja_rendered_text = jinja_template.render(jinja_data) # Make sure the /util/data directory is there if it is not dir_local_export_res = os.path.dirname(path_local_export_res) if not os.path.exists(dir_local_export_res): os.makedirs(dir_local_export_res) # Write the file sdk_helpers.write_file(path_local_export_res, jinja_rendered_text) LOG.info("'dev --set-version' complete for '%s'", package_name) except Exception as err: LOG.error( u"Error running resilient-sdk dev --set-version\n\nERROR:%s", err) # This is required in finally block as user may kill using keyboard interrupt finally: # If an error occurred, customize.py does not exist, rename the backup file to original if not os.path.isfile(path_customize_py): LOG.info( u"An error occurred. Renaming customize.py.bak to customize.py" ) sdk_helpers.rename_file(path_customize_py_bak, package_helpers.BASE_NAME_CUSTOMIZE_PY) if path_local_export_res_bak and not os.path.isfile( path_local_export_res): LOG.info( u"An error occurred. Renaming /util/data/export.res.bak to export.res" ) sdk_helpers.rename_file( path_local_export_res_bak, package_helpers.BASE_NAME_LOCAL_EXPORT_RES)
def render_jinja_mapping(jinja_mapping_dict, jinja_env, target_dir, package_dir): """ Write all the Jinja Templates specified in jinja_mapping_dict that are found in the jinja_env to the target_dir. Returns a Tuple of newly generated files and files that were skipped :param jinja_mapping_dict: e.g. {"file_to_write.py": ("name_of_template.py.jinja2", jinja_data)} :param jinja_env: Jinja Environment :param target_dir: Path to write Templates to :return: newly_generated_files, files_skipped: a Tuple of newly generated files and files skipped :rtype: tuple """ newly_generated_files = [] files_skipped = [] for (file_name, file_info) in jinja_mapping_dict.items(): if isinstance(file_info, dict): # This is a sub directory sub_dir_mapping_dict = file_info path_sub_dir = os.path.join(target_dir, file_name) try: os.makedirs(path_sub_dir) # Skip this error, which is generally a 'File Exists' error except OSError: pass new_files, skipped_files = CmdCodegen.render_jinja_mapping( jinja_mapping_dict=sub_dir_mapping_dict, jinja_env=jinja_env, target_dir=path_sub_dir, package_dir=package_dir) newly_generated_files += new_files files_skipped += skipped_files elif isinstance(file_info, str) and os.path.isfile(file_info): # It is just a path to a file, copy it to the target_file target_file = os.path.join(target_dir, file_name) if os.path.exists(target_file): # If file already exists skip copy. files_skipped.append(os.path.relpath(target_file, start=package_dir)) continue newly_generated_files.append(os.path.relpath(target_file, start=package_dir)) shutil.copy(file_info, target_file) else: # Initialize variable for target file name from export. export_target_file = None # Get path to Jinja2 template path_template = file_info[0] # Get data dict for this Jinja2 template template_data = file_info[1] target_file = os.path.join(target_dir, file_name) # Get target file extension. target_ext = os.path.splitext(target_file)[1] # Try to set object name to function name if it exists in export. export_obj_name = template_data.get(ResilientObjMap.FUNCTIONS) if not export_obj_name: # Not a function try to set to workflow name from export instead. export_obj_name = template_data.get(ResilientObjMap.WORKFLOWS) if export_obj_name: # Is a function or workflow so get file path(s) using export object name. if os.path.dirname(path_template) == "tests": export_target_file = os.path.join(target_dir, u"test_{0}{1}".format(export_obj_name, target_ext)) else: export_target_file = os.path.join(target_dir, u"{0}{1}".format(export_obj_name, target_ext)) write_target_file = None for t_file in [target_file, export_target_file]: if t_file and os.path.exists(t_file): # Don't skip for workflows. if target_ext == ".md" and export_target_file: # Write to first workflow target file name format found. write_target_file = t_file else: files_skipped.append(os.path.relpath(t_file, start=package_dir)) write_target_file = None break if t_file and not write_target_file: # We will use default (target_file) format if file doesn't already exist. write_target_file = t_file if not write_target_file: continue jinja_template = jinja_env.get_template(path_template) jinja_rendered_text = jinja_template.render(template_data) newly_generated_files.append(os.path.relpath(write_target_file, start=package_dir)) sdk_helpers.write_file(write_target_file, jinja_rendered_text) return newly_generated_files, files_skipped
def _get_results_from_log_file(cls, args): """ - Gets all function names from the payload_samples directory - Traverses the file at the path specified by args.gather_results (in a reversed order) - Looks for lines containing ``[<fn_name>] Result: {'version': 2.0, 'success': True...`` - Parses it and generates an output_json_example.json and output_json_schema.json file for each ``Result`` found - Uses the libary ``genson`` to generate the JSON schema from a Python Dictionary :param args: (required) the cmd line arguments :type args: argparse.ArgumentParser :raises: an SDKException if args.package is not a valid path """ # Check if Python >= MIN_SUPPORTED_PY_VERSION if not sdk_helpers.is_python_min_supported_version(constants.ERROR_WRONG_PYTHON_VERSION): raise SDKException(constants.ERROR_WRONG_PYTHON_VERSION) path_package = os.path.abspath(args.package) path_log_file = args.gather_results path_payload_samples_dir = os.path.join(path_package, package_helpers.BASE_NAME_PAYLOAD_SAMPLES_DIR) LOG.debug("\nPath to project: %s", path_package) sdk_helpers.validate_dir_paths(os.W_OK, path_package) package_name = package_helpers.get_package_name(path_package) LOG.info("'codegen %s' started for '%s'", constants.SUB_CMD_OPT_GATHER_RESULTS, package_name) try: sdk_helpers.validate_dir_paths(os.W_OK, path_payload_samples_dir) except SDKException as e: if constants.ERROR_NOT_FIND_DIR in e.message: LOG.warning("WARNING: no '%s' found. Running 'codegen --reload' to create the default missing files\n%s", package_helpers.BASE_NAME_PAYLOAD_SAMPLES_DIR, constants.LOG_DIVIDER) args.reload = True cls._reload_package(args) LOG.warning(constants.LOG_DIVIDER) else: raise e functions_that_need_payload_samples = args.function if args.function else os.listdir(path_payload_samples_dir) results_scraped = sdk_helpers.scrape_results_from_log_file(path_log_file) for fn_name in functions_that_need_payload_samples: fn_results = results_scraped.get(fn_name) if not fn_results: package_helpers.color_output("WARNING: No results could be found for '{0}' in '{1}'".format(fn_name, path_log_file), constants.VALIDATE_LOG_LEVEL_WARNING, do_print=True) continue LOG.info("Results found for '[%s]'", fn_name) path_payload_samples_fn_name = os.path.join(path_payload_samples_dir, fn_name) path_output_json_example = os.path.join(path_payload_samples_fn_name, package_helpers.BASE_NAME_PAYLOAD_SAMPLES_EXAMPLE) path_output_json_schema = os.path.join(path_payload_samples_fn_name, package_helpers.BASE_NAME_PAYLOAD_SAMPLES_SCHEMA) path_output_json_example_bak = sdk_helpers.rename_to_bak_file(path_output_json_example) path_output_json_schema_bak = sdk_helpers.rename_to_bak_file(path_output_json_schema) try: LOG.debug("Writing JSON example file for '%s' to '%s'", fn_name, path_output_json_example) sdk_helpers.write_file(path_output_json_example, json.dumps(fn_results, indent=2)) LOG.debug("Writing JSON schema file for '%s' to '%s'", fn_name, path_output_json_schema) builder = CustomSchemaBuilder(schema_uri=constants.CODEGEN_JSON_SCHEMA_URI) main_genson_builder_overwrites(builder) builder.add_object(fn_results) sdk_helpers.write_file(path_output_json_schema, builder.to_json(indent=2)) finally: if not os.path.isfile(path_output_json_example) and path_output_json_example_bak: LOG.info(u"An error occurred. Renaming %s.bak to %s", package_helpers.BASE_NAME_PAYLOAD_SAMPLES_EXAMPLE, package_helpers.BASE_NAME_PAYLOAD_SAMPLES_EXAMPLE) sdk_helpers.rename_file(path_output_json_example_bak, package_helpers.BASE_NAME_PAYLOAD_SAMPLES_EXAMPLE) if not os.path.isfile(path_output_json_schema) and path_output_json_schema_bak: LOG.info(u"An error occurred. Renaming %s.bak to %s", package_helpers.BASE_NAME_PAYLOAD_SAMPLES_SCHEMA, package_helpers.BASE_NAME_PAYLOAD_SAMPLES_SCHEMA) sdk_helpers.rename_file(path_output_json_schema_bak, package_helpers.BASE_NAME_PAYLOAD_SAMPLES_SCHEMA) LOG.info("'codegen %s' complete for '%s'", constants.SUB_CMD_OPT_GATHER_RESULTS, package_name)
def execute_command(self, args): LOG.info("Starting 'extract'...") LOG.debug("'extract' called with %s", args) # Set docgen name for SDKException SDKException.command_ran = self.CMD_NAME # Get output_base, use args.output if defined, else current directory output_base = args.output if args.output else os.curdir output_base = os.path.abspath(output_base) # If --exportfile is specified, read org_export from that file if args.exportfile: LOG.info("Using local export file: %s", args.exportfile) org_export = sdk_helpers.read_local_exportfile(args.exportfile) else: # Instantiate connection to the Resilient Appliance res_client = sdk_helpers.get_resilient_client( path_config_file=args.config) # Generate + get latest export from Resilient Server org_export = sdk_helpers.get_latest_org_export(res_client) LOG.info("Extracting data from export...") # Get extracted data from export extract_data = sdk_helpers.get_from_export( org_export, message_destinations=args.messagedestination, functions=args.function, workflows=args.workflow, rules=args.rule, fields=args.field, artifact_types=args.artifacttype, datatables=args.datatable, tasks=args.task, scripts=args.script, incident_types=args.incidenttype, playbooks=args.playbook) # Get 'minified' version of the export. This is used in to create export.res min_extract_data = sdk_helpers.minify_export( org_export, message_destinations=sdk_helpers.get_object_api_names( ResilientObjMap.MESSAGE_DESTINATIONS, extract_data.get("message_destinations")), functions=sdk_helpers.get_object_api_names( ResilientObjMap.FUNCTIONS, extract_data.get("functions")), workflows=sdk_helpers.get_object_api_names( ResilientObjMap.WORKFLOWS, extract_data.get("workflows")), rules=sdk_helpers.get_object_api_names(ResilientObjMap.RULES, extract_data.get("rules")), fields=extract_data.get("all_fields"), artifact_types=sdk_helpers.get_object_api_names( ResilientObjMap.INCIDENT_ARTIFACT_TYPES, extract_data.get("artifact_types")), datatables=sdk_helpers.get_object_api_names( ResilientObjMap.DATATABLES, extract_data.get("datatables")), tasks=sdk_helpers.get_object_api_names(ResilientObjMap.TASKS, extract_data.get("tasks")), phases=sdk_helpers.get_object_api_names( ResilientObjMap.PHASES, extract_data.get("phases")), scripts=sdk_helpers.get_object_api_names( ResilientObjMap.SCRIPTS, extract_data.get("scripts")), incident_types=sdk_helpers.get_object_api_names( ResilientObjMap.INCIDENT_TYPES, extract_data.get("incident_types")), playbooks=sdk_helpers.get_object_api_names( ResilientObjMap.PLAYBOOKS, extract_data.get(constants.CUST_PLAYBOOKS))) # Convert dict to JSON string if sys.version_info.major >= 3: res_data = json.dumps(min_extract_data, ensure_ascii=False) else: res_data = unicode(json.dumps(min_extract_data, ensure_ascii=False)) # Generate path to file file_name = "export-{0}".format( sdk_helpers.get_timestamp( org_export.get("export_date", 0) / 1000.0)) # If custom name supplied, prepend it if args.name: file_name = "{0}-{1}".format(args.name, file_name) path_file_to_write = os.path.join(output_base, "{0}.res".format(file_name)) LOG.info("Generating %s.res", file_name) # Write the file sdk_helpers.write_file(path_file_to_write, res_data) LOG.debug('Wrote: %s', path_file_to_write) # If we should create .zip archive if args.zip: LOG.info("Generating %s.zip", file_name) # Get path to .zip path_dir_to_zip = os.path.join(output_base, file_name) # Create directory os.makedirs(path_dir_to_zip) # Copy the written export file into new dir shutil.copy(path_file_to_write, path_dir_to_zip) # zip the dir the_zip = shutil.make_archive(base_name=file_name, format="zip", root_dir=path_dir_to_zip) if output_base != os.path.dirname(the_zip): # Move the zip into the output base shutil.move(the_zip, output_base) LOG.debug('Wrote: %s.zip', path_dir_to_zip) # Remove directory shutil.rmtree(path_dir_to_zip) LOG.info("'extract' complete")
def create_extension(path_setup_py_file, path_apikey_permissions_file, output_dir, path_built_distribution=None, path_extension_logo=None, path_company_logo=None, custom_display_name=None, repository_name=None, keep_build_dir=False): """ TODO: update this docstring to new standard format Function that creates The App.zip file from the given setup.py, customize and config files and copies it to the output_dir. Returns the path to the App.zip - path_setup_py_file [String]: abs path to the setup.py file - path_apikey_permissions_file [String]: abs path to the apikey_permissions.txt file - output_dir [String]: abs path to the directory the App.zip should be produced - path_built_distribution [String]: abs path to a tar.gz Built Distribution - if provided uses that .tar.gz - else looks for it in the output_dir. E.g: output_dir/package_name.tar.gz - path_extension_logo [String]: abs path to the app_logo.png. Has to be 200x72 and a .png file - if not provided uses default icon - path_company_logo [String]: abs path to the company_logo.png. Has to be 100x100 and a .png file - if not provided uses default icon - custom_display_name [String]: will give the App that display name. Default: name from setup.py file - repository_name [String]: will over-ride the container repository name for the App. Default: 'ibmresilient' - keep_build_dir [Boolean]: if True, build/ will not be remove. Default: False """ LOG.info("Creating App") # Variables to hold path of files for customize and config as defined in setup.py. # Set initially default to 'None', actual paths will be calculated later. path_customize_py_file = None path_config_py_file = None # Ensure the output_dir exists, we have WRITE access and ensure we can READ setup.py and apikey_permissions.txt # files. sdk_helpers.validate_dir_paths(os.W_OK, output_dir) sdk_helpers.validate_file_paths(os.R_OK, path_setup_py_file, path_apikey_permissions_file) # Parse the setup.py file setup_py_attributes = parse_setup_py(path_setup_py_file, SUPPORTED_SETUP_PY_ATTRIBUTE_NAMES) # Validate setup.py attributes # Validate the name attribute. Raise exception if invalid if not sdk_helpers.is_valid_package_name(setup_py_attributes.get("name")): raise SDKException( "'{0}' is not a valid App name. The name attribute must be defined and can only include 'a-z and _'.\nUpdate this value in the setup.py file located at: {1}" .format(setup_py_attributes.get("name"), path_setup_py_file)) # Validate the version attribute. Raise exception if invalid if not sdk_helpers.is_valid_version_syntax( setup_py_attributes.get("version")): raise SDKException( "'{0}' is not a valid App version syntax. The version attribute must be defined. Example: version=\"1.0.0\".\nUpdate this value in the setup.py file located at: {1}" .format(setup_py_attributes.get("version"), path_setup_py_file)) # Validate the url supplied in the setup.py file, set to an empty string if not valid if not sdk_helpers.is_valid_url(setup_py_attributes.get("url")): LOG.warning("WARNING: '%s' is not a valid url. Ignoring.", setup_py_attributes.get("url")) setup_py_attributes["url"] = "" # Get the tag name tag_name = setup_py_attributes.get("name") # Get the customize file location. path_customize_py_file = get_configuration_py_file_path( "customize", setup_py_attributes) # Get the config file location. path_config_py_file = get_configuration_py_file_path( "config", setup_py_attributes) # Get ImportDefinition from the discovered customize file. if path_customize_py_file: import_definition = get_import_definition_from_customize_py( path_customize_py_file) else: # No 'customize.py' file found generate import definition with just mimimum server version. import_definition = {'server_version': IMPORT_MIN_SERVER_VERSION} # Add the tag to the import defintion import_definition = add_tag_to_import_definition(tag_name, SUPPORTED_RES_OBJ_NAMES, import_definition) # Parse the app.configs from the discovered config file if path_config_py_file: app_configs = get_configs_from_config_py(path_config_py_file) else: # No config file file found generate an empty definition. app_configs = ("", []) # Parse the api key permissions from the apikey_permissions.txt file apikey_permissions = get_apikey_permissions(path_apikey_permissions_file) # Generate the name for the extension extension_name = "{0}-{1}".format(setup_py_attributes.get("name"), setup_py_attributes.get("version")) # Generate the uuid uuid = sdk_helpers.generate_uuid_from_string( setup_py_attributes.get("name")) # Set the container repository name to default if value not passed in as argument. if not repository_name: repository_name = REPOSITORY_NAME # Generate paths to the directories and files we will use in the build directory path_build = os.path.join(output_dir, BASE_NAME_BUILD) path_extension_json = os.path.join(path_build, BASE_NAME_EXTENSION_JSON) path_export_res = os.path.join(path_build, BASE_NAME_EXPORT_RES) try: # If there is an old build directory, remove it first if os.path.exists(path_build): shutil.rmtree(path_build) # Create the directories for the path "/build/" os.makedirs(path_build) # If no path_built_distribution is given, use the default: "<output_dir>/<package-name>.tar.gz" if not path_built_distribution: path_built_distribution = os.path.join( output_dir, "{0}.tar.gz".format(extension_name)) # Validate the built distribution exists and we have READ access sdk_helpers.validate_file_paths(os.R_OK, path_built_distribution) # Copy the built distribution to the build dir and enforce rename to .tar.gz shutil.copy( path_built_distribution, os.path.join(path_build, "{0}.tar.gz".format(extension_name))) # Get the extension_logo (icon) and company_logo (author.icon) as base64 encoded strings extension_logo = get_icon( icon_name=os.path.basename(PATH_DEFAULT_ICON_EXTENSION_LOGO), path_to_icon=path_extension_logo, width_accepted=200, height_accepted=72, default_path_to_icon=PATH_DEFAULT_ICON_EXTENSION_LOGO) company_logo = get_icon( icon_name=os.path.basename(PATH_DEFAULT_ICON_COMPANY_LOGO), path_to_icon=path_company_logo, width_accepted=100, height_accepted=100, default_path_to_icon=PATH_DEFAULT_ICON_COMPANY_LOGO) # Get the display name # Use --display-name if passed # If not use 'display_name' attribute in setup.py # If not set use the 'name' attribute in setup.py display_name = custom_display_name or setup_py_attributes.get( "display_name") or setup_py_attributes.get("name") # Image string is all lowercase on quay.io image_name = "{0}/{1}:{2}".format(repository_name, setup_py_attributes.get("name"), setup_py_attributes.get("version")) image_name = image_name.lower() # Generate the contents for the extension.json file the_extension_json_file_contents = { "author": { "name": setup_py_attributes.get("author"), "website": setup_py_attributes.get("url"), "icon": { "data": company_logo, "media_type": "image/png" } }, "description": { "content": setup_py_attributes.get("description"), "format": "text" }, "display_name": display_name, "icon": { "data": extension_logo, "media_type": "image/png" }, "long_description": { "content": "<div>{0}</div>".format( setup_py_attributes.get("long_description")), "format": "html" }, "minimum_resilient_version": { "major": import_definition.get("server_version").get("major", None), "minor": import_definition.get("server_version").get("minor", None), "build_number": import_definition.get("server_version").get( "build_number", None), "version": import_definition.get("server_version").get("version", None) }, "name": setup_py_attributes.get("name"), "tag": { "prefix": tag_name, "name": tag_name, "display_name": tag_name, "uuid": uuid }, "uuid": uuid, "version": setup_py_attributes.get("version"), "current_installation": { "executables": [{ "name": setup_py_attributes.get("name"), "image": image_name, "config_string": app_configs[0], "permission_handles": apikey_permissions, "uuid": uuid }] } } # Write the executable.json file sdk_helpers.write_file( path_extension_json, json.dumps(the_extension_json_file_contents, sort_keys=True)) # Write the customize ImportDefinition to the app*.zip export.res file sdk_helpers.write_file(path_export_res, json.dumps(import_definition, sort_keys=True)) # Copy the built distribution to the build dir, enforce rename to .tar.gz shutil.copy( path_built_distribution, os.path.join(path_build, "{0}.tar.gz".format(extension_name))) # create The Extension Zip by zipping the build directory extension_zip_base_path = os.path.join( output_dir, "{0}{1}".format(PREFIX_EXTENSION_ZIP, extension_name)) extension_zip_name = shutil.make_archive( base_name=extension_zip_base_path, format="zip", root_dir=path_build) path_the_extension_zip = os.path.join(extension_zip_base_path, extension_zip_name) except SDKException as err: raise err except Exception as err: raise SDKException(err) finally: # Remove the build dir. Keep it if user passes --keep-build-dir if not keep_build_dir: shutil.rmtree(path_build) LOG.info("App %s.zip created", "{0}{1}".format(PREFIX_EXTENSION_ZIP, extension_name)) # Return the path to the extension zip return path_the_extension_zip
def create_extension(path_setup_py_file, path_apikey_permissions_file, output_dir, path_built_distribution=None, path_extension_logo=None, path_company_logo=None, path_payload_samples=None, path_validate_report=None, custom_display_name=None, repository_name=None, image_hash=None, keep_build_dir=False): """ Function that creates The App.zip file from the given setup.py, customize and config files and copies it to the output_dir. Returns the path to the app.zip :param path_setup_py_file: abs path to the setup.py file :type path_setup_py_file: str :param path_apikey_permissions_file: abs path to the apikey_permissions.txt file :type path_apikey_permissions_file: str :param output_dir: abs path to the directory the App.zip should be produced :type output_dir: str :param path_built_distribution: abs path to a tar.gz Built Distribution - if provided uses that .tar.gz - else looks for it in the output_dir. E.g: output_dir/package_name.tar.gz :type path_built_distribution: str :param path_extension_logo: abs path to the app_logo.png. Has to be 200x72 and a .png file - if not provided uses default icon :type path_extension_logo: str :param path_company_logo: abs path to the company_logo.png. Has to be 100x100 and a .png file - if not provided uses default icon :type path_company_logo: str :param path_payload_samples: abs path to directory containing the files with a JSON schema and example output of the functions :type path_payload_samples: str :param path_validate_report: abs path to directory containing the validation report - to be copied to the build directory that will be zipped :type path_validate_report: str :param custom_display_name: will give the App that display name. Default: name from setup.py file :type custom_display_name: str :param repository_name: will over-ride the container repository name for the App. Default: 'ibmresilient' :type repository_name: str :param image_hash: if defined will append the hash to the image_name in the app.json file e.g. <repository_name>/<package_name>@sha256:<image_hash>. Default: <repository_name>/<package_name>:<version> :type image_hash: str :param keep_build_dir: if True, build/ will not be removed. Default: False :type keep_build_dir: bool :return: Path to new app.zip :rtype: str """ LOG.info("Creating App") # Variables to hold path of files for customize and config as defined in setup.py. # Set initially default to 'None', actual paths will be calculated later. path_customize_py_file = None path_config_py_file = None # Ensure the output_dir exists, we have WRITE access and ensure we can READ setup.py and apikey_permissions.txt # files. sdk_helpers.validate_dir_paths(os.W_OK, output_dir) sdk_helpers.validate_file_paths(os.R_OK, path_setup_py_file, path_apikey_permissions_file) # Parse the setup.py file setup_py_attributes = parse_setup_py(path_setup_py_file, SUPPORTED_SETUP_PY_ATTRIBUTE_NAMES) # Validate setup.py attributes # Validate the name attribute. Raise exception if invalid if not sdk_helpers.is_valid_package_name(setup_py_attributes.get("name")): raise SDKException("'{0}' is not a valid App name. The name attribute must be defined and can only include 'a-z and _'.\nUpdate this value in the setup.py file located at: {1}".format(setup_py_attributes.get("name"), path_setup_py_file)) # Validate the version attribute. Raise exception if invalid if not sdk_helpers.is_valid_version_syntax(setup_py_attributes.get("version")): raise SDKException("'{0}' is not a valid App version syntax. The version attribute must be defined. Example: version=\"1.0.0\".\nUpdate this value in the setup.py file located at: {1}".format(setup_py_attributes.get("version"), path_setup_py_file)) # Validate the url supplied in the setup.py file, set to an empty string if not valid if not sdk_helpers.is_valid_url(setup_py_attributes.get("url")): LOG.warning("WARNING: '%s' is not a valid url. Ignoring.", setup_py_attributes.get("url")) setup_py_attributes["url"] = "" # Get the tag name tag_name = setup_py_attributes.get("name") # Get the customize file location. path_customize_py_file = get_configuration_py_file_path("customize", setup_py_attributes) # Get the config file location. path_config_py_file = get_configuration_py_file_path("config", setup_py_attributes) # Get ImportDefinition from the discovered customize file. if path_customize_py_file: import_definition = get_import_definition_from_customize_py(path_customize_py_file) else: # No 'customize.py' file found generate import definition with just mimimum server version. import_definition = { 'server_version': IMPORT_MIN_SERVER_VERSION } # Add the tag to the import defintion import_definition = add_tag_to_import_definition(tag_name, SUPPORTED_RES_OBJ_NAMES, import_definition) # Parse the app.configs from the discovered config file if path_config_py_file: app_configs = get_configs_from_config_py(path_config_py_file) else: # No config file file found generate an empty definition. app_configs = ("", []) # Parse the api key permissions from the apikey_permissions.txt file apikey_permissions = get_apikey_permissions(path_apikey_permissions_file) # Generate the name for the extension extension_name = "{0}-{1}".format(setup_py_attributes.get("name"), setup_py_attributes.get("version")) # Generate the uuid uuid = sdk_helpers.generate_uuid_from_string(setup_py_attributes.get("name")) # Set the container repository name to default if value not passed in as argument. if not repository_name: repository_name = REPOSITORY_NAME # Generate paths to the directories and files we will use in the build directory path_build = os.path.join(output_dir, BASE_NAME_BUILD) path_extension_json = os.path.join(path_build, BASE_NAME_EXTENSION_JSON) path_export_res = os.path.join(path_build, BASE_NAME_EXPORT_RES) try: # If there is an old build directory, remove it first if os.path.exists(path_build): shutil.rmtree(path_build) # Create the directories for the path "/build/" os.makedirs(path_build) # If no path_built_distribution is given, use the default: "<output_dir>/<package-name>.tar.gz" if not path_built_distribution: path_built_distribution = os.path.join(output_dir, "{0}.tar.gz".format(extension_name)) # Validate the built distribution exists and we have READ access sdk_helpers.validate_file_paths(os.R_OK, path_built_distribution) # Copy the built distribution to the build dir and enforce rename to .tar.gz shutil.copy(path_built_distribution, os.path.join(path_build, "{0}.tar.gz".format(extension_name))) # Get the extension_logo (icon) and company_logo (author.icon) as base64 encoded strings extension_logo = get_icon( icon_name=os.path.basename(PATH_DEFAULT_ICON_EXTENSION_LOGO), path_to_icon=path_extension_logo, width_accepted=constants.ICON_APP_LOGO_REQUIRED_WIDTH, height_accepted=constants.ICON_APP_LOGO_REQUIRED_HEIGHT, default_path_to_icon=PATH_DEFAULT_ICON_EXTENSION_LOGO) company_logo = get_icon( icon_name=os.path.basename(PATH_DEFAULT_ICON_COMPANY_LOGO), path_to_icon=path_company_logo, width_accepted=constants.ICON_COMPANY_LOGO_REQUIRED_WIDTH, height_accepted=constants.ICON_COMPANY_LOGO_REQUIRED_HEIGHT, default_path_to_icon=PATH_DEFAULT_ICON_COMPANY_LOGO) # Get the display name # Use --display-name if passed # If not use 'display_name' attribute in setup.py # If not set use the 'name' attribute in setup.py display_name = custom_display_name or setup_py_attributes.get("display_name") or setup_py_attributes.get("name") # Image string is all lowercase on quay.io image_name = "{0}/{1}:{2}".format(repository_name, setup_py_attributes.get("name"), setup_py_attributes.get("version")) if image_hash: if not sdk_helpers.is_valid_hash(image_hash): raise SDKException(u"image_hash '{0}' is not a valid SHA256 hash\nIt must be a valid hexadecimal and 64 characters long".format(image_hash)) # If image_hash is defined append to image name e.g. <repository_name>/<package_name>@sha256:<image_hash> image_name = "{0}/{1}@sha256:{2}".format(repository_name, setup_py_attributes.get("name"), image_hash) image_name = image_name.lower() LOG.debug("image_name generated: %s", image_name) # Generate the contents for the extension.json file the_extension_json_file_contents = { "author": { "name": setup_py_attributes.get("author"), "website": setup_py_attributes.get("url"), "icon": { "data": company_logo, "media_type": "image/png" } }, "description": { "content": setup_py_attributes.get("description"), "format": "text" }, "display_name": display_name, "icon": { "data": extension_logo, "media_type": "image/png" }, "long_description": { "content": u"<div>{0}</div>".format(setup_py_attributes.get("long_description")), "format": "html" }, "minimum_resilient_version": { "major": import_definition.get("server_version").get("major", None), "minor": import_definition.get("server_version").get("minor", None), "build_number": import_definition.get("server_version").get("build_number", None), "version": import_definition.get("server_version").get("version", None) }, "name": setup_py_attributes.get("name"), "tag": { "prefix": tag_name, "name": tag_name, "display_name": tag_name, "uuid": uuid }, "uuid": uuid, "version": setup_py_attributes.get("version"), "current_installation": { "executables": [ { "name": setup_py_attributes.get("name"), "image": image_name, "config_string": app_configs[0], "permission_handles": apikey_permissions, "uuid": uuid } ] } } # Write the executable.json file sdk_helpers.write_file(path_extension_json, json.dumps(the_extension_json_file_contents, sort_keys=True)) # Gather payload_samples file for each function and add to export.res file if exists if not path_payload_samples: LOG.warning("WARNING: No path for 'payload_samples' provided. Skipping adding them to the export.res file") else: for fn in import_definition.get("functions"): # Get paths to payload_samples fn_name = fn.get(ResilientObjMap.FUNCTIONS) path_payload_samples_fn = os.path.join(path_payload_samples, fn_name) path_payload_samples_schema = os.path.join(path_payload_samples_fn, BASE_NAME_PAYLOAD_SAMPLES_SCHEMA) path_payload_samples_example = os.path.join(path_payload_samples_fn, BASE_NAME_PAYLOAD_SAMPLES_EXAMPLE) try: # Validate payload_files, add custom error message if we can't sdk_helpers.validate_file_paths(os.R_OK, path_payload_samples_schema, path_payload_samples_example) except SDKException as err: err.message += ("\nWARNING: could not access JSON file to add payload_samples. Continuing to create package.\n" "Add '--no-samples' flag to avoid looking for them and avoid this warning message.\n") LOG.warning(err.message) continue # Read in schema payload and add to function import definition payload_samples_schema_contents_dict = sdk_helpers.read_json_file(path_payload_samples_schema) LOG.debug("Adding JSON output schema to '%s' from file: %s", fn_name, path_payload_samples_schema) json_schema_key = os.path.splitext(BASE_NAME_PAYLOAD_SAMPLES_SCHEMA)[0] fn[json_schema_key] = json.dumps(payload_samples_schema_contents_dict) # Read in example payload and add to function import definition payload_samples_example_contents_dict = sdk_helpers.read_json_file(path_payload_samples_example) LOG.debug("Adding JSON output example to '%s' from file: %s", fn_name, path_payload_samples_example) json_example_key = os.path.splitext(BASE_NAME_PAYLOAD_SAMPLES_EXAMPLE)[0] fn[json_example_key] = json.dumps(payload_samples_example_contents_dict) if path_validate_report: path_zipped_validate_report = os.path.join(path_build, os.path.basename(path_validate_report)) shutil.copy(path_validate_report, path_zipped_validate_report) else: LOG.warn("WARNING: If a validation report is not included with your submission, it will get rejected. Run this command with the '--validate' flag to include validations.") # Write the customize ImportDefinition to the app*.zip export.res file sdk_helpers.write_file(path_export_res, json.dumps(import_definition, sort_keys=True)) # Copy the built distribution to the build dir, enforce rename to .tar.gz shutil.copy(path_built_distribution, os.path.join(path_build, "{0}.tar.gz".format(extension_name))) # Create the app.zip (Extension Zip) by zipping the build directory extension_zip_base_path = os.path.join(output_dir, "{0}{1}".format(PREFIX_EXTENSION_ZIP, extension_name)) extension_zip_name = shutil.make_archive(base_name=extension_zip_base_path, format="zip", root_dir=path_build) path_the_extension_zip = os.path.join(extension_zip_base_path, extension_zip_name) except SDKException as err: raise err except Exception as err: raise SDKException(err) finally: # Remove the build dir. Keep it if user passes --keep-build-dir if not keep_build_dir: shutil.rmtree(path_build) LOG.info("App %s.zip created", "{0}{1}".format(PREFIX_EXTENSION_ZIP, extension_name)) # Return the path to the extension zip return path_the_extension_zip
def execute_command(self, args): LOG.debug("docgen called with %s", args) # Set docgen name for SDKException SDKException.command_ran = self.CMD_NAME # Get absolute path_to_src path_to_src = os.path.abspath(args.p) LOG.debug("Path to project: %s", path_to_src) # Instansiate Jinja2 Environment with path to Jinja2 templates jinja_env = sdk_helpers.setup_jinja_env("data/docgen/templates") # Load the Jinja2 Templates readme_template = jinja_env.get_template(README_TEMPLATE_NAME) # Generate path to setup.py file path_setup_py_file = os.path.join(path_to_src, package_helpers.BASE_NAME_SETUP_PY) try: # Ensure we have read permissions for setup.py sdk_helpers.validate_file_paths(os.R_OK, path_setup_py_file) except SDKException as err: err.message += "\nEnsure you are in the directory of the package you want to run docgen for" raise err # Parse the setup.py file setup_py_attributes = package_helpers.parse_setup_py( path_setup_py_file, package_helpers.SUPPORTED_SETUP_PY_ATTRIBUTE_NAMES) package_name = setup_py_attributes.get("name", "") # Generate paths to other required directories + files path_customize_py_file = os.path.join( path_to_src, package_name, package_helpers.PATH_CUSTOMIZE_PY) path_config_py_file = os.path.join(path_to_src, package_name, package_helpers.PATH_CONFIG_PY) path_readme = os.path.join(path_to_src, package_helpers.BASE_NAME_README) path_screenshots_dir = os.path.join(path_to_src, package_helpers.PATH_SCREENSHOTS) path_payload_samples_dir = os.path.join( path_to_src, package_helpers.BASE_NAME_PAYLOAD_SAMPLES_DIR) # Ensure we have read permissions for each required file and the file exists sdk_helpers.validate_file_paths(os.R_OK, path_setup_py_file, path_customize_py_file, path_config_py_file) # Check doc/screenshots directory exists, if not, create it + copy default screenshot if not os.path.isdir(path_screenshots_dir): os.makedirs(path_screenshots_dir) shutil.copy(package_helpers.PATH_DEFAULT_SCREENSHOT, path_screenshots_dir) # Get the resilient_circuits dependency string from setup.py file res_circuits_dep_str = package_helpers.get_dependency_from_install_requires( setup_py_attributes.get("install_requires"), "resilient_circuits") if not res_circuits_dep_str: res_circuits_dep_str = package_helpers.get_dependency_from_install_requires( setup_py_attributes.get("install_requires"), "resilient-circuits") # Get ImportDefinition from customize.py customize_py_import_def = package_helpers.get_import_definition_from_customize_py( path_customize_py_file) # Parse the app.configs from the config.py file jinja_app_configs = package_helpers.get_configs_from_config_py( path_config_py_file) # Get field names from ImportDefinition field_names = [] for f in customize_py_import_def.get("fields", []): f_export_key = f.get("export_key") if "incident/" in f_export_key and f_export_key not in IGNORED_INCIDENT_FIELDS: field_names.append(f.get(ResilientObjMap.FIELDS, "")) # Get data from ImportDefinition import_def_data = sdk_helpers.get_from_export( customize_py_import_def, message_destinations=sdk_helpers.get_object_api_names( ResilientObjMap.MESSAGE_DESTINATIONS, customize_py_import_def.get("message_destinations")), functions=sdk_helpers.get_object_api_names( ResilientObjMap.FUNCTIONS, customize_py_import_def.get("functions")), workflows=sdk_helpers.get_object_api_names( ResilientObjMap.WORKFLOWS, customize_py_import_def.get("workflows")), rules=sdk_helpers.get_object_api_names( ResilientObjMap.RULES, customize_py_import_def.get("actions")), fields=field_names, artifact_types=sdk_helpers.get_object_api_names( ResilientObjMap.INCIDENT_ARTIFACT_TYPES, customize_py_import_def.get("incident_artifact_types")), datatables=sdk_helpers.get_object_api_names( ResilientObjMap.DATATABLES, customize_py_import_def.get("types")), tasks=sdk_helpers.get_object_api_names( ResilientObjMap.TASKS, customize_py_import_def.get("automatic_tasks")), scripts=sdk_helpers.get_object_api_names( ResilientObjMap.SCRIPTS, customize_py_import_def.get("scripts")), playbooks=sdk_helpers.get_object_api_names( ResilientObjMap.PLAYBOOKS, customize_py_import_def.get("playbooks", []))) # Lists we use in Jinja Templates jinja_functions = self._get_function_details( import_def_data.get("functions", []), import_def_data.get("workflows", [])) jinja_scripts = self._get_script_details( import_def_data.get("scripts", [])) jinja_rules = self._get_rule_details(import_def_data.get("rules", [])) jinja_datatables = self._get_datatable_details( import_def_data.get("datatables", [])) jinja_custom_fields = self._get_custom_fields_details( import_def_data.get("fields", [])) jinja_custom_artifact_types = self._get_custom_artifact_details( import_def_data.get("artifact_types", [])) jinja_playbooks = self._get_playbook_details( import_def_data.get("playbooks", [])) # Other variables for Jinja Templates package_name_dash = package_name.replace("_", "-") server_version = customize_py_import_def.get("server_version", {}) supported_app = sdk_helpers.does_url_contain( setup_py_attributes.get("url", ""), "ibm.com/mysupport") # See if a payload_samples dir exists and use the contents for function results try: sdk_helpers.validate_dir_paths(os.R_OK, path_payload_samples_dir) for f in jinja_functions: fn_name = f.get("x_api_name") path_payload_samples_fn_name = os.path.join( path_payload_samples_dir, fn_name) path_output_json_example = os.path.join( path_payload_samples_fn_name, package_helpers.BASE_NAME_PAYLOAD_SAMPLES_EXAMPLE) try: sdk_helpers.validate_file_paths(os.R_OK, path_output_json_example) f["results"] = sdk_helpers.read_json_file( path_output_json_example) except SDKException as e: sdk_helpers.handle_file_not_found_error( e, u"Error getting results. No '{0}' file found for '{1}'." .format( package_helpers.BASE_NAME_PAYLOAD_SAMPLES_EXAMPLE, fn_name)) except SDKException as e: sdk_helpers.handle_file_not_found_error( e, u"Error getting results. No '{0}' directory found.".format( package_helpers.BASE_NAME_PAYLOAD_SAMPLES_EXAMPLE)) LOG.info("Rendering README for %s", package_name_dash) # Render the README Jinja2 Templeate with parameters rendered_readme = readme_template.render({ "name_underscore": package_name, "name_dash": package_name_dash, "display_name": setup_py_attributes.get("display_name", package_name), "short_description": setup_py_attributes.get("description"), "long_description": setup_py_attributes.get("long_description"), "version": setup_py_attributes.get("version"), "server_version": server_version.get("version"), "all_dependencies": setup_py_attributes.get("install_requires", []), "res_circuits_dependency_str": res_circuits_dep_str, "author": setup_py_attributes.get("author"), "support_url": setup_py_attributes.get("url"), "supported_app": supported_app, "app_configs": jinja_app_configs[1], "functions": jinja_functions, "scripts": jinja_scripts, "rules": jinja_rules, "datatables": jinja_datatables, "custom_fields": jinja_custom_fields, "custom_artifact_types": jinja_custom_artifact_types, "playbooks": jinja_playbooks, "placeholder_string": constants.DOCGEN_PLACEHOLDER_STRING }) # Create a backup if needed of README sdk_helpers.rename_to_bak_file(path_readme, package_helpers.PATH_DEFAULT_README) LOG.info("Writing README to: %s", path_readme) # Write the new README sdk_helpers.write_file(path_readme, rendered_readme)