atomicshop 2.15.11__py3-none-any.whl → 3.10.5__py3-none-any.whl

atomicshop/wrappers/elasticsearchw/elastic_infra.py

@@ -0,0 +1,75 @@
+import sys
+import time
+import requests
+
+from ...print_api import print_api
+from ... import filesystem
+from .. import ubuntu_terminal
+from . import config_basic
+
+
+def is_elastic_service_running():
+    return ubuntu_terminal.is_service_running(config_basic.UBUNTU_ELASTIC_SERVICE_NAME, return_false_on_error=False)
+
+
+def enable_elastic_service():
+    ubuntu_terminal.enable_service(config_basic.UBUNTU_ELASTIC_SERVICE_NAME, sudo=True)
+
+
+def start_elastic_service():
+    ubuntu_terminal.start_service(config_basic.UBUNTU_ELASTIC_SERVICE_NAME, sudo=True)
+
+
+def is_kibana_service_running():
+    return ubuntu_terminal.is_service_running(config_basic.UBUNTU_KIBANA_SERVICE_NAME, return_false_on_error=False)
+
+
+def enable_kibana_service():
+    ubuntu_terminal.enable_service(config_basic.UBUNTU_KIBANA_SERVICE_NAME, sudo=True)
+
+
+def start_kibana_service():
+    ubuntu_terminal.start_service(config_basic.UBUNTU_KIBANA_SERVICE_NAME, sudo=True)
+
+
+def is_server_available(
+        max_attempts: int = 5,
+        wait_between_attempts_seconds: float = 10,
+        elastic_url: str = None,
+        print_kwargs: dict = None
+):
+    """
+    The function checks if Elasticsearch server is up and running by sending GET request to the Elasticsearch server.
+    :param max_attempts: int, the maximum number of attempts to check if Elasticsearch is running.
+    :param wait_between_attempts_seconds: float, the time to wait between attempts.
+    :param elastic_url: str, the URL of the Elasticsearch server. If None, the default URL will be used.
+    :param print_kwargs: dict, the keyword arguments for the print_api function.
+    :return:
+    """
+
+    if not elastic_url:
+        elastic_url = config_basic.DEFAULT_ELASTIC_URL
+
+    if not print_kwargs:
+        print_kwargs = dict()
+
+    for attempt in range(1, max_attempts + 1):
+        print_api(f"Checking if Elasticsearch is running (Attempt {attempt}/{max_attempts})...", **print_kwargs)
+
+        try:
+            response = requests.get(elastic_url)
+            status_code = response.status_code
+
+            if status_code == 200:
+                print_api("Elasticsearch is up and running.", color='green', **print_kwargs)
+                return True
+            else:
+                print_api(f"Elasticsearch is not running. Status code: {status_code}", color='yellow', **print_kwargs)
+        except requests.exceptions.RequestException as e:
+            print_api(f"Failed to connect to Elasticsearch: {e}", color='yellow', **print_kwargs)
+
+        print_api("Waiting for Elasticsearch to start...", **print_kwargs)
+        time.sleep(wait_between_attempts_seconds)
+
+    print_api("Elasticsearch did not start within the expected time.", color='red', **print_kwargs)
+    return False

atomicshop/wrappers/elasticsearchw/elasticsearchw.py

@@ -6,10 +6,8 @@ from typing import Union
 from . import config_basic
 from ...basics import dicts
 
-ELASTIC_WRAPPER = None
 
-
-def get_elastic_wrapper(url: str = None, overwrite: bool = False):
+def get_elastic_wrapper(url: str = config_basic.DEFAULT_ELASTIC_URL, overwrite: bool = False):
     """
     The function initializes the Elasticsearch wrapper.
 
@@ -19,25 +17,9 @@ def get_elastic_wrapper(url: str = None, overwrite: bool = False):
 
     Usage:
         elastic_wrapper = get_elastic_wrapper()
-    or after you initialize it once, you can use it like:
-        atomicshop.wrappers.elasticsearchw.elasticsearchw.ELASTIC_WRAPPER
     """
 
-    # If no url is provided, use the default url.
-    if url is None:
-        url = config_basic.DEFAULT_ELASTIC_URL
-
-    # Get the global variable.
-    global ELASTIC_WRAPPER
-    # If the wrapper is not initialized, initialize it.
-    if ELASTIC_WRAPPER is None:
-        ELASTIC_WRAPPER = Elasticsearch([url])
-    # If the wrapper is already initialized, check if it should be overwritten.
-    else:
-        if overwrite:
-            ELASTIC_WRAPPER = Elasticsearch([url])
-
-    return ELASTIC_WRAPPER
+    return Elasticsearch([url])
 
 
 def test_connection(elastic_wrapper: Elasticsearch = None):

atomicshop/wrappers/factw/get_file_data.py

@@ -33,11 +33,18 @@ def get_file_data(directory_path: str, firmwares: list = None):
     """
 
     if not firmwares:
-        firmwares: list = filesystem.get_file_hashes_from_directory(directory_path, recursive=False, add_binary=True)
+        firmwares: list = filesystem.get_paths_from_directory(
+            directory_path, get_file=True, recursive=False, add_file_binary=True, add_file_hash=True)
 
     # Add UIDs to the list.
+    final_firmwares: list = []
     for firmware in firmwares:
-        if 'uid' not in firmware:
-            firmware['uid'] = get_uid_from_file(file_binary=firmware['binary'], sha256_hash=firmware['hash'])
-
-    return firmwares
+        uid = get_uid_from_file(file_binary=firmware.binary, sha256_hash=firmware.hash)
+        final_firmwares.append({
+            'path': firmware.path,
+            'hash': firmware.hash,
+            'binary': firmware.binary,
+            'uid': uid
+        })
+
+    return final_firmwares

atomicshop/wrappers/factw/install/install_after_restart.py

@@ -1,14 +1,48 @@
 from typing import Union, Literal
 from pathlib import Path
 
-from .... import process, filesystem
+from .... import process, print_api
 from .. import config_install
 
 
+PLUGIN_LIST: list = [
+    'qemu_exec',
+    'binwalk',
+    'users_and_passwords',
+    'kernel_config',
+    'cve_lookup',
+    'crypto_hints',
+    'input_vectors',
+    'cwe_checker',
+    'linter',
+    'ip_and_uri_finder',
+    'device_tree',
+    'file_system_metadata',
+    'ipc',
+    'software_components',
+    'architecture_detection',
+    'known_vulnerabilities'
+]
+
+
+INSTALLING_STRINGS: list = ['Installing', 'plugin']
+FINISHED_INSTALLING_STRINGS: list = ['Finished installing', 'plugin']
+LOG_FINISHED_STRING: str = 'installation complete'
+
+
 def install_after_restart(
         installation_directory: str,
-        install_type: Union[None, Literal['backend', 'frontend', 'db']] = None
-):
+        install_type: Union[
+            None,
+            Literal['backend', 'frontend', 'db']] = None,
+        log_level: Union[
+            None,
+            Literal['DEBUG', 'INFO', 'WARNING', 'ERROR']] = None,
+        log_file: Union[
+            None,
+            str] = None,
+        analyze_log: bool = False
+) -> int:
     """
     This function will continue the installation the FACT_core after the restart of the computer.
 
@@ -20,7 +54,13 @@ def install_after_restart(
         --backend: Distributed setup, Install the FACT_core backend.
         --frontend: Distributed setup, Install the FACT_core frontend.
         --db: Distributed setup, Install the FACT_core database.
-    :return:
+    :param log_level: string, the log level to use for the installation.
+        The same as using the '--log-level' parameter in the 'install.py' script.
+        The default is 'INFO' in the 'install.py' script.
+    :param log_file: string, the log file to use for the installation.
+        The same as using the '--log-file' parameter in the 'install.py' script.
+    :param analyze_log: bool, if True, the log file will be analyzed for plugin installation errors.
+    :return: int, 0 if the installation was successful, otherwise 1.
     """
 
     install_command: str = 'python3 "' + str(Path(installation_directory, config_install.INSTALL_FILE_PATH)) + '"'
@@ -28,8 +68,52 @@ def install_after_restart(
     if install_type:
         install_command = install_command + ' --' + install_type
 
+    if log_level:
+        install_command = install_command + ' --log_level ' + log_level
+
+    if log_file:
+        install_command = install_command + ' --log_file "' + log_file + '"'
+
     # Install the FACT_core repo.
     process.execute_with_live_output(cmd=install_command, verbose=True)
+
+    # Analyze the log file for errors.
+    if analyze_log and (install_type == 'backend' or install_type is None):
+        if not log_file:
+            log_file = str(Path.cwd() / config_install.INSTALL_LOG_FILE_NAME)
+
+        return analyze_log_file(log_file=log_file)
+
     # Remove the FACT_core installation log.
-    working_directory_path: str = filesystem.get_working_directory()
+    # working_directory_path: str = filesystem.get_working_directory()
     # filesystem.remove_file(str(Path(working_directory_path, config_install.INSTALL_LOG_FILE_NAME)))
+
+    return 0
+
+
+def analyze_log_file(log_file: str):
+    """
+    This function will analyze the log file for plugin installation errors.
+    :param log_file:
+    :return:
+    """
+
+    with open(log_file, 'r') as file:
+        log_content: str = file.read()
+
+    for plugin in PLUGIN_LIST:
+        if f'{FINISHED_INSTALLING_STRINGS[0]} {plugin} {FINISHED_INSTALLING_STRINGS[1]}' not in log_content:
+            message = (f'Error: [{plugin}] plugin missing in the log. Installation failed.\n'
+                       f'Check the log file: {log_file}\n'
+                       f'Exiting...')
+            print_api.print_api(message, color='red')
+            return 1
+
+    if LOG_FINISHED_STRING not in log_content:
+        message = (f'Error: Installation failed.\n'
+                   f'Check the log file: {log_file}\n'
+                   f'Exiting...')
+        print_api.print_api(message, color='red')
+        return 1
+
+    return 0

atomicshop/wrappers/factw/install/pre_install_and_install_before_restart.py

@@ -1,12 +1,13 @@
-import sys
 import subprocess
 from pathlib import Path
 
-from .... import permissions, filesystem
-from ....archiver import zips
+from dkarchiver.arch_wrappers import zips
+from dkinst.installers.helpers import docker_installer
+
+from .... import filesystem
+from ....permissions import ubuntu_permissions
 from ....print_api import print_api
 from ... import githubw, pipw, ubuntu_terminal
-from ...dockerw import install_docker
 from .. import config_install
 
 
@@ -16,7 +17,7 @@ def install_before_restart(
         fact_source_archive_path: str = None,
         use_built_in_fact_installer: bool = True,
         print_kwargs: dict = None
-):
+) -> int:
     """
     This function will install the FACT_core before the restart of the computer.
     :param installation_directory: string, the directory to install the FACT_core to.
@@ -34,15 +35,15 @@ def install_before_restart(
         If False, only the regular prerequisites will be installed, while the user will need to install DOCKER
         and Node.js separately.
     :param print_kwargs: dict, the print kwargs for the print_api function.
-    :return:
+    :return: int, 0 if the installation was successful, 1 if there was an error.
     """
 
     # if not permissions.is_admin():
     #     print_api("This script requires root privileges...", color='red')
-    #     sys.exit(1)
+    #     return 1
 
     # # Install docker in rootless mode.
-    # with permissions.temporary_regular_permissions():
+    # with ubuntu_permissions.temporary_regular_permissions():
     #     install_docker.install_docker_ubuntu(
     #         use_docker_installer=True, rootless=True, add_current_user_to_docker_group_bool=False)
 
@@ -59,13 +60,13 @@ def install_before_restart(
         filesystem.remove_directory(installation_directory)
 
     # Since you run the script with sudo, we need to change the permissions to the current user.
-    # with permissions.temporary_regular_permissions():
+    # with ubuntu_permissions.temporary_regular_permissions():
     # Create the FACT_core directory.
     filesystem.create_directory(installation_directory)
 
     if not fact_source_archive_path:
         # Download the FACT_core repo.
-        if not filesystem.get_file_paths_from_directory(installation_directory):
+        if not filesystem.get_paths_from_directory(installation_directory, get_file=True):
             git_wrapper = githubw.GitHubWrapper(repo_url=config_install.FACT_CORE_GITHUB_URL)
             git_wrapper.build_links_from_repo_url()
             git_wrapper.download_and_extract_branch(
@@ -78,7 +79,7 @@ def install_before_restart(
             remove_first_directory=True, **(print_kwargs or {}))
 
     # Set the executable permission on the pre-installation file.
-    permissions.set_executable_permission(fact_core_pre_install_file_path)
+    ubuntu_permissions.set_executable(fact_core_pre_install_file_path)
 
     if use_built_in_fact_installer:
         # Run the shell script
@@ -86,9 +87,9 @@ def install_before_restart(
 
         # Install docker. FACT installs the docker, but there can be a problem with permissions, so we need to add
         # the user permissions to the docker group before restart.
-        if not install_docker.add_current_user_to_docker_group():
+        if not docker_installer.add_current_user_to_docker_group():
             print_api("Docker is installed, but the current user was not added to the docker group.", color='red')
-            sys.exit(1)
+            return 1
     else:
         message = ("You will need to install DOCKER and NODEJS separately.\n"
                    "This was done to enable Rootless docker install and install other version of NodeJS.")
@@ -107,8 +108,13 @@ def install_before_restart(
         #     use_docker_installer=True, rootless=True, add_current_user_to_docker_group_bool=False)
 
         # Install docker in regular mode.
-        install_docker.install_docker_ubuntu(
+        result: int = docker_installer.install_docker_ubuntu(
             use_docker_installer=True, rootless=False, add_current_user_to_docker_group_bool=True)
+        if result != 0:
+            print_api("Docker installation failed. Please install Docker manually.", color='red')
+            return result
 
     print_api("FACT_core installation before restart is finished.", color='green')
     print_api("Please restart the computer to continue the installation.", color='red')
+
+    return 0