def __validate_static_directory(self): output = {"status": True, "message": ""} if os.path.isdir(join_path(self.path_to_app, "static")): subs = get_sub_dirs_and_files(join_path(self.path_to_app, "static")) if len(subs["files"]) > 0: output["status"] = False output["message"] = "static directory does not follow the required " \ "directory structure." print("-- An Error Occurred -- {0}".format(output["message"])) else: if not os.path.isdir( join_path(self.path_to_app, "static", self.app_name)): output["status"] = False output["message"] = "static directory does not follow the required " \ "directory structure." print("-- An Error Occurred -- {0}".format( output["message"])) else: subs_files = get_paths_of_subfiles( join_path(self.path_to_app, "static", self.app_name), re.compile("\.js$")) path_to_js = join_path(self.path_to_app, "static", self.app_name, "js") for sub_file in subs_files: if not sub_file.startswith(path_to_js): output["status"] = False output[ "message"] = "A .js file cannot be outside the 'js' folder." print("-- An Error Occurred -- {0}".format( output["message"])) return output
def ready(self): """ The ready function is trigger only on events like server start up and server reload """ # print "***************You are in Core Katana App Config Class***************" nav_obj = Navigator() base_directory = nav_obj.get_katana_dir() warrior_dir = nav_obj.get_warrior_dir() config_file_name = "wf_config.json" config_json_file = join_path(base_directory, "config.json") settings_file_path = get_abs_path(join_path("wui", "settings.py"), base_directory) core_index_obj = CoreIndex(base_directory, settings_file_path=settings_file_path) available_apps = core_index_obj.get_available_apps() settings_apps = core_index_obj.get_apps_from_settings_file() AppInformation.information = Apps() AppInformation.information.set_apps({'base_directory': base_directory, 'config_file_name': config_file_name, 'available_apps': available_apps, 'settings_apps': settings_apps}) ordered_json = validate_config_json(read_json_data(config_json_file), warrior_dir) with open(config_json_file, "w") as f: f.write(json.dumps(ordered_json, indent=4))
def __init__(self, filepath): self.navigator = Navigator() self.app_name = get_sub_folders( join_path(filepath, "warriorframework_py3", "katana", "wapps"))[0] self.path_to_app = join_path(filepath, "warriorframework_py3", "katana", "wapps", self.app_name) self.wf_config_file = join_path(self.path_to_app, "wf_config.json") self.urls_inclusions = [] self.mandatory_fields = [ "app", "version", "warrior-compatibility", "warrior-incompatibility" ]
def open_config(request): config_name = request.GET['config_name'] config_path = join_path(WappManagementView.dot_data_directory, "{0}.xml".format(config_name)) config_file_data_dir = join_path(WappManagementView.dot_data_directory, config_name) info = [] show_install_btn = True with open(config_path, 'r') as f: data = f.read() tree = ET.ElementTree(ET.fromstring(data)) apps = tree.findall('app') for app in apps: temp = {} if app.find('zip', None) is not None: node = app.find('zip', None) type_of_app = "zip" text = node.text if not os.path.exists(join_path(config_file_data_dir, text)): show_install_btn = False needs_update = True else: needs_update = False elif app.find('repository', None) is not None: node = app.find('repository', None) type_of_app = "repository" text = node.text needs_update = False else: node = app.find('filepath', None) type_of_app = "filepath" text = node.text if not os.path.exists(text): show_install_btn = False needs_update = True else: needs_update = False temp["name"] = text temp["type"] = type_of_app temp["needs_update"] = needs_update info.append(temp) output_data = { "config_name": config_name, "preference_details": info, "show_install_btn": show_install_btn } return render(request, 'wapp_management/config_details.html', output_data)
def __init__(self, base_directory, path_to_app): self.base_directory = base_directory self.app_directory = join_path(self.base_directory, "katana", "wapps") self.plugin_directory = join_path(self.base_directory, "warrior", "plugins") self.settings_file = join_path(self.base_directory, "katana", "wui", "settings.py") self.urls_file = join_path(self.base_directory, "katana", "wui", "urls.py") self.app_name = get_sub_folders( join_path(path_to_app, "warriorframework_py3", "katana", "wapps"))[0] self.path_to_app = join_path(path_to_app, "warriorframework_py3", "katana", "wapps", self.app_name) self.path_to_plugin_dir = join_path(path_to_app, "warriorframework_py3", "warrior", "plugins") self.wf_config_file = join_path(self.path_to_app, "wf_config.json") self.plugins_paths = get_sub_folders(self.path_to_plugin_dir, abs_path=True) self.pkg_in_settings = "wapps.{0}".format(self.app_name) self.urls_inclusions = [] self.settings_backup = [] self.urls_backup = [] self.delete_app_dir = [] self.delete_plugins_dir = [] self.config_data = None self.message = ""
def read_config_file(request): nav_obj = Navigator() config_file_path = join_path(nav_obj.get_katana_dir(), "config.json") data = read_json_data(config_file_path) if data is None: data = False return JsonResponse(data)
def __init__(self, json_data, path, base_directory): """Constructor of the App Class""" self.data = json_data self.path = get_relative_path(path, base_directory) self.static_file_dir = join_path("static", get_dir_from_path(path)) self.app_type = get_dir_from_path(get_parent_directory(path)) self.app_dir_name = get_dir_from_path(path)
def post(self, request): app_paths = request.POST.getlist("app_paths[]") filename = request.POST.get("filename") root = ET.Element("data") for app_path in app_paths: app = ET.SubElement(root, "app") if os.path.exists(app_path): ET.SubElement(app, "filepath").text = app_path else: ET.SubElement(app, "repository").text = app_path fpath = join_path(WappManagementView.dot_data_directory, "{0}.xml".format(filename)) xml_str = ET.tostring(root, encoding='utf8', method='xml') with open(fpath, "w") as f: f.write(xml_str) files = get_sub_files(WappManagementView.dot_data_directory) preferences = [] for subfile in files: filename, file_extension = os.path.splitext(subfile) if file_extension == ".xml": preferences.append(filename) output_data = {"data": {"preferences": preferences}} return render(request, 'wapp_management/saved_preferences.html', output_data)
def prerequisites_handler(self, request): ref_file = join_path(self.static_dir, "base_templates", "empty.xml") prereqs = read_xml_get_json(ref_file)["data"]["warhorn"]["dependency"] prereq_data = [] for prereq in prereqs: temp = {} for key, value in list(prereq.items()): temp[key.strip('@')] = value temp["status"] = "install" try: module_name = __import__(temp["name"]) some_var = module_name.__version__ except ImportError: temp["available_version"] = "--" temp["installBtnText"] = "Install" except Exception as e: print( "-- An Exception Occurred -- while getting details about {0}: {1}" .format(temp["name"], e)) temp["available_version"] = "--" temp["installBtnText"] = "Install" else: temp["available_version"] = some_var if LooseVersion(str(temp["version"])) <= LooseVersion( str(temp["available_version"])): temp["installBtnText"] = "Installed" temp["status"] = "installed" else: temp["installBtnText"] = "Upgrade" temp["status"] = "upgrade" prereq_data.append(copy.deepcopy(temp)) return prereq_data
def install_an_app(request): app_path = request.POST.get("app_paths") dot_data_dir = join_path(nav_obj.get_katana_dir(), "native", "wapp_management", ".data") temp_dir_path = join_path(dot_data_dir, "temp") output_data = {"status": True, "message": ""} if os.path.exists(temp_dir_path): shutil.rmtree(temp_dir_path) create_dir(temp_dir_path) if app_path.endswith(".git"): repo_name = get_repository_name(app_path) os.system("git clone {0} {1}".format( app_path, join_path(temp_dir_path, repo_name))) app_path = join_path(temp_dir_path, repo_name) elif app_path.endswith(".zip"): if os.path.exists(app_path): temp = app_path.split(os.sep) temp = temp[len(temp) - 1] shutil.copyfile(app_path, join_path(temp_dir_path, temp)) zip_ref = zipfile.ZipFile(join_path(temp_dir_path, temp), 'r') zip_ref.extractall(temp_dir_path) zip_ref.close() app_path = join_path(temp_dir_path, temp[:-4]) else: output_data["status"] = False output_data[ "message"] = "-- An Error Occurred -- {0} does not exist".format( app_path) print(output_data["message"]) else: if os.path.isdir(app_path): filename = get_dir_from_path(app_path) copy_dir(app_path, join_path(temp_dir_path, filename)) app_path = join_path(temp_dir_path, filename) else: output_data["status"] = False output_data[ "message"] = "-- An Error Occurred -- {0} does not exist".format( app_path) print(output_data["message"]) installer_obj = Installer(get_parent_directory(nav_obj.get_katana_dir()), app_path) installer_obj.install() if installer_obj.message != "": output_data["status"] = False output_data["message"] += "\n" + installer_obj.message return JsonResponse(output_data)
def validate_app_path(request): output = {"status": True, "message": ""} detail_type = request.POST.get("type", None) detail_info = request.POST.get("value", None) dot_data_dir = join_path(nav_obj.get_katana_dir(), "native", "wapp_management", ".data") temp_dir_path = join_path(dot_data_dir, "temp") app_path = False if os.path.exists(temp_dir_path): shutil.rmtree(temp_dir_path) if create_dir(temp_dir_path): if detail_type == "repository": repo_name = get_repository_name(detail_info) os.system("git clone {0} {1}".format( detail_info, join_path(temp_dir_path, repo_name))) app_path = join_path(temp_dir_path, repo_name) elif detail_type == "zip": if os.path.exists(detail_info): temp = detail_info.split(os.sep) temp = temp[len(temp) - 1] shutil.copyfile(detail_info, join_path(temp_dir_path, temp)) zip_ref = zipfile.ZipFile(join_path(temp_dir_path, temp), 'r') zip_ref.extractall(temp_dir_path) zip_ref.close() app_path = join_path(temp_dir_path, temp[:-4]) else: output["status"] = False output["message"] = "{0} does not exist".format(detail_info) print("-- An Error Occurred -- ".format(output["message"])) elif detail_type == "filepath": if os.path.isdir(detail_info): filename = get_dir_from_path(detail_info) copy_dir(detail_info, join_path(temp_dir_path, filename)) app_path = join_path(temp_dir_path, filename) else: output["status"] = False output[ "message"] = "{0} does not exist or is not a directory".format( detail_info) print("-- An Error Occurred -- {0}".format(output["message"])) else: print("-- An Error Occurred -- Type of validation not given.") if app_path: app_validator_obj = AppValidator(app_path) output = app_validator_obj.is_valid() else: print("-- An Error Occurred -- Could not create temporary directory.") return JsonResponse(output)
def check_if_file_exists(request): filename = request.POST.get("filename") directory = request.POST.get("directory") extension = request.POST.get("extension") path = request.POST.get("path") if path is not None: output = {"exists": file_or_dir_exists(path)} else: output = {"exists": file_or_dir_exists(join_path(directory, filename + extension))} return JsonResponse(output)
def get_file_explorer_data(request): nav_obj = Navigator() if "data[start_dir]" in request.POST and request.POST["data[start_dir]"] != "false": start_dir = request.POST["data[start_dir]"] elif "data[path]" in request.POST and request.POST["data[path]"] != "false": start_dir = get_parent_directory(request.POST["data[path]"]) else: start_dir = join_path(nav_obj.get_warrior_dir(), "Warriorspace") output = nav_obj.get_dir_tree_json(start_dir_path=start_dir) return JsonResponse(output)
def __init__(self, data_file, ref_data_file): self.data_file = data_file self.data = read_xml_get_json(data_file) self.ref_data_file = ref_data_file self.nav_obj = Navigator() self.dependency_template = join_path(self.nav_obj.get_katana_dir(), "native", "settings", "static", "settings", "base_templates", "empty.xml") self.ref_data = self._get_ref_data() self.dependency_dict = self.__get_dependency_dict()
def __add_app_directory(self): temp_app_path = join_path(self.app_directory, self.app_name) if os.path.exists(temp_app_path): output = False message = "-- An Error Occurred -- Directory already exists: {0}.".format( temp_app_path) print(message) self.message += message else: output = copy_dir(self.path_to_app, temp_app_path) self.delete_app_dir.append(self.path_to_app) return output
class CliDataFileClass(View): nav_obj = Navigator() app_directory = join_path(nav_obj.get_katana_dir(), "wapps", "cli_data") app_static_dir = join_path(app_directory, "static") def get(self, request): filepath = request.GET.get('path') # filepath = join_path(CliDataFileClass.app_static_dir, "base_templates", "test.xml") base_filepath = join_path(CliDataFileClass.app_static_dir, "base_templates", "empty.xml") if filepath == "false": filepath = base_filepath name = "Untitled" else: name, _ = os.path.splitext(get_dir_from_path(filepath)) vcdc_obj = VerifyCliDataClass(filepath, base_filepath) json_data = vcdc_obj.verify_contents() return JsonResponse({ "contents": json_data, "name": name, "filepath": get_parent_dir_path(filepath) }) def post(self, request): json_data = json.loads(request.POST.get('json_data')) data = xmltodict.unparse(json_data) directory = request.POST.get('directory') filepath = os.path.join(directory, request.POST.get('filename') + ".xml") message = "" saved = True try: with open(filepath, 'w') as f: f.write(data) except Exception as e: saved = False message = e return JsonResponse({"saved": saved, "message": message})
def __add_plugins(self): output = True for plugin in self.plugins_paths: if output: plugin_name = get_dir_from_path(plugin) temp_pl_path = join_path(self.plugin_directory, plugin_name) if os.path.exists(temp_pl_path): output = False message = "-- An Error Occurred -- Directory already exists: {0}.".format( temp_pl_path) print(message) self.message += message else: output = copy_dir(plugin, temp_pl_path) self.delete_plugins_dir.append(plugin) return output
def set_apps(self, data): """ call this to build Apps array and make app objects """ self.get_config_paths(data) for url in self.paths: json_data = read_json_data(url) if json_data is not None: app_path = get_parent_directory(url) app = App(json_data, app_path, data["base_directory"]) js_urls = get_paths_of_subfiles( join_path(app_path, app.static_file_dir, "js"), extension=compile_regex("^\.js$")) for i in range(0, len(js_urls)): js_urls[i] = get_relative_path(js_urls[i], app_path) app.data["js_urls"] = js_urls self.apps.append(app) return self.apps
def get(self, request): filepath = request.GET.get('path') # filepath = join_path(CliDataFileClass.app_static_dir, "base_templates", "test.xml") base_filepath = join_path(CliDataFileClass.app_static_dir, "base_templates", "empty.xml") if filepath == "false": filepath = base_filepath name = "Untitled" else: name, _ = os.path.splitext(get_dir_from_path(filepath)) vcdc_obj = VerifyCliDataClass(filepath, base_filepath) json_data = vcdc_obj.verify_contents() return JsonResponse({ "contents": json_data, "name": name, "filepath": get_parent_dir_path(filepath) })
def _get_package_list(self, driver_path): """ This function gets the list of packages included in each driver """ with open(driver_path, 'r') as f: data = f.readlines() list_of_pkgs = [] package_list = [] for line in data: if line.strip().startswith('package_list'): temp = line.split("[")[1].strip()[:-1] list_of_pkgs = [x.strip() for x in temp.split(",")] break for pkg in list_of_pkgs: temp = pkg.split(".") path = self.warrior_dir for i in range(0, len(temp)): path = join_path(path, temp[i]) package_list.append(path) return package_list
def validate_config_json(json_data, warrior_dir): """ This function validates the config.json file and returns an ordered dictionary :param json_data: original unordered contents of config.json :param warrior_dir: path to warrior directory :return: Ordered Dictionary containing validated config.json data """ ordered_json = OrderedDict() if "engineer" not in json_data: ordered_json["engineer"] = "" else: ordered_json["engineer"] = json_data["engineer"] ordered_json["pythonsrcdir"] = warrior_dir[:-1] \ if "pythonsrcdir" not in json_data or json_data["pythonsrcdir"] == "" \ else json_data["pythonsrcdir"] warrior_dir = ordered_json["pythonsrcdir"] ref = OrderedDict([("xmldir", "Testcases"), ('testsuitedir', 'Suites'), ('projdir', 'Projects'), ('idfdir', 'Data'), ('testdata', 'Config_files')]) for key, value in list(ref.items()): if key not in json_data or json_data[key] == "": path = get_abs_path(join_path("Warriorspace", value), warrior_dir) if path is not None: ordered_json[key] = path else: ordered_json[key] = "" print( "-- An Error Occurred -- Path to {0} directory could not be located" .format(value)) else: ordered_json[key] = json_data[key] if "pythonpath" not in json_data: ordered_json["pythonpath"] = "" else: ordered_json["pythonpath"] = json_data["pythonpath"] return ordered_json
def save_file(request): """ This function saves the file in the given path. """ output = {"status": True, "message": ""} data = json.loads(request.POST.get("data"), object_pairs_hook=collections.OrderedDict) data["TestWrapper"]["Details"] = validate_details_data(data["TestWrapper"]["Details"]) data["TestWrapper"]["Setup"]["step"] = validate_step_data(data["TestWrapper"]["Setup"]["step"]) data["TestWrapper"]["Cleanup"]["step"] = validate_step_data(data["TestWrapper"]["Cleanup"]["step"]) data["TestWrapper"]["Debug"]["step"] = validate_step_data(data["TestWrapper"]["Debug"]["step"]) xml_data = xmltodict.unparse(data, pretty=True) directory = request.POST.get("directory") filename = request.POST.get("filename") extension = request.POST.get("extension") try: with open(join_path(directory, filename + extension), 'w') as f: f.write(xml_data) except Exception as e: output["status"] = False output["message"] = e print("-- An Error Occurred -- {0}".format(e)) return JsonResponse(output)
class WappManagementView(View): template = 'wapp_management/wapp_management.html' dot_data_directory = join_path(nav_obj.get_katana_dir(), "native", "wapp_management", ".data") def get(self, request): """ Get Request Method """ files = get_sub_files(WappManagementView.dot_data_directory) preferences = [] for subfile in files: filename, file_extension = os.path.splitext(subfile) if file_extension == ".xml": preferences.append(filename) output = { "data": { "app": AppInformation.information.apps, "preferences": preferences } } return render(request, WappManagementView.template, output)
def __verify_app_details(self, app_details): output = {"status": True, "message": ""} if "name" not in app_details or "url" not in app_details or "include" not in app_details: print( "-- An Error Occurred -- wf_config.json file is not in the correct format." ) output["status"] = False else: self.urls_inclusions.append("url(r'^" + app_details["url"] + "', include('" + app_details["include"] + "')),") path_dir = app_details["include"].split(".") path_urls = "" for d in range(2, len(path_dir)): path_urls += os.sep + path_dir[d] path_urls = path_urls.strip(os.sep) path_urls += ".py" path_to_urls_abs = join_path(self.path_to_app, path_urls) if not os.path.isfile(path_to_urls_abs): output["status"] = False output["message"] = "Package {0} does not exist.".format( app_details["include"]) print("-- An Error Occurred -- {0}".format(output["message"])) return output
def __init__(self, base_directory, app_path, app_type): self.app_name = get_dir_from_path(app_path) self.base_directory = base_directory self.plugin_dir = join_path(self.base_directory, "warrior", "plugins") self.app_dir = join_path(self.base_directory, "katana", app_type) self.settings_file = join_path(self.base_directory, "katana", "wui", "settings.py") self.urls_file = join_path(self.base_directory, "katana", "wui", "urls.py") self.app_path = get_abs_path(self.app_name, self.app_dir) self.app_type = app_type self.config_file = join_path(self.app_path, "wf_config.json") self.config_file_data = read_json_data(self.config_file) self.related_plugins = self.__extract_plugin_names() self.pkg_in_settings = self.__get_setting_file_info() self.include_urls = self.__get_urls_info() self.valid_app_types = {"wapps"} self.cache_dir = create_dir( join_path(self.base_directory, "katana", ".data", self.app_name)) self.settings_backup = [] self.urls_backup = []
def run_process(os_string): return subprocess.Popen(os_string.split(), shell=False, stdin=None, stdout=None, stderr=None, close_fds=True) def to_string(self, args): args[0] = self.manage_path if len(args) > 1 and args[1] == 'database': args.remove('database') return 'python3 ' + ' '.join(args) def katana_init(self, args): args[0] = self.manage_path self.og_process = self.run_process(self.to_string(args)) signal.signal(signal.SIGINT, self.signal_handler) if len(args) > 1 and args[1] == 'database': self.database_init() signal.pause() def database_init(self): proc = self.run_process('python3 {0} makemigrations'.format(self.manage_path)) proc.wait() proc = self.run_process('python3 {0} migrate --run-syncdb'.format(self.manage_path)) proc.wait() if __name__ == "__main__": if not use_py_server: katana = Katana(join_path(get_parent_dir_path(sys.argv[0]), "manage.py")) katana.katana_init(sys.argv) else: main('8000')
def __init__(self, warrior_dir): """Constructor for GetDriversActions Class""" self.warrior_dir = warrior_dir self.actions_dir = join_path(self.warrior_dir, "Actions") self.pd_dir = join_path(self.warrior_dir, "ProductDrivers") self.information = self._get_drivers()
from django.views import View import collections import json import os import xmltodict from django.http import JsonResponse from django.template.loader import render_to_string from utils.directory_traversal_utils import join_path, get_parent_dir_path, get_dir_from_path from utils.json_utils import read_json_data, read_xml_get_json from utils.navigator_util import Navigator from wapps.suites.suite_utils.defaults import on_errors, impacts, contexts, runmodes, \ executiontypes, runtypes from wapps.suites.suite_utils.verify_suite_file import VerifySuiteFile navigator = Navigator() CONFIG_FILE = join_path(navigator.get_katana_dir(), "config.json") APP_DIR = join_path(navigator.get_katana_dir(), "wapps", "suites") STATIC_DIR = join_path(APP_DIR, "static", "suites") TEMPLATE = join_path(STATIC_DIR, "base_templates", "Untitled.xml") DROPDOWN_DEFAULTS = read_json_data( join_path(STATIC_DIR, "base_templates", "dropdowns_data.json")) class SuitesView(View): def get(self, request): """ Get Request Method """ return render(request, 'suites/suites.html')
def __init__(self): self.navigator = Navigator() self.static_dir = join_path(self.navigator.get_katana_dir(), "native", "settings", "static", "settings")
import os import xmltodict from django.http import JsonResponse from django.shortcuts import render from django.template.loader import render_to_string from django.views import View from utils.directory_traversal_utils import join_path, get_dir_from_path, get_parent_dir_path from utils.json_utils import read_json_data from utils.navigator_util import Navigator from wapps.testwrapper.testwrapper_utils.defaults import impacts, on_errors, runmodes, iteration_types, contexts from wapps.testwrapper.testwrapper_utils.get_drivers import GetDriversActions from wapps.testwrapper.testwrapper_utils.verify_testwrapper_file import VerifyTestWrapperFile navigator = Navigator() CONFIG_FILE = join_path(navigator.get_katana_dir(), "config.json") APP_DIR = join_path(navigator.get_katana_dir(), "wapps", "testwrapper") STATIC_DIR = join_path(APP_DIR, "static", "testwrapper") TEMPLATE = join_path(STATIC_DIR, "base_templates", "Untitled.xml") DROPDOWN_DEFAULTS = read_json_data(join_path(STATIC_DIR, "base_templates", "dropdowns_data.json")) clas TestWrapperView(View): def get(self, request): """ Get Request Method """ return render(request, 'testwrapper/cases.html')