atomicshop 2.9.13__py3-none-any.whl → 2.9.15__py3-none-any.whl

atomicshop/__init__.py

@@ -1,4 +1,4 @@
 """Atomic Basic functions and classes to make developer life easier"""
 
 __author__ = "Den Kras"
-__version__ = '2.9.13'
+__version__ = '2.9.15'

atomicshop/basics/booleans.py

@@ -5,9 +5,9 @@ def check_3_booleans_when_only_1_can_be_true(boolean1: tuple, boolean2: tuple, b
             (self.config['section']['default_usage'], 'default_usage'),
             (self.config['section']['create_usage'], 'create_usage'),
             (self.config['section']['custom_usage'], 'custom_usage'))
-    :param boolean1: tuple, first entry contains the value, second contains the name of the setting.
-    :param boolean2: tuple, first entry contains the value, second contains the name of the setting.
-    :param boolean3: tuple, first entry contains the value, second contains the name of the setting.
+    :param boolean1: tuple, (value, string name of the setting you want to print to the user to be aware of).
+    :param boolean2: tuple, (value, string name of the setting you want to print to the user to be aware of).
+    :param boolean3: tuple, (value, string name of the setting you want to print to the user to be aware of).
     :return:
     """
 

atomicshop/filesystem.py

@@ -1071,12 +1071,12 @@ def create_dict_of_path(
         parent_entry: str = None
 ):
     """
-    The function receives a path and a dictionary and adds the path to the dictionary.
+    The function receives a path and a list, and adds the path to the list.
 
     Check the working example from 'create_dict_of_paths_list' function.
 
     :param path: string, path.
-    :param structure_dict: dictionary to add the path to.
+    :param structure_list: list to add the path to.
     :param add_data_to_entry: any, data to add to the entry.
     :param add_data_key: string, key to add the data to.
     :param parent_entry: string, for internal use to pass the current parent entry.

atomicshop/mitm/connection_thread_worker.py

@@ -112,10 +112,9 @@ def thread_worker_main(
 
         # Loading parser by domain, if there is no parser for current domain - general reference parser is loaded.
         # These should be outside any loop and initialized only once entering the thread.
-        parser, responder, recorder = assign_class_by_domain(engines_list,
-                                                             client_message.server_name,
-                                                             reference_module=reference_module,
-                                                             logger=network_logger)
+        parser, responder, recorder = assign_class_by_domain(
+            engines_list, client_message.server_name, reference_module=reference_module, config=config,
+            logger=network_logger)
 
         # Defining client connection boolean variable to enter the loop
         client_connection_boolean: bool = True

atomicshop/mitm/engines/create_module_template.py

@@ -1,5 +1,4 @@
 import os
-from pathlib import Path
 from typing import Literal
 
 from ... import filesystem

atomicshop/mitm/import_config.py

@@ -63,6 +63,13 @@ class ImportConfig:
                 "Exiting..."
             )
 
+        # Check [dns] boolean configurations. ==========================================================================
+        check_3_booleans_when_only_1_can_be_true(
+            (self.config['dns']['route_to_tcp_server_only_engine_domains'], 'route_to_tcp_server_only_engine_domains'),
+            (self.config['dns']['route_to_tcp_server_all_domains'], 'route_to_tcp_server_all_domains'),
+            (self.config['dns']['regular_resolving'], 'regular_resolving')
+        )
+
         check_3_booleans_when_only_1_can_be_true(
             (self.config['certificates']['default_server_certificate_usage'], 'default_server_certificate_usage'),
             (self.config['certificates']['sni_create_server_certificate_for_each_domain'],

atomicshop/mitm/initialize_engines.py

@@ -89,7 +89,8 @@ class ModuleCategory:
 
 # Assigning external class object by message domain received from client. If the domain is not in the list,
 # the reference general module will be assigned.
-def assign_class_by_domain(engines_list: list, message_domain_name: str, reference_module, logger=None):
+def assign_class_by_domain(
+        engines_list: list, message_domain_name: str, reference_module, config, logger=None):
     # Defining return variables:
     function_parser = None
     function_responder = None
@@ -97,30 +98,33 @@ def assign_class_by_domain(engines_list: list, message_domain_name: str, referen
 
     # In case SNI came empty in the request from client, then there's no point in iterating through engine domains.
     if message_domain_name:
-        # Checking if current domain is in engines' domain list to activate domain specific engine
-        for function_module in engines_list:
-            # The list: matches_list = ["domain1.com", "domain2.com", "domain3.com"]
-            # The string: a_string = "www.domain1.com"
-            # Checking that the message subdomain + domain contains current module's domain name
-            # Template Should be like this: if any(x in a_string for x in matches_list):
-
-            # On the other hand if you want to find if partial string is
-            # in the list of strings: if any(a_string in x for x in matches_list):
-            # In this case list is the same and string: a_string = domain
-            if any(x in message_domain_name for x in function_module.domain_list):
-                # Assigning modules by current engine of the domain
-                function_parser = function_module.parser_class_object
-                function_recorder = function_module.recorder_class_object
-                # Since the responder is being initiated only once, we're assigning only the instance
-                function_responder = function_module.responder_instance
-
-                logger.info(f"Assigned Modules for [{message_domain_name}]: "
-                            f"{function_module.parser_class_object.__name__}, "
-                            f"{function_module.responder_class_object.__name__}, "
-                            f"{function_module.recorder_class_object.__name__}")
-
-                # If the domain was found in the current list of class domains, we can stop the loop
-                break
+        # If the engines_usage is set to True in the config file, then we'll iterate through the list of engines
+        # to find the domain in the list of domains of the engine.
+        if config['tcp']['engines_usage']:
+            # Checking if current domain is in engines' domain list to activate domain specific engine
+            for function_module in engines_list:
+                # The list: matches_list = ["domain1.com", "domain2.com", "domain3.com"]
+                # The string: a_string = "www.domain1.com"
+                # Checking that the message subdomain + domain contains current module's domain name
+                # Template Should be like this: if any(x in a_string for x in matches_list):
+
+                # On the other hand if you want to find if partial string is
+                # in the list of strings: if any(a_string in x for x in matches_list):
+                # In this case list is the same and string: a_string = domain
+                if any(x in message_domain_name for x in function_module.domain_list):
+                    # Assigning modules by current engine of the domain
+                    function_parser = function_module.parser_class_object
+                    function_recorder = function_module.recorder_class_object
+                    # Since the responder is being initiated only once, we're assigning only the instance
+                    function_responder = function_module.responder_instance
+
+                    logger.info(f"Assigned Modules for [{message_domain_name}]: "
+                                f"{function_module.parser_class_object.__name__}, "
+                                f"{function_module.responder_class_object.__name__}, "
+                                f"{function_module.recorder_class_object.__name__}")
+
+                    # If the domain was found in the current list of class domains, we can stop the loop
+                    break
 
     # If none of the domains were found in the engine domains list, then we'll assign reference module.
     # It's enough to check only parser, since responder and recorder also will be empty.

atomicshop/mitm/initialize_mitm_server.py

@@ -1,8 +1,9 @@
 import os
 import threading
 
+# Importing atomicshop package to get the version of the package.
 import atomicshop
-from atomicshop.print_api import print_api
+
 from .import_config import ImportConfig
 from .initialize_engines import ModuleCategory
 from .connection_thread_worker import thread_worker_main
@@ -12,6 +13,7 @@ from ..wrappers.socketw.socket_wrapper import SocketWrapper
 from ..wrappers.socketw.dns_server import DnsServer
 from ..basics import dicts_nested
 from ..wrappers.loggingw import loggingw
+from ..print_api import print_api
 
 
 def initialize_mitm_server(config_static):
@@ -129,20 +131,57 @@ def initialize_mitm_server(config_static):
                                        logger=system_logger, stdout=False, reference_general=True)
     # === EOF Initialize Reference Module ==========================================================================
     # === Engine logging ===========================================================================================
-    # If engines were found.
-    if engines_list:
-        # Printing the parsers using "start=1" for index to start counting from "1" and not "0"
-        system_logger.info("[*] Found Engines:")
-        for index, engine in enumerate(engines_list, start=1):
-            system_logger.info(f"[*] {index}: {engine.engine_name} | {engine.domain_list}")
-            system_logger.info(f"[*] Modules: {engine.parser_class_object.__name__}, "
-                               f"{engine.responder_class_object.__name__}, "
-                               f"{engine.recorder_class_object.__name__}")
-    # If engines weren't found.
+    # Printing the parsers using "start=1" for index to start counting from "1" and not "0"
+    print_api(f"[*] Found Engines:", logger=system_logger)
+    for index, engine in enumerate(engines_list, start=1):
+        message = f"[*] {index}: {engine.engine_name} | {engine.domain_list}"
+        print_api(message, logger=system_logger)
+
+        message = (f"[*] Modules: {engine.parser_class_object.__name__}, "
+                   f"{engine.responder_class_object.__name__}, "
+                   f"{engine.recorder_class_object.__name__}")
+        print_api(message, logger=system_logger)
+
+    if config['dns']['enable_dns_server']:
+        print_api("DNS Server is enabled.", logger=system_logger)
+
+        # If engines were found and dns is set to route by the engine domains.
+        if engines_list and config['dns']['route_to_tcp_server_only_engine_domains']:
+            print_api("Engine domains will be routed by the DNS server to Built-in TCP Server.", logger=system_logger)
+        # If engines were found, but the dns isn't set to route to engines.
+        elif engines_list and not config['dns']['route_to_tcp_server_only_engine_domains']:
+            message = f"[*] Engine domains found, but the DNS routing is set not to use them for routing."
+            print_api(message, color="yellow", logger=system_logger)
+        elif not engines_list and config['dns']['route_to_tcp_server_only_engine_domains']:
+            raise ValueError("No engines were found, but the DNS routing is set to use them for routing.\n"
+                             "Please check your DNS configuration in the 'config.ini' file.")
+
+        if config['dns']['route_to_tcp_server_all_domains']:
+            print_api("All domains will be routed by the DNS server to Built-in TCP Server.", logger=system_logger)
+
+        if config['dns']['regular_resolving']:
+            print_api(
+                "Regular DNS resolving is enabled. Built-in TCP server will not be routed to",
+                logger=system_logger, color="yellow")
     else:
-        system_logger.info("[*] NO ENGINES WERE FOUND!")
-        system_logger.info(f"Server will process all the incoming (domains) connections by "
-                           f"[{reference_module.engine_name}] engine.")
+        print_api("DNS Server is disabled.", logger=system_logger, color="yellow")
+
+    if config['tcp']['enable_tcp_server']:
+        print_api("TCP Server is enabled.", logger=system_logger)
+
+        if engines_list and not config['tcp']['engines_usage']:
+            message = \
+                f"Engines found, but the TCP server is set not to use them for processing. General responses only."
+            print_api(message, color="yellow", logger=system_logger)
+        elif engines_list and config['tcp']['engines_usage']:
+            message = f"Engines found, and the TCP server is set to use them for processing."
+            print_api(message, logger=system_logger)
+        elif not engines_list and config['tcp']['engines_usage']:
+            raise ValueError("No engines were found, but the TCP server is set to use them for processing.\n"
+                             "Please check your TCP configuration in the 'config.ini' file.")
+    else:
+        print_api("TCP Server is disabled.", logger=system_logger, color="yellow")
+
     # === EOF Engine Logging =======================================================================================
 
     # Assigning all the engines domains to all time domains, that will be responsible for adding new domains.
@@ -178,20 +217,24 @@ def initialize_mitm_server(config_static):
         dns_server.request_domain_queue = domain_queue
         # Initiate the thread.
         threading.Thread(target=dns_server.start).start()
+
     # === EOF Initialize DNS module ================================================================================
+    # === Initialize TCP Server ====================================================================================
+    if config['tcp']['enable_tcp_server']:
+        socket_wrapper = SocketWrapper(
+            config=dicts_nested.merge(config, config_static.CONFIG_EXTENDED), logger=listener_logger,
+            statistics_logger=statistics_logger)
 
-    socket_wrapper = SocketWrapper(
-        config=dicts_nested.merge(config, config_static.CONFIG_EXTENDED), logger=listener_logger,
-        statistics_logger=statistics_logger)
+        socket_wrapper.create_tcp_listening_socket_list()
 
-    socket_wrapper.create_tcp_listening_socket_list()
+        socket_wrapper.requested_domain_from_dns_server = domain_queue
 
-    socket_wrapper.requested_domain_from_dns_server = domain_queue
+        # General exception handler will catch all the exceptions that occurred in the threads and write it to the log.
+        try:
+            socket_wrapper.loop_for_incoming_sockets(function_reference=thread_worker_main, reference_args=(
+                network_logger, statistics_logger, engines_list, reference_module, config,))
+        except Exception:
+            message = f"Unhandled Exception occurred in 'loop_for_incoming_sockets' function"
+            print_api(message, error_type=True, color="red", logger=network_logger, traceback_string=True, oneline=True)
 
-    # The general exception handler will catch all the exceptions that occurred in the threads and write it to the log.
-    try:
-        socket_wrapper.loop_for_incoming_sockets(function_reference=thread_worker_main, reference_args=(
-            network_logger, statistics_logger, engines_list, reference_module, config,))
-    except Exception:
-        message = f"Unhandled Exception occurred in 'loop_for_incoming_sockets' function"
-        print_api(message, error_type=True, color="red", logger=network_logger, traceback_string=True, oneline=True)
+    # === EOF Initialize TCP Server ================================================================================

atomicshop/process.py

@@ -1,5 +1,4 @@
 import os
-import sys
 import functools
 from typing import Union
 import shlex

atomicshop/wrappers/elasticsearchw/config_basic.py

@@ -1,3 +1,17 @@
-DEFAULT_PORT: str = '9200'
-DEFAULT_HOST: str = 'localhost'
-DEFAULT_URL: str = f"http://{DEFAULT_HOST}:{DEFAULT_PORT}"
+DEFAULT_ELASTIC_PORT: str = '9200'
+DEFAULT_ELASTIC_HOST: str = 'localhost'
+DEFAULT_ELASTIC_URL: str = f"http://{DEFAULT_ELASTIC_HOST}:{DEFAULT_ELASTIC_PORT}"
+
+DEFAULT_KIBANA_PORT: str = '5601'
+DEFAULT_KIBANA_HOST: str = 'localhost'
+DEFAULT_KIBANA_URL: str = f"http://{DEFAULT_KIBANA_HOST}:{DEFAULT_KIBANA_PORT}"
+
+ELASTIC_CONFIG_FILE: str = "/etc/elasticsearch/elasticsearch.yml"
+ELASTIC_JVM_OPTIONS_FILE: str = "/etc/elasticsearch/jvm.options"
+XPACK_SECURITY_SETTING_NAME: str = "xpack.security.enabled"
+
+UBUNTU_DEPENDENCY_PACKAGES: list[str] = ['apt-transport-https', 'openjdk-11-jdk', 'wget']
+UBUNTU_ELASTIC_PACKAGE_NAME: str = 'elasticsearch'
+UBUNTU_ELASTIC_SERVICE_NAME: str = 'elasticsearch'
+UBUNTU_KIBANA_PACKAGE_NAME: str = 'kibana'
+UBUNTU_KIBANA_SERVICE_NAME: str = 'kibana'

atomicshop/wrappers/elasticsearchw/elasticsearchw.py

@@ -25,7 +25,7 @@ def get_elastic_wrapper(url: str = None, overwrite: bool = False):
 
     # If no url is provided, use the default url.
     if url is None:
-        url = config_basic.DEFAULT_URL
+        url = config_basic.DEFAULT_ELASTIC_URL
 
     # Get the global variable.
     global ELASTIC_WRAPPER

atomicshop/wrappers/elasticsearchw/infrastructure.py

@@ -0,0 +1,213 @@
+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)
+
+
+def start_elastic_service():
+    ubuntu_terminal.start_service(config_basic.UBUNTU_ELASTIC_SERVICE_NAME)
+
+
+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)
+
+
+def start_kibana_service():
+    ubuntu_terminal.start_service(config_basic.UBUNTU_KIBANA_SERVICE_NAME)
+
+
+def start_elastic_and_check_service_availability(wait_time_seconds: float = 30, exit_on_error: bool = True):
+    """
+    Function starts the Elasticsearch service and checks its availability.
+    :param wait_time_seconds: float, the time to wait after starting the service before checking
+        the service availability.
+    :param exit_on_error: bool, if True, the function will exit the program if the service is not available.
+    :return:
+    """
+
+    # Start, enable and check the Elasticsearch service.
+    ubuntu_terminal.start_enable_service_check_availability(
+        service_name=config_basic.UBUNTU_ELASTIC_SERVICE_NAME,
+        wait_time_seconds=wait_time_seconds,
+        exit_on_error=exit_on_error
+    )
+
+    # Check if Elasticsearch is running.
+    if not is_server_available():
+        if exit_on_error:
+            sys.exit(1)
+
+
+def start_kibana_and_check_service_availability(wait_time_seconds: float = 30, exit_on_error: bool = True):
+    """
+    Function starts the Kibana service and checks its availability.
+    :param wait_time_seconds: float, the time to wait after starting the service before checking
+        the service availability.
+    :param exit_on_error: bool, if True, the function will exit the program if the service is not available.
+    :return:
+    """
+
+    # Start, enable and check the Elasticsearch service.
+    ubuntu_terminal.start_enable_service_check_availability(
+        service_name=config_basic.UBUNTU_KIBANA_SERVICE_NAME,
+        wait_time_seconds=wait_time_seconds,
+        exit_on_error=exit_on_error
+    )
+
+
+def is_elastic_config_file_exists(
+        config_file_path: str = None,
+        exit_on_error: bool = False,
+        output_message: bool = False
+) -> bool:
+    """
+    The function checks if the Elasticsearch configuration file exists.
+
+    :param config_file_path: str, the path to the configuration file.
+    :param exit_on_error: bool, if True, the function will exit the program if the file does not exist.
+    :param output_message: bool, if True, the function will print a message if the file does not exist.
+    :return:
+    """
+
+    if not config_file_path:
+        config_file_path = config_basic.ELASTIC_CONFIG_FILE
+
+    if not filesystem.check_file_existence(config_file_path):
+        if output_message:
+            message = f"Configuration file does not exist at {config_file_path}."
+            print_api(message, color='red', error_type=True)
+        if exit_on_error:
+            sys.exit(1)
+        return False
+    else:
+        return True
+
+
+def check_xpack_security_setting(config_file_path: str = None):
+    """
+    The function checks if the 'xpack.security.enabled' setting is set to 'false' in the Elasticsearch
+    configuration file.
+
+    :param config_file_path:
+    :return:
+    """
+
+    if not config_file_path:
+        config_file_path = config_basic.ELASTIC_CONFIG_FILE
+
+    with open(config_file_path, 'r') as file:
+        # Read the file contents
+        contents = file.read()
+        # Check if the specific setting exists
+        if f"{config_basic.XPACK_SECURITY_SETTING_NAME}: false" in contents:
+            return False
+        elif f"{config_basic.XPACK_SECURITY_SETTING_NAME}: true" in contents:
+            return True
+        # If the setting doesn't exist, return None.
+        else:
+            return None
+
+
+def modify_xpack_security_setting(
+        config_file_path: str = None,
+        setting: bool = False,
+        output_message: bool = True
+):
+    """
+    The function modifies the 'xpack.security.enabled' setting in the Elasticsearch configuration file.
+    :param config_file_path: str, the path to the configuration file.
+    :param setting: bool, the setting to change to. Will be added, if doesn't exist.
+    :param output_message: bool, if True, the function will print a message.
+    :return:
+    """
+
+    if not config_file_path:
+        config_file_path = config_basic.ELASTIC_CONFIG_FILE
+
+    # The setting to set in the configuration file.
+    xpack_setting_to_set: str = f'{config_basic.XPACK_SECURITY_SETTING_NAME}: {str(setting).lower()}'
+
+    # Check if the setting exists in the configuration file and get its value.
+    current_xpack_security_setting = check_xpack_security_setting(config_file_path)
+
+    # If the setting doesn't exist, add it to the configuration file.
+    if current_xpack_security_setting is None:
+        with open(config_file_path, 'a') as file:
+            file.write(f'{xpack_setting_to_set}\n')
+        if output_message:
+            print_api(f"Added [{xpack_setting_to_set}] to the configuration.")
+    # If the setting exists and is different from the desired setting, change it.
+    elif current_xpack_security_setting != setting:
+        with open(config_file_path, 'r') as file:
+            lines = file.readlines()
+        with open(config_file_path, 'w') as file:
+            for line in lines:
+                if f"{config_basic.XPACK_SECURITY_SETTING_NAME}:" in line:
+                    file.write(f'{xpack_setting_to_set}\n')
+                else:
+                    file.write(line)
+        if output_message:
+            print_api(f"Changed [{config_basic.XPACK_SECURITY_SETTING_NAME}] to [{setting}].")
+    # If the setting is already set to the desired value, print a message.
+    elif current_xpack_security_setting == setting:
+        if output_message:
+            print_api(f"The setting is already set to [{setting}].")
+
+
+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/install_elastic.py

@@ -0,0 +1,225 @@
+import sys
+
+from ...print_api import print_api
+from ... import process
+from .. import ubuntu_terminal
+from . import config_basic, infrastructure
+
+
+def install_elastic_kibana_ubuntu(install_elastic: bool = True, install_kibana: bool = True):
+    """
+    The function will install docker on ubuntu.
+
+    :param install_elastic: bool, if True, install Elasticsearch.
+    :param install_kibana: bool, if True, install Kibana.
+
+    Usage in main.py (run with sudo):
+        from atomicshop.wrappers.elasticw import install_elastic
+
+
+        def main():
+            install_elastic.install_elastic_ubuntu()
+
+
+        if __name__ == '__main__':
+            main()
+    """
+
+    # This is pure bash script.
+    """
+    #!/bin/bash
+
+    # Color text in red.
+    echo_red() {
+        local color="\e[31m"  # Red color
+        local reset="\e[0m"   # Reset formatting
+        echo -e "${color}$1${reset}"
+    }
+    
+    # Function to check if a service is running
+    check_service_running() {
+        local service_name=$1
+        local status=$(systemctl is-active "$service_name")
+    
+        if [ "$status" == "active" ]; then
+            echo "$service_name service is active and running."
+            return 0
+        else
+            echo_red "$service_name service is not running or has failed. Status: $service_status, Failed: $service_failed"
+            return 1
+        fi
+    }
+    
+    # Update and upgrade system packages
+    sudo apt-get update && sudo apt-get upgrade -y
+    
+    # Install necessary dependencies
+    sudo apt-get install apt-transport-https openjdk-11-jdk wget -y
+    
+    # Download and install the GPG signing key
+    wget -qO - https://artifacts.elastic.co/GPG-KEY-elasticsearch | gpg --dearmor | sudo tee /usr/share/keyrings/elasticsearch-keyring.gpg > /dev/null
+    
+    # Add the Elastic repository to the system
+    echo "deb [signed-by=/usr/share/keyrings/elasticsearch-keyring.gpg] https://artifacts.elastic.co/packages/8.x/apt stable main" | sudo tee /etc/apt/sources.list.d/elastic-8.x.list
+    
+    # Update package index
+    sudo apt-get update
+    
+    # Install Elasticsearch
+    sudo apt-get install elasticsearch -y
+    
+    # Path to the Elasticsearch configuration file
+    CONFIG_FILE="/etc/elasticsearch/elasticsearch.yml"
+    
+    # Check if the configuration file exists
+    if [ ! -f "$CONFIG_FILE" ]; then
+        echo "Configuration file does not exist at $CONFIG_FILE."
+        exit 1
+    fi
+    
+    # Function to check the setting in the configuration file
+    check_setting() {
+        if grep -q "^xpack.security.enabled: false" "$CONFIG_FILE"; then
+            echo "The setting is confirmed to be 'xpack.security.enabled: false'."
+        else
+            echo "Failed to set 'xpack.security.enabled: false'."
+            exit 1
+        fi
+    }
+    
+    # Check if 'xpack.security.enabled' is set to 'false'
+    if grep -q "^xpack.security.enabled: false" "$CONFIG_FILE"; then
+        echo "The setting is already set to false."
+    elif grep -q "^xpack.security.enabled: true" "$CONFIG_FILE"; then
+        # If the setting is true, change it to false
+        sudo sed -i 's/^xpack.security.enabled: true/xpack.security.enabled: false/' "$CONFIG_FILE"
+        echo "Changed xpack.security.enabled to false."
+        check_setting
+    else
+        # If the setting doesn't exist, add it
+        echo "xpack.security.enabled: false" | sudo tee -a "$CONFIG_FILE" > /dev/null
+        echo "Added xpack.security.enabled: false to the configuration."
+        check_setting
+    fi
+    
+    # Start and enable Elasticsearch service
+    sudo systemctl start elasticsearch
+    sudo systemctl enable elasticsearch
+    
+    echo "Waiting 30 seconds for program to start before availability check..."
+    sleep 30
+    
+    # Check if Elasticsearch service is running
+    if ! check_service_running "elasticsearch"; then
+        echo "Elasticsearch service failed to start. Exiting."
+        exit 1
+    fi
+    
+    # Function to check if Elasticsearch is up and running
+    check_elasticsearch() {
+        max_attempts=5
+        wait_seconds=10
+    
+        for ((i=1; i<=max_attempts; i++)); do
+            echo "Checking if Elasticsearch is running (Attempt $i/$max_attempts)..."
+    
+            # Using curl to get the HTTP status code
+            status=$(curl --write-out %{http_code} --silent --output /dev/null http://localhost:9200)
+    
+            if [ "$status" -eq 200 ]; then
+                echo "Elasticsearch is up and running."
+                return 0
+            else
+                echo "Elasticsearch is not running. Status code: $status"
+            fi
+    
+            echo "Waiting for Elasticsearch to start..."
+            sleep $wait_seconds
+        done
+    
+        echo "Elasticsearch did not start within the expected time."
+        return 1
+    }
+    
+    # Check if Elasticsearch is running
+    if ! check_elasticsearch; then
+        echo "Elasticsearch failed to start. Exiting."
+        exit 1
+    fi
+    
+    # Install Kibana
+    sudo apt-get install kibana -y
+    
+    # Start and enable Kibana service
+    sudo systemctl start kibana
+    sudo systemctl enable kibana
+    
+    echo "Waiting 30 seconds for program to start before availability check..."
+    sleep 30
+    
+    # Check if Kibana service is running
+    if ! check_service_running "kibana"; then
+        echo "Kibana service failed to start. Exiting."
+        exit 1
+    fi
+    
+    # Print status
+    echo "Elasticsearch and Kibana installation completed."
+    echo "Elasticsearch is running on http://localhost:9200"
+    echo "Kibana is running on http://localhost:5601"
+    """
+
+    if not install_elastic and not install_kibana:
+        raise ValueError("At least one of the services (Elasticsearch or Kibana) must be installed.")
+
+    # Update and upgrade system packages.
+    ubuntu_terminal.upgrade_system_packages()
+    ubuntu_terminal.update_system_packages()
+
+    # Install necessary dependencies.
+    ubuntu_terminal.install_packages(config_basic.UBUNTU_DEPENDENCY_PACKAGES)
+
+    # Install the GPG key and add elastic repository.
+    script = f"""
+    # Download and install the GPG signing key
+    wget -qO - https://artifacts.elastic.co/GPG-KEY-elasticsearch | gpg --dearmor | sudo tee /usr/share/keyrings/elasticsearch-keyring.gpg > /dev/null
+    
+    # Add the Elastic repository to the system
+    echo "deb [signed-by=/usr/share/keyrings/elasticsearch-keyring.gpg] https://artifacts.elastic.co/packages/8.x/apt stable main" | sudo tee /etc/apt/sources.list.d/elastic-8.x.list
+    """
+    process.execute_script(script, shell=True)
+
+    # Update system with elastic search packages.
+    ubuntu_terminal.update_system_packages()
+
+    if install_elastic:
+        # Install Elasticsearch.
+        ubuntu_terminal.install_packages([config_basic.UBUNTU_ELASTIC_PACKAGE_NAME])
+
+        # Check if the configuration file exists.
+        infrastructure.is_elastic_config_file_exists(exit_on_error=True, output_message=True)
+
+        # Check if the specific setting exists or not and set it to false.
+        infrastructure.modify_xpack_security_setting(setting=False, output_message=True)
+
+        # Check if the setting was really set to false.
+        if infrastructure.check_xpack_security_setting() is False:
+            print_api(f"The setting is confirmed to be [{config_basic.XPACK_SECURITY_SETTING_NAME}: false].")
+        else:
+            print_api(f"Failed to set [{config_basic.XPACK_SECURITY_SETTING_NAME}: false].")
+            sys.exit(1)
+
+        infrastructure.start_elastic_and_check_service_availability()
+
+    if install_kibana:
+        # Install Kibana.
+        ubuntu_terminal.install_packages([config_basic.UBUNTU_KIBANA_PACKAGE_NAME])
+
+        # Start and enable Kibana service.
+        infrastructure.start_kibana_and_check_service_availability()
+
+    print_api("Installation completed.", color='green')
+    if install_elastic:
+        print_api(f"Default Elasticsearch on {config_basic.DEFAULT_ELASTIC_URL}")
+    if install_kibana:
+        print_api(f"Default Kibana on {config_basic.DEFAULT_KIBANA_URL}")

atomicshop/wrappers/factw/install/install_after_restart.py

@@ -1,7 +1,7 @@
 from typing import Union, Literal
 from pathlib import Path
 
-from .... import permissions, process, filesystem
+from .... import process, filesystem
 from .. import config_install
 
 

atomicshop/wrappers/ffmpegw.py

@@ -4,7 +4,7 @@ import shlex
 
 from ..print_api import print_api
 from ..tempfiles import TempFile
-from ..github_wrapper import GitHubWrapper
+from .githubw import GitHubWrapper
 from ..process import execute_with_live_output
 from ..filesystem import create_directory
 

atomicshop/wrappers/playwrightw/base.py

@@ -1,5 +1,3 @@
-import time
-
 from . import combos, javascript
 from ...file_io import file_io
 

atomicshop/wrappers/socketw/dns_server.py

@@ -91,9 +91,19 @@ class DnsServer:
 
         # Check if 'route_to_tcp_server_only_engine_domains' was set to 'True' and output message accordingly.
         if self.config['dns']['route_to_tcp_server_only_engine_domains']:
-            self.logger.info(f"Current engine domains: {self.domain_list}")
-        else:
-            self.logger.info("Not using engine domains. All 'A' records will be forwarded to TCP Server.")
+            message = "Routing only engine domains to Built-in TCP Server."
+            print_api(message, logger=self.logger)
+
+            message = f"Current engine domains: {self.domain_list}"
+            print_api(message, logger=self.logger, color='green')
+
+        if self.config['dns']['route_to_tcp_server_all_domains']:
+            message = "Routing all domains to Built-in TCP Server."
+            print_api(message, logger=self.logger, color='green')
+
+        if self.config['dns']['regular_resolving']:
+            message = f"Routing all domains to Live DNS Service: {self.config['dns']['forwarding_dns_service_ipv4']}"
+            print_api(message, logger=self.logger, color='green')
 
         # The list that will hold all the threads that can be joined later
         threads_list: list = list()
@@ -201,22 +211,28 @@ class DnsServer:
                     else:
                         # Check if the incoming Record is "A" record.
                         if qtype_string == "A":
-                            # If so, check if 'route_to_tcp_server_only_engine_domains' is set to 'True' in 'config.ini'.
+                            # Check if 'route_to_tcp_server_only_engine_domains' is set to 'True' in 'config.ini'.
                             # If so, we need to check if the incoming domain contain any of the 'engine_domains'.
                             if self.config['dns']['route_to_tcp_server_only_engine_domains']:
                                 # If current query domain (+ subdomains) CONTAIN any of the domains from modules config
                                 # files and current request contains "A" (IPv4) record.
                                 if any(x in question_domain for x in self.domain_list):
-                                    # If incoming domain contains any of the 'engine_domains' then domain will be forwarded
-                                    # to our TCP Server.
+                                    # If incoming domain contains any of the 'engine_domains' then domain will
+                                    # be forwarded to our TCP Server.
                                     forward_to_tcp_server = True
                                 else:
                                     forward_to_tcp_server = False
-                            # If 'route_to_tcp_server_only_engine_domains' was set to 'False' in 'config.ini' file then the
-                            # domains in engine config files doesn't matter, and we'll forward all 'A' records domains to
-                            # our TCP Server.
-                            else:
+
+                            # If 'route_to_tcp_server_all_domains' was set to 'False' in 'config.ini' file then
+                            # we'll forward all 'A' records domains to the Built-in TCP Server.
+                            if self.config['dns']['route_to_tcp_server_all_domains']:
                                 forward_to_tcp_server = True
+
+                            # If 'regular_resolving' was set to 'True' in 'config.ini' file then
+                            # we'll forward all 'A' records domains to the Live DNS Service.
+                            if self.config['dns']['regular_resolving']:
+                                forward_to_tcp_server = False
+
                         # If incoming record is not an "A" record, then it will not be forwarded to our TCP Server.
                         else:
                             forward_to_tcp_server = False

atomicshop/wrappers/ubuntu_terminal.py

@@ -1,14 +1,22 @@
+import sys
 import subprocess
 import shutil
+import time
 
+from ..print_api import print_api
 
-def install_package(package: str):
+
+def install_packages(package_list: list[str]):
     """
     Function installs a package using apt-get.
-    :param package: str, package name.
+    :param package_list: list of strings, package names to install.
     :return:
     """
-    subprocess.check_call(['sudo', 'apt-get', 'install', '-y', package])
+
+    # Construct the command with the package list
+    command = ["sudo", "apt-get", "install", "-y"] + package_list
+
+    subprocess.check_call(command)
 
 
 def is_package_installed(package: str) -> bool:
@@ -22,3 +30,102 @@ def is_package_installed(package: str) -> bool:
         return False
     else:
         return True
+
+
+def update_system_packages():
+    """
+    Function updates the system packages.
+    :return:
+    """
+    subprocess.check_call(['sudo', 'apt-get', 'update'])
+
+
+def upgrade_system_packages():
+    """
+    Function upgrades the system packages.
+    :return:
+    """
+    subprocess.check_call(['sudo', 'apt-get', 'upgrade', '-y'])
+
+
+def is_service_running(service_name: str, return_false_on_error: bool = False) -> bool:
+    try:
+        # Use subprocess to run 'systemctl is-active' and capture its output
+        status = subprocess.check_output(['systemctl', 'is-active', service_name], text=True).strip()
+    except subprocess.CalledProcessError as e:
+        if return_false_on_error:
+            # Handle error if systemctl command fails
+            return False
+        else:
+            # Raise the exception if return_false_on_error is False
+            raise e
+
+    if status == "active":
+        return True
+    else:
+        return False
+
+
+def enable_service(service_name: str):
+    """
+    Function enables a service.
+    :param service_name: str, the service name.
+    :return:
+    """
+    subprocess.check_call(['sudo', 'systemctl', 'enable', service_name])
+
+
+def start_service(service_name: str):
+    """
+    Function starts a service.
+    :param service_name: str, the service name.
+    :return:
+    """
+    subprocess.check_call(['sudo', 'systemctl', 'start', service_name])
+
+
+def start_enable_service_check_availability(
+        service_name: str,
+        wait_time_seconds: float = 30,
+        exit_on_error: bool = True,
+        start_service_bool: bool = True,
+        enable_service_bool: bool = True,
+        check_service_running: bool = True,
+        print_kwargs: dict = None
+):
+    """
+    Function starts and enables a service and checks its availability.
+
+    :param service_name: str, the service name.
+    :param wait_time_seconds: float, the time to wait after starting the service before checking the service
+        availability.
+    :param exit_on_error: bool, if True, the function will exit the program if the service is not available.
+    :param start_service_bool: bool, if True, the service will be started.
+    :param enable_service_bool: bool, if True, the service will be enabled.
+    :param check_service_running: bool, if True, the function will check if the service is running.
+    :param print_kwargs: dict, the print arguments.
+    :return:
+    """
+
+    if not start_service_bool and not enable_service_bool:
+        raise ValueError("Either 'start_service_bool' or 'enable_service_bool' must be True.")
+
+    # Start and enable the service.
+    if start_service_bool:
+        start_service(service_name)
+    if enable_service_bool:
+        enable_service(service_name)
+
+    if check_service_running:
+        print_api(
+            f"Waiting {str(wait_time_seconds)} seconds for the program to start before availability check...",
+            **(print_kwargs or {}))
+        time.sleep(wait_time_seconds)
+
+        if not is_service_running(service_name):
+            print_api(
+                f"[{service_name}] service failed to start.", color='red', error_type=True, **(print_kwargs or {}))
+            if exit_on_error:
+                sys.exit(1)
+        else:
+            print_api(f"[{service_name}] service is running.", color='green', **(print_kwargs or {}))

{atomicshop-2.9.13.dist-info → atomicshop-2.9.15.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: atomicshop
-Version: 2.9.13
+Version: 2.9.15
 Summary: Atomic functions and classes to make developer life easier
 Author: Denis Kras
 License: MIT License

{atomicshop-2.9.13.dist-info → atomicshop-2.9.15.dist-info}/RECORD

@@ -1,4 +1,4 @@
-atomicshop/__init__.py,sha256=1mDlW2D2mjBVL1hBbLyWpj9YZ0vnfn0nL8Ik-itVx5k,123
+atomicshop/__init__.py,sha256=YjtN4-RYTZwCTFS1O3pUEqPdO7RNYB0bgcXRvqPDH1Y,123
 atomicshop/_basics_temp.py,sha256=6cu2dd6r2dLrd1BRNcVDKTHlsHs_26Gpw8QS6v32lQ0,3699
 atomicshop/_create_pdf_demo.py,sha256=Yi-PGZuMg0RKvQmLqVeLIZYadqEZwUm-4A9JxBl_vYA,3713
 atomicshop/_patch_import.py,sha256=ENp55sKVJ0e6-4lBvZnpz9PQCt3Otbur7F6aXDlyje4,6334
@@ -14,7 +14,7 @@ atomicshop/dns.py,sha256=bNZOo5jVPzq7OT2qCPukXoK3zb1oOsyaelUwQEyK1SA,2500
 atomicshop/domains.py,sha256=Rxu6JhhMqFZRcoFs69IoEd1PtYca0lMCG6F1AomP7z4,3197
 atomicshop/emails.py,sha256=I0KyODQpIMEsNRi9YWSOL8EUPBiWyon3HRdIuSj3AEU,1410
 atomicshop/file_types.py,sha256=-0jzQMRlmU1AP9DARjk-HJm1tVE22E6ngP2mRblyEjY,763
-atomicshop/filesystem.py,sha256=SMIa9H4E3CgpZ4Z8HmYx_7SMiwgsJHTogfZ9vE_cTPo,42808
+atomicshop/filesystem.py,sha256=kMsAMp6ij1j1Qdd-T1H8A-5PYD6zH4cTLMwBnQoHgJ8,42791
 atomicshop/functions.py,sha256=pK8hoCE9z61PtWCxQJsda7YAphrLH1wxU5x-1QJP-sY,499
 atomicshop/hashing.py,sha256=Le8qGFyt3_wX-zGTeQShz7L2HL_b6nVv9PnawjglyHo,3474
 atomicshop/http_parse.py,sha256=nrf2rZcprLqtW8HVrV7TCZ1iTBcWRRy-mXIlAOzcaJs,9703
@@ -24,7 +24,7 @@ atomicshop/keyboard_press.py,sha256=1W5kRtOB75fulVx-uF2yarBhW0_IzdI1k73AnvXstk0,
 atomicshop/pbtkmultifile_argparse.py,sha256=aEk8nhvoQVu-xyfZosK3ma17CwIgOjzO1erXXdjwtS4,4574
 atomicshop/permissions.py,sha256=GYWxm9niuJWY0pWCnASF34_HiTuvhTamn8BCgcFyVAk,2540
 atomicshop/print_api.py,sha256=DhbCQd0MWZZ5GYEk4oTu1opRFC-b31g1VWZgTGewG2Y,11568
-atomicshop/process.py,sha256=5lqepm1psRbz66J4MB43ou6HHyac9F34QJedGukwAnk,14188
+atomicshop/process.py,sha256=SXaqG8pzNkHvppPhuhixEIXSaqbeDlTUFLaS5bYSp54,14176
 atomicshop/process_name_cmd.py,sha256=TNAK6kQZm5JKWzEW6QLqVHEG98ZLNDQiSS4YwDk8V8c,3830
 atomicshop/process_poller.py,sha256=WfmwCLALfTYOq8ri0vkPeqq8ruEyA_43DaN--CU2_XY,10854
 atomicshop/python_file_patcher.py,sha256=kd3rBWvTcosLEk-7TycNdfKW9fZbe161iVwmH4niUo0,5515
@@ -64,6 +64,7 @@ atomicshop/addons/process_list/process_list.cpp,sha256=e7olpLfLVg9vQnjEr5L2Y8aWG
 atomicshop/addons/process_list/compiled/Win10x64/process_list.dll,sha256=SkAZvYAfSbzQTTq-5aL6_dYR2rA4DHbgyenFfgLFzW0,266752
 atomicshop/addons/process_list/compiled/Win10x64/process_list.exp,sha256=VTph513eqa6f6HmqAj_6mBS1Rf9G56bgYqZNuDePYcs,708
 atomicshop/addons/process_list/compiled/Win10x64/process_list.lib,sha256=n9c2MVPs3GBNoOQjMesAwzNpv5aFZsW8c-ADS7GYRhA,1886
+atomicshop/archiver/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 atomicshop/archiver/_search_in_zip.py,sha256=dd8qFSvIhcKmtnPj_uYNJFPmMwZp4tZys0kKgTw_ACw,8385
 atomicshop/archiver/archiver.py,sha256=BomnK7zT-nQXA1z0i2R2aTv8eu88wPx7tf2HtOdbmEc,1280
 atomicshop/archiver/search_in_archive.py,sha256=mEngDfULXBd3Oio8a2SUtynfJASVLsH74XIYJOWVkH0,10467
@@ -72,7 +73,7 @@ atomicshop/archiver/zip.py,sha256=k742K1bEDtc_4N44j_Waebi-uOkxxavqltvV6q-BLW4,14
 atomicshop/basics/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 atomicshop/basics/ansi_escape_codes.py,sha256=WtIkm-BjSZS5J5irDUdAMBNvdX-qXFZcTX98jcBMpJE,3140
 atomicshop/basics/argparse_template.py,sha256=horwgSf3MX1ZgRnYxtmmQuz9OU_vKrKggF65gmjlmfg,5836
-atomicshop/basics/booleans.py,sha256=416QbQeYWFb5RMsMAHSH1Nj6IMaQwBO_uZH1JT87Krc,2020
+atomicshop/basics/booleans.py,sha256=va3LYIaSOhjdifW4ZEesnIQxBICNHyQjUAkYelzchhE,2047
 atomicshop/basics/bytes_arrays.py,sha256=WvSRDhIGt1ywF95t-yNgpxLm1nlZUbM1Dz6QckcyE8Y,5915
 atomicshop/basics/classes.py,sha256=EijW_g4EhdNBnKPMG3nT3HjFspTchtM7to6zm9Ad_Mk,9771
 atomicshop/basics/dicts.py,sha256=N696f-vamrCcLpLOvtRpHrEmLfyOqkCyW8JDZnwYLpg,11295
@@ -105,15 +106,15 @@ atomicshop/file_io/tomls.py,sha256=oa0Wm8yMkPRXKN9jgBuTnKbioSOee4mABW5IMUFCYyU,3
 atomicshop/file_io/xlsxs.py,sha256=v_dyg9GD4LqgWi6wA1QuWRZ8zG4ZwB6Dz52ytdcmmmI,2184
 atomicshop/file_io/xmls.py,sha256=zh3SuK-dNaFq2NDNhx6ivcf4GYCfGM8M10PcEwDSpxk,2104
 atomicshop/mitm/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-atomicshop/mitm/connection_thread_worker.py,sha256=7f7T3t6ltndzb3125DgyRTzsD-oAbAfewDIhpNEeHRY,20630
-atomicshop/mitm/import_config.py,sha256=BPZ62ozMUaUKn7Crt6dhzvUgD3dSKd17kMfbJNObvlI,7486
-atomicshop/mitm/initialize_engines.py,sha256=b4iNwZEzIF2LlwScET_h_Hj_K8PKPcv8S9P7Jvpb-mw,7727
-atomicshop/mitm/initialize_mitm_server.py,sha256=8Rwq4OzA4VKpzWNhxn8-CkCY_UdPIK64J4UrtD7oE3M,11230
+atomicshop/mitm/connection_thread_worker.py,sha256=PQ8bwOgrPudYP5oPnSi_DWaKXOi038M8TMImlLkxuPI,20486
+atomicshop/mitm/import_config.py,sha256=_V-IVJ7a1L6E-VOR4CDfZj-S1odbsIlBe13ij0NlpqY,7974
+atomicshop/mitm/initialize_engines.py,sha256=UGdT5DKYNri3MNOxESP7oeSxYiUDrVilJ4jic_nwdew,8055
+atomicshop/mitm/initialize_mitm_server.py,sha256=aXNZlRu1_RGjC7lagvs2Q8rjQiygxYucy-U4C_SBnsk,13871
 atomicshop/mitm/message.py,sha256=u2U2f2SOHdBNU-6r1Ik2W14ai2EOwxUV4wVfGZA098k,1732
 atomicshop/mitm/shared_functions.py,sha256=NeHABBlY-tmQRooWGVl2jZQx1wSTKJtEqG7mMvF2Jqo,4268
 atomicshop/mitm/statistic_analyzer.py,sha256=1g5l6X-NbnHvh_TREJRumTDWgE4ixUNJ8pKGneKcf4Y,23524
 atomicshop/mitm/engines/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-atomicshop/mitm/engines/create_module_template.py,sha256=ZQVWR1HUiYF5oLqNEk_qG5qxtHnkRzcxH0Nal04qY_k,4879
+atomicshop/mitm/engines/create_module_template.py,sha256=tRjVSm1sD6FzML71Qbuwvita0qsusdFGm8NZLsZ-XMs,4853
 atomicshop/mitm/engines/create_module_template_example.py,sha256=X5xhvbV6-g9jU_bQVhf_crZmaH50LRWz3bS-faQ18ds,489
 atomicshop/mitm/engines/__parent/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 atomicshop/mitm/engines/__parent/parser___parent.py,sha256=sBvPlFMOCTdS-qgW9uTKvvJCFT5nNW9n3UyhaFcjAfg,1365
@@ -141,12 +142,12 @@ atomicshop/wrappers/_process_wrapper_tar.py,sha256=WUMZFKNrlG4nJP9tWZ51W7BR1j_pI
 atomicshop/wrappers/astw.py,sha256=VkYfkfyc_PJLIOxByT6L7B8uUmKY6-I8XGZl4t_z828,4239
 atomicshop/wrappers/configparserw.py,sha256=JwDTPjZoSrv44YKwIRcjyUnpN-FjgXVfMqMK_tJuSgU,22800
 atomicshop/wrappers/cryptographyw.py,sha256=H5NaHHDkr97QYhUrHFO9vY218u8k3N3Zgh6bQRnicUE,13140
-atomicshop/wrappers/ffmpegw.py,sha256=YKptcdNQC1wyPLRLvc24fIPr4_rj8IHH01UUzt6XFO0,6039
+atomicshop/wrappers/ffmpegw.py,sha256=wcq0ZnAe0yajBOuTKZCCaKI7CDBjkq7FAgdW5IsKcVE,6031
 atomicshop/wrappers/githubw.py,sha256=AjD0VUlV2Kcddns2OaGmyX-FOAvdps-8SPSWS05E0QA,4809
 atomicshop/wrappers/numpyw.py,sha256=sBV4gSKyr23kXTalqAb1oqttzE_2XxBooCui66jbAqc,1025
 atomicshop/wrappers/process_wrapper_pbtk.py,sha256=ycPmBRnv627RWks6N8OhxJQe8Gu3h3Vwj-4HswPOw0k,599
 atomicshop/wrappers/pyopensslw.py,sha256=OBWxA6EJ2vU_Qlf4M8m6ilcG3hyYB4yB0EsXUf7NhEU,6804
-atomicshop/wrappers/ubuntu_terminal.py,sha256=FGY9pqgUrRDtoLeIdSqDQMZdyfPtLBYLiyg-HDq2a_g,532
+atomicshop/wrappers/ubuntu_terminal.py,sha256=1CcTXASzxdFFFJTf3G1OtHcs8abbn_jgkPsY0OzEs1w,4132
 atomicshop/wrappers/wslw.py,sha256=AKphiHLSddL7ErevUowr3f9Y1AgGz_R3KZ3NssW07h8,6959
 atomicshop/wrappers/certauthw/certauth.py,sha256=hKedW0DOWlEigSNm8wu4SqHkCQsGJ1tJfH7s4nr3Bk0,12223
 atomicshop/wrappers/certauthw/certauthw.py,sha256=4WvhjANI7Kzqrr_nKmtA8Kf7B6rute_5wfP65gwQrjw,8082
@@ -155,8 +156,10 @@ atomicshop/wrappers/dockerw/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMp
 atomicshop/wrappers/dockerw/dockerw.py,sha256=w8zSJr5C7cbvbuG09ORCpAe0BOcibqqL_Z2EKEBHYK4,6266
 atomicshop/wrappers/dockerw/install_docker.py,sha256=dpSOmD690oLukoLCo0u6Pzh5fRyCWBuSQEtG8VwC3jk,2765
 atomicshop/wrappers/elasticsearchw/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-atomicshop/wrappers/elasticsearchw/config_basic.py,sha256=nMtWYBlkQwzUMTLBaL3US8-f87bNPS_wzVxpLR1D6Hc,121
-atomicshop/wrappers/elasticsearchw/elasticsearchw.py,sha256=BmBTS6WYYO_XK7ZAzl3uL5P_YzDvjDTkokvvHd3t6Yw,9760
+atomicshop/wrappers/elasticsearchw/config_basic.py,sha256=XJMKKfDrUq9ZKxYnQ-xFJxSA51z31Nn4eB8_n_hryVk,800
+atomicshop/wrappers/elasticsearchw/elasticsearchw.py,sha256=7TqFdEFznO8NlligJhEKk1vm641ALpCYdaRl1uoXdzM,9768
+atomicshop/wrappers/elasticsearchw/infrastructure.py,sha256=J1hKIEQA8ImRUmkM25fbmwHbZPC9VnT9NK1_kOfXitA,8311
+atomicshop/wrappers/elasticsearchw/install_elastic.py,sha256=Lez_Tt21Jlprz7EaRZlppzbpTkYerWkkHd9cfIwcyy8,8308
 atomicshop/wrappers/elasticsearchw/queries/__init__.py,sha256=KBjT-bAt75CJsx1Apko9mpuFU4pfZV8DcGWQvpX65RU,78
 atomicshop/wrappers/elasticsearchw/queries/aggregation.py,sha256=N9a5yMMnb10sMa_x1qJBFQpgyJ49UWo8_vxuqmUtZ1A,1742
 atomicshop/wrappers/elasticsearchw/queries/info.py,sha256=P_VhhBo8MvRI4Shi-bh4RsYtlYNRKRBzScXPC64Up_Q,2900
@@ -173,7 +176,7 @@ atomicshop/wrappers/factw/fact_extractor/__init__.py,sha256=47DEQpj8HBSa-_TImW-5
 atomicshop/wrappers/factw/fact_extractor/docker_image.py,sha256=jJAoJNQ4aoATjn3x_va031Obb4oBtcqCY40hydghm0s,2504
 atomicshop/wrappers/factw/fact_extractor/get_extractor.py,sha256=2mfOAftHIlCcGt1s7MWdq7DsDCuI6wX3MtvcEZ4SK-0,756
 atomicshop/wrappers/factw/install/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-atomicshop/wrappers/factw/install/install_after_restart.py,sha256=Wixuc-foMA0qGjzypbbQ5sdE-F72yIKmrI9c6xwLY-g,1571
+atomicshop/wrappers/factw/install/install_after_restart.py,sha256=roM1W2hkDynpEKda55xd7AsZxodsFj8i4wmFGt_HHzA,1558
 atomicshop/wrappers/factw/install/pre_install_and_install_before_restart.py,sha256=OWlT1h9XJChuKOT3GPa69nnrqxgM4TD9Cy-GR7E23LY,2377
 atomicshop/wrappers/factw/postgresql/__init__.py,sha256=xMBn2d3Exo23IPP2F_9-SXmOlhFbwWDgS9KwozSTjA0,162
 atomicshop/wrappers/factw/postgresql/analysis.py,sha256=2Rxzy2jyq3zEKIo53z8VkjuslKE_i5mq2ZpmJAvyd6U,716
@@ -197,7 +200,7 @@ atomicshop/wrappers/loggingw/loggingw.py,sha256=v9WAseZXB50LluT9rIUcRvvevg2nLVKP
 atomicshop/wrappers/loggingw/reading.py,sha256=xs7L6Jo-vedrhCVP7m-cJo0VhWmoSoK86avR4Tm0kG4,3675
 atomicshop/wrappers/playwrightw/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 atomicshop/wrappers/playwrightw/_tryouts.py,sha256=l1BLkFsiIMNlgv7nfZd1XGEvXQkIQkIcg48__9OaC00,4920
-atomicshop/wrappers/playwrightw/base.py,sha256=zwHfbFZV7qqpmReJg5lEpKtOO23DRxEd61ZdoLBU_9Q,9833
+atomicshop/wrappers/playwrightw/base.py,sha256=WeRpx8otdXuKSr-BjY-uCJTze21kbPpfitoOjKQz5-g,9818
 atomicshop/wrappers/playwrightw/combos.py,sha256=215y7wugyyBrFK9_0WutnMXsF1jqJ2PLm9eHEa2PMz0,7145
 atomicshop/wrappers/playwrightw/engine.py,sha256=Ik9hysgJAtjbzr6ED-9gRBaxnt3cNt5hu1u4ut_M3To,14861
 atomicshop/wrappers/playwrightw/javascript.py,sha256=CL3tVE9C4SVvy76FEgGCl77B-xziCG6JZR5Ed8IfcSo,1112
@@ -216,7 +219,7 @@ atomicshop/wrappers/socketw/accepter.py,sha256=HQC1EyZmyUtVEfFbaBkHCE-VZp6RWyd9m
 atomicshop/wrappers/socketw/base.py,sha256=1vvg8EhRGvnxdrRAm1VJSLCXkm2SZDHRjdpTuhkH3Mg,1844
 atomicshop/wrappers/socketw/certificator.py,sha256=SxCKFyBlwzs4uohugfBokOYQpZJyH8KY46m87Q23n6w,9017
 atomicshop/wrappers/socketw/creator.py,sha256=C-l57G854HAtWJonVbgfQge290-Dg0Ov4aurJAWIKls,11199
-atomicshop/wrappers/socketw/dns_server.py,sha256=ql3R5lSKajoR_xPr9myk08ngb5dzk77henwOmqCtXIo,41225
+atomicshop/wrappers/socketw/dns_server.py,sha256=laMR_opplvytVTvVcztNoDChZGMCDR31fDQejrCNaEI,42032
 atomicshop/wrappers/socketw/exception_wrapper.py,sha256=_YDnzyEcUnV6VISU3bk-UPdnsMvHjKJBHwxLMTsxQu8,8495
 atomicshop/wrappers/socketw/get_process.py,sha256=APw_oOXsuR5KljYesd4J8MuzR-kaw2ez3MN3oD_h9Qc,5226
 atomicshop/wrappers/socketw/receiver.py,sha256=m8hXKOa8dqEQGUdcbYjshH8-j0CsMGRkge2ifYKhaAw,9050
@@ -227,8 +230,8 @@ atomicshop/wrappers/socketw/socket_server_tester.py,sha256=AhpurHJmP2kgzHaUbq5ey
 atomicshop/wrappers/socketw/socket_wrapper.py,sha256=aXBwlEIJhFT0-c4i8iNlFx2It9VpCEpsv--5Oqcpxao,11624
 atomicshop/wrappers/socketw/ssl_base.py,sha256=k4V3gwkbq10MvOH4btU4onLX2GNOsSfUAdcHmL1rpVE,2274
 atomicshop/wrappers/socketw/statistics_csv.py,sha256=t3dtDEfN47CfYVi0CW6Kc2QHTEeZVyYhc57IYYh5nmA,826
-atomicshop-2.9.13.dist-info/LICENSE.txt,sha256=lLU7EYycfYcK2NR_1gfnhnRC8b8ccOTElACYplgZN88,1094
-atomicshop-2.9.13.dist-info/METADATA,sha256=D2qXuN1VKUUI9zVBO2sg6Wzg2LP1WiIfLbh0_-LVXg4,10423
-atomicshop-2.9.13.dist-info/WHEEL,sha256=GJ7t_kWBFywbagK5eo9IoUwLW6oyOeTKmQ-9iHFVNxQ,92
-atomicshop-2.9.13.dist-info/top_level.txt,sha256=EgKJB-7xcrAPeqTRF2laD_Np2gNGYkJkd4OyXqpJphA,11
-atomicshop-2.9.13.dist-info/RECORD,,
+atomicshop-2.9.15.dist-info/LICENSE.txt,sha256=lLU7EYycfYcK2NR_1gfnhnRC8b8ccOTElACYplgZN88,1094
+atomicshop-2.9.15.dist-info/METADATA,sha256=Pvhwhgb3o01SAy7xGphWOTiNIaCfMSxpVvgdSzOX9XE,10423
+atomicshop-2.9.15.dist-info/WHEEL,sha256=GJ7t_kWBFywbagK5eo9IoUwLW6oyOeTKmQ-9iHFVNxQ,92
+atomicshop-2.9.15.dist-info/top_level.txt,sha256=EgKJB-7xcrAPeqTRF2laD_Np2gNGYkJkd4OyXqpJphA,11
+atomicshop-2.9.15.dist-info/RECORD,,