atomicshop 3.3.21__py3-none-any.whl → 3.3.22__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__ = '3.3.21'
+__version__ = '3.3.22'

atomicshop/web.py

@@ -1,13 +1,10 @@
 import os
 import urllib.request
 import ssl
+from typing import Any
 # noinspection PyPackageRequirements
 import certifi
 
-try:
-    from importlib.metadata import version, PackageNotFoundError  # Python 3.8+
-except ImportError:  # Python <3.8
-    from importlib_metadata import version, PackageNotFoundError  # backport
 
 from .archiver import zips
 from .urls import url_parser
@@ -102,7 +99,7 @@ def get_page_content(
         playwright_pdf_format: str = 'A4',
         playwright_html_txt_convert_to_bytes: bool = True,
         print_kwargs: dict = None
-) -> any:
+) -> Any:
     """
     Function returns the page content from the given URL.
 
@@ -187,19 +184,6 @@ def download(
         else:
             print_api.print_api(f'Downloaded bytes: {aggregated_bytes_int}', print_end=print_end, **kwargs)
 
-    def has_pip_system_certs() -> bool:
-        try:
-            version("pip-system-certs")  # distribution/project name on PyPI
-            return True
-        except PackageNotFoundError:
-            return False
-
-    if not has_pip_system_certs():
-        print_api.print_api(
-            'Warning: "pip-system-certs" package is not installed. '
-            'If "certifi" package is installed, the system\'s CA store will not be used for SSL context. '
-            'Install "pip-system-certs" package if you want to use the system\'s CA store.', color='yellow', **kwargs)
-
     # Size of the buffer to read each time from url.
     buffer_size: int = 4096
 
@@ -238,7 +222,7 @@ def download(
     if not is_status_ok(status_code=file_to_download.status, **kwargs):
         return None
 
-    file_size_bytes_int: int = None
+    file_size_bytes_int: int | None = None
     # Get file size. For some reason doesn't show for GitHub branch downloads.
     if file_to_download.headers['Content-Length']:
         file_size_bytes_int = int(file_to_download.headers['Content-Length'])

atomicshop/wrappers/elasticsearchw/config_basic.py

@@ -7,17 +7,5 @@ DEFAULT_KIBANA_PORT: str = '5601'
 DEFAULT_KIBANA_HOST: str = 'localhost'
 DEFAULT_KIBANA_URL: str = f"http://{DEFAULT_KIBANA_HOST}:{DEFAULT_KIBANA_PORT}"
 
-ELASTIC_SEARCH_CONFIG_DIRECTORY: str = "/etc/elasticsearch"
-
-ELASTIC_CONFIG_FILE: str = f"{ELASTIC_SEARCH_CONFIG_DIRECTORY}/elasticsearch.yml"
-XPACK_SECURITY_SETTING_NAME: str = "xpack.security.enabled"
-
-ELASTIC_JVM_OPTIONS_DIRECTORY: str = f"{ELASTIC_SEARCH_CONFIG_DIRECTORY}/jvm.options.d"
-ELASTIC_JVM_OPTIONS_4GB_CUSTOM_FILE: str = f"{ELASTIC_JVM_OPTIONS_DIRECTORY}/4gb_memory_heap.options"
-ELASTIC_JVM_OPTIONS_4GB_MEMORY_USAGE: list[str] = ['-Xms4g', '-Xmx4g']
-
-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/elastic_infra.py

@@ -32,174 +32,6 @@ def start_kibana_service():
     ubuntu_terminal.start_service(config_basic.UBUNTU_KIBANA_SERVICE_NAME, sudo=True)
 
 
-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 ubuntu_terminal.is_sudo_file_exists(config_file_path):
-    if not filesystem.is_file_exists(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 create_jvm_options_custom_file(file_path: str, options: list):
-    """
-    The function creates a custom JVM options file for Elasticsearch.
-    You can use the default directory path as 'config_basic.ELASTIC_JVM_OPTIONS_DIRECTORY'.
-    :param file_path: str, the path to the custom JVM options file.
-    :param options: list, the list of JVM options.
-    :return:
-    """
-
-    # Write the options to the file.
-    with open(file_path, 'w') as file:
-        for option in options:
-            file.write(f"{option}\n")
-
-
-def create_jvm_options_custom_4gb_memory_heap_file(file_path: str = None):
-    """
-    The function creates a custom JVM options file with 4GB memory heap usage.
-    The 4GB memory usage options are needed for the Elasticsearch to work properly and not to crash.
-    :param file_path: str, the path to the custom JVM options file.
-    :return:
-    """
-
-    if not file_path:
-        file_path = config_basic.ELASTIC_JVM_OPTIONS_4GB_CUSTOM_FILE
-
-    create_jvm_options_custom_file(file_path, config_basic.ELASTIC_JVM_OPTIONS_4GB_MEMORY_USAGE)
-
-
 def is_server_available(
         max_attempts: int = 5,
         wait_between_attempts_seconds: float = 10,
@@ -241,25 +73,3 @@ def is_server_available(
 
     print_api("Elasticsearch did not start within the expected time.", color='red', **print_kwargs)
     return False
-
-
-def is_4gb_memory_heap_options_applied_on_server() -> bool:
-    """
-    The function checks if the 4GB memory heap options are applied on the Elasticsearch server.
-    :return: bool.
-    """
-
-    # Send a GET request
-    response = requests.get(config_basic.DEFAULT_ELASTIC_URL_JVM_OPTIONS)
-    response.raise_for_status()  # Raise an exception for HTTP errors
-
-    # Load JSON data from the response
-    jvm_data = response.json()
-
-    # Check if memory heap options are applied in 'input_arguments' key.
-    for node in jvm_data['nodes'].values():
-        # Get the JVM input arguments values.
-        input_arguments = node['jvm']['input_arguments']
-
-        # Check that the 4GB memory heap options are applied.
-        return all(options in input_arguments for options in config_basic.ELASTIC_JVM_OPTIONS_4GB_MEMORY_USAGE)

atomicshop/wrappers/ubuntu_terminal.py

@@ -115,7 +115,7 @@ def update_system_packages():
     Function updates the system packages.
     :return:
     """
-    subprocess.check_call(['sudo', 'apt-get', 'update'])
+    subprocess.check_call(['sudo', 'apt', 'update'])
 
 
 def upgrade_system_packages(apt_update: bool = True):
@@ -129,7 +129,7 @@ def upgrade_system_packages(apt_update: bool = True):
     if apt_update:
         update_system_packages()
 
-    subprocess.check_call(['sudo', 'apt-get', 'upgrade', '-y'])
+    subprocess.check_call(['sudo', 'apt', 'upgrade', '-y'])
 
 
 def is_service_running(service_name: str, user_mode: bool = False, return_false_on_error: bool = False) -> bool:
@@ -216,26 +216,25 @@ def start_service(service_name: str, sudo: bool = False, user_mode: bool = False
 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,
         user_mode: bool = False,
         sudo: bool = True
-):
+) -> int:
     """
     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 user_mode: bool, if True, the service will be started and enabled in user mode.
     :param sudo: bool, if True, the command will be executed with sudo.
-    :return:
+
+    :return: int, 0 if the service is running, 1 if the service is not running.
     """
 
     if not start_service_bool and not enable_service_bool:
@@ -256,11 +255,12 @@ def start_enable_service_check_availability(
 
         if not is_service_running(service_name, user_mode=user_mode):
             console.print(f"[{service_name}] service failed to start.", style='red', markup=False)
-            if exit_on_error:
-                sys.exit(1)
+            return 1
         else:
             console.print(f"[{service_name}] service is running.", style='green', markup=False)
 
+    return 0
+
 
 def add_path_to_bashrc(as_regular_user: bool = False):
     """Add $HOME/bin to the PATH in .bashrc if it's not already present.

{atomicshop-3.3.21.dist-info → atomicshop-3.3.22.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: atomicshop
-Version: 3.3.21
+Version: 3.3.22
 Summary: Atomic functions and classes to make developer life easier
 Author: Denis Kras
 License-Expression: MIT

{atomicshop-3.3.21.dist-info → atomicshop-3.3.22.dist-info}/RECORD

@@ -1,4 +1,4 @@
-atomicshop/__init__.py,sha256=sVDbOyXcjGDnpHErAr-9a53LfQe1cLDue9somCFikBM,123
+atomicshop/__init__.py,sha256=CwR_3jqYkF_a_nmrM3h4bWwuqn_DXHc7ThZPhoeOZoE,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
@@ -48,11 +48,10 @@ atomicshop/uuids.py,sha256=JSQdm3ZTJiwPQ1gYe6kU0TKS_7suwVrHc8JZDGYlydM,2214
 atomicshop/venvs.py,sha256=D9lwOoObkYoRx-weuoAmbvN-RdSHhVm4DE9TVl-utAs,903
 atomicshop/versioning.py,sha256=e5W6m9AF3__M5nntqI9CqNAeHqkwY9JhlnpYeZ1CEus,970
 atomicshop/virtualization.py,sha256=LPP4vjE0Vr10R6DA4lqhfX_WaNdDGRAZUW0Am6VeGco,494
-atomicshop/web.py,sha256=dqnOX2Y4kQktAaU2xzfT-U-emPcqN4z50rQ0UoOgiBc,13828
+atomicshop/web.py,sha256=zceiDUNIJfSSOKXNaKthvQJpIkU_sTTCWDEBbIQ_K5g,13068
 atomicshop/websocket_parse.py,sha256=aLHWyKqaYqEn_MRBWm2L6rIl6QPmqbVrjEXE_rBzwCw,16711
 atomicshop/a_installs/ubuntu/docker_rootless.py,sha256=9IPNtGZYjfy1_n6ZRt7gWz9KZgR6XCgevjqq02xk-o0,281
 atomicshop/a_installs/ubuntu/docker_sudo.py,sha256=JzayxeyKDtiuT4Icp2L2LyFRbx4wvpyN_bHLfZ-yX5E,281
-atomicshop/a_installs/ubuntu/elastic_search_and_kibana.py,sha256=yRB-l1zBxdiN6av-FwNkhcBlaeu4zrDPjQ0uPGgpK2I,244
 atomicshop/a_mains/dns_gateway_setting.py,sha256=ncc2rFQCChxlNP59UshwmTonLqC6MWblrVAzbbz-13M,149
 atomicshop/a_mains/github_wrapper.py,sha256=F-PoZknVCxWPN0PTO6l7ZNiaYvo7OVFKFI_zlPt56ps,169
 atomicshop/a_mains/msi_unpacker.py,sha256=5hrkqETYt9HIqR_3PMf32_q06kCrIcsdm_RJV9oY438,188
@@ -196,7 +195,7 @@ atomicshop/wrappers/pipw.py,sha256=mu4jnHkSaYNfpBiLZKMZxEX_E2LqW5BVthMZkblPB_c,1
 atomicshop/wrappers/process_wrapper_pbtk.py,sha256=ycPmBRnv627RWks6N8OhxJQe8Gu3h3Vwj-4HswPOw0k,599
 atomicshop/wrappers/pyopensslw.py,sha256=pklvXEbi0fHu5n1eRKKHEDLN_nsIqCTXv5Lv0bzReTo,7071
 atomicshop/wrappers/sysmonw.py,sha256=CdawuWuy_uUi3ALCm6lKP7pSyKeTk1MXyzOaTMbBSO8,5346
-atomicshop/wrappers/ubuntu_terminal.py,sha256=hHXsr_jEHU4frCwgo1XWS5Gb5nmg-Q06tiem4N8RYeE,12316
+atomicshop/wrappers/ubuntu_terminal.py,sha256=XHM6NkzNV9x57yuPWNijLDK9ayk1-KT0n3qcv31BoSc,12215
 atomicshop/wrappers/certauthw/certauth.py,sha256=qLo593_MLU8VfbhYoNQ3J5BvtZuE71aFQROysEt6_dk,12225
 atomicshop/wrappers/certauthw/certauthw.py,sha256=4WvhjANI7Kzqrr_nKmtA8Kf7B6rute_5wfP65gwQrjw,8082
 atomicshop/wrappers/ctyping/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
@@ -216,10 +215,9 @@ atomicshop/wrappers/dockerw/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMp
 atomicshop/wrappers/dockerw/dockerw.py,sha256=GgPSvXxJj15kZ-LPiaHLl8aekof53sSP_U-vUMUe7_8,10639
 atomicshop/wrappers/dockerw/install_docker.py,sha256=9fjbx3GtpnNA4d4YU2ziPynqANXxo-x-Sq90SUSQEPg,18448
 atomicshop/wrappers/elasticsearchw/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-atomicshop/wrappers/elasticsearchw/config_basic.py,sha256=fDujtrjEjbWiYh_WQ3OcYp_8mXhXPYeKLy4wSPL5qM0,1177
-atomicshop/wrappers/elasticsearchw/elastic_infra.py,sha256=at0sD-SFtmEvfGyIU_YBEKoU-MNeVtDQSNscPm0JWLc,10368
+atomicshop/wrappers/elasticsearchw/config_basic.py,sha256=vTXnOYFTT5ggZIIdiw2vhTSr9WMmJg0-QP3pt3AT9R0,515
+atomicshop/wrappers/elasticsearchw/elastic_infra.py,sha256=EiPMUufu6ZGVGFNW7lzQI8zzb0cDJCjx5pBkuahJl88,2807
 atomicshop/wrappers/elasticsearchw/elasticsearchw.py,sha256=nkjUuW6dhJf65w3JiGIxUFxSO_oNFCFw9fFR0xH_SCU,9152
-atomicshop/wrappers/elasticsearchw/install_elastic.py,sha256=m77uAkfEkjwTf0CfWBHal1C7gcQDwry7LcWN331KZOI,8640
 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
@@ -316,8 +314,8 @@ atomicshop/wrappers/socketw/statistics_csv.py,sha256=_gA8bMX6Sw_UCXKi2y9wNAwlqif
 atomicshop/wrappers/winregw/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 atomicshop/wrappers/winregw/winreg_installed_software.py,sha256=Qzmyktvob1qp6Tjk2DjLfAqr_yXV0sgWzdMW_9kwNjY,2345
 atomicshop/wrappers/winregw/winreg_network.py,sha256=ih0BVNwByLvf9F_Lac4EdmDYYJA3PzMvmG0PieDZrsE,9905
-atomicshop-3.3.21.dist-info/licenses/LICENSE.txt,sha256=lLU7EYycfYcK2NR_1gfnhnRC8b8ccOTElACYplgZN88,1094
-atomicshop-3.3.21.dist-info/METADATA,sha256=u4vdaos5E4BpZqXSzLHwu7h28iZVyv_aUN-Pw_KSVEM,9312
-atomicshop-3.3.21.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-atomicshop-3.3.21.dist-info/top_level.txt,sha256=EgKJB-7xcrAPeqTRF2laD_Np2gNGYkJkd4OyXqpJphA,11
-atomicshop-3.3.21.dist-info/RECORD,,
+atomicshop-3.3.22.dist-info/licenses/LICENSE.txt,sha256=lLU7EYycfYcK2NR_1gfnhnRC8b8ccOTElACYplgZN88,1094
+atomicshop-3.3.22.dist-info/METADATA,sha256=XyMxJFTTJwHywcPPUpS42MjToQQiaXSP6vjxpdphYH0,9312
+atomicshop-3.3.22.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+atomicshop-3.3.22.dist-info/top_level.txt,sha256=EgKJB-7xcrAPeqTRF2laD_Np2gNGYkJkd4OyXqpJphA,11
+atomicshop-3.3.22.dist-info/RECORD,,

atomicshop/a_installs/ubuntu/elastic_search_and_kibana.py

@@ -1,10 +0,0 @@
-#! /usr/bin/env python3
-from atomicshop.wrappers.elasticsearchw import install_elastic
-
-
-def main():
-    install_elastic.install_elastic_kibana_ubuntu(install_elastic=True, install_kibana=True)
-
-
-if __name__ == '__main__':
-    main()

atomicshop/wrappers/elasticsearchw/install_elastic.py

@@ -1,233 +0,0 @@
-import sys
-
-from ...print_api import print_api
-from ... import process
-from ...permissions import permissions
-from .. import ubuntu_terminal
-from . import config_basic, elastic_infra
-
-
-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.update_system_packages()
-    ubuntu_terminal.upgrade_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])
-
-        if not permissions.is_admin():
-            print_api("This script requires root privileges...", color='red')
-            sys.exit(1)
-
-        # Check if the configuration file exists.
-        elastic_infra.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.
-        elastic_infra.modify_xpack_security_setting(setting=False, output_message=True)
-
-        # Check if the setting was really set to false.
-        if elastic_infra.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)
-
-        elastic_infra.start_elastic_and_check_service_availability()
-
-        print_api("Creating custom JVM options file with 4GB memory usage.")
-        elastic_infra.create_jvm_options_custom_4gb_memory_heap_file()
-
-    if install_kibana:
-        # Install Kibana.
-        ubuntu_terminal.install_packages([config_basic.UBUNTU_KIBANA_PACKAGE_NAME])
-
-        # Start and enable Kibana service.
-        elastic_infra.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}")