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

atomicshop/certificates.py

@@ -5,9 +5,10 @@ https://oidref.com/1.3.6.1.5.5.7.3.1
 
 
 import ssl
+from typing import Literal
 
 from .wrappers import cryptographyw
-from .print_api import print_api
+from .wrappers.pywin32w import cert_store
 
 
 # Valid for 3 years from now
@@ -16,72 +17,165 @@ from .print_api import print_api
 SECONDS_NOT_AFTER_3_YEARS = 3 * 365 * 24 * 60 * 60
 
 
-def is_certificate_in_store(certificate, issuer_only: bool = False, thumbprint_only: bool = False):
+def get_pem_certificate_from_string(certificate: str) -> str:
     """
-    The function will check if the certificate is installed in the Windows certificate store.
-
-    :param certificate: x509 object, certificate to check.
-    :param issuer_only: bool, if True, will check only by the certificate issuer common name is installed in the store.
-        The problem that the issuer common name is not unique, so it can be installed multiple times.
-    :param thumbprint_only: bool, if True, will check only by the certificate thumbprint is installed in the store.
-        The problem that searching by the thumbprint will not tell you if there are multiple certificates with the same
-        issuer name.
-    :return: bool, True if certificate is installed, False if not.
+    Some PEM certificates can contain a private key. This function will return only the certificate part.
+
+    :param certificate: string, PEM certificate.
+    :return: string, certificate part.
     """
 
-    # Make sure the certificate is x509.Certificate object.
-    certificate = cryptographyw.convert_object_to_x509(certificate)
-    # Get the certificate thumbprint.
-    thumbprint = cryptographyw.get_sha1_thumbprint_from_x509(certificate)
-    issuer_common_name: str = cryptographyw.get_issuer_common_name_from_x509(certificate)
+    certificate_lines = certificate.split('\n')
+    certificate_part = ''
+    start = False
+    for line in certificate_lines:
+        if 'BEGIN CERTIFICATE' in line:
+            start = True
+        if start:
+            certificate_part += line + '\n'
+        if 'END CERTIFICATE' in line:
+            break
 
-    # for store in ["CA", "ROOT", "MY"]:
-    for cert, encoding, trust in ssl.enum_certificates("ROOT"):
-        store_certificate = cryptographyw.convert_object_to_x509(cert)
-        store_issuer_common_name: str = cryptographyw.get_issuer_common_name_from_x509(store_certificate)
-        store_thumbprint = cryptographyw.get_sha1_thumbprint_from_x509(store_certificate)
-
-        if issuer_only:
-            if store_issuer_common_name == issuer_common_name:
-                return True, certificate
-        elif thumbprint_only:
-            if store_thumbprint == thumbprint:
-                return True, certificate
-        elif not issuer_only and not thumbprint_only:
-            if store_thumbprint == thumbprint and store_issuer_common_name == issuer_common_name:
-                return True, certificate
+    return certificate_part
 
 
-def get_certificates_by_issuer_name(issuer_name: str, print_kwargs: dict = None):
+def write_crt_certificate_file_in_pem_format_from_pem_file(
+        pem_file_path: str,
+        crt_file_path: str
+):
     """
-    The function will return all certificates with the specified issuer name.
+    The function will read the PEM certificate file and write it to the CRT file in PEM format.
+    The function is used to convert the PEM certificate file to the CRT file.
 
-    :param issuer_name: string, issuer name to search for.
-    :param print_kwargs: dict, that contains all the arguments for 'print_api' function.
+    Basically the point here is that the CRT file is the same as the PEM file, but the extension is different,
+    and it doesn't support integrated private key.
 
-    :return: list, of certificates with the specified issuer name.
+    :param pem_file_path: string, path to the PEM certificate file.
+    :param crt_file_path: string, path to the CRT certificate file.
     """
 
-    if not print_kwargs:
-        print_kwargs = {}
+    with open(pem_file_path, 'r') as f:
+        certificate_string = f.read()
+
+    certificate_pem = get_pem_certificate_from_string(certificate_string)
+
+    with open(crt_file_path, 'w') as f:
+        f.write(certificate_pem)
+
+
+def is_certificate_in_store(
+        certificate: any = None,
+        by_cert_issuer: bool = True,
+        by_cert_thumbprint: bool = True,
+        issuer_name: str = None,
+        store_location: str = "ROOT"
+) -> tuple[bool, list]:
+    """
+    The function will check if the CA certificate is installed in the Windows certificate Trusted Root store.
+    NO ADMIN RIGHTS NEEDED.
+
+    :param certificate: x509 object, certificate to check. You can search by certificate or by issuer name.
+        Supported types:
+            string that is path to file will be imported as bytes object abd converted to x509.Certificate
+                After check if it's PEM or DER format.
+            string that is PEM certificate will be converted to bytes, then x509.Certificate
+            bytes of PEM or DER will be converted to x509.Certificate.
+            x509.Certificate will be returned as is.
+    :param by_cert_issuer: bool, if True, will check only by the certificate issuer common name is installed in the store.
+        The problem if the search will be by issuer alone, that the issuer common name is not unique,
+        so it can be installed multiple times.
+    :param by_cert_thumbprint: bool, if True, will check only by the certificate thumbprint is installed in the store.
+        The problem that searching by the thumbprint alone will not tell you if there are multiple
+        certificates with the same issuer name.
+    :param issuer_name: string, issuer name to search for. You can search by certificate or by issuer name.
+    :param store_location: string, store location to search in. Default is "ROOT".
+    :return: tuple(bool - True if certificate is installed and False if not, list of certificates found)
+    """
 
-    certificates_list = []
+    if not by_cert_issuer and not by_cert_thumbprint:
+        raise ValueError('At least one of the parameters "by_issuer" or "by_thumbprint" must be True.')
+
+    if not certificate and not issuer_name:
+        raise ValueError('At least one of the parameters "certificate" or "issuer_name" must be provided.')
+    elif certificate and issuer_name:
+        raise ValueError('Only one of the parameters "certificate" or "issuer_name" must be provided.')
+
+    if certificate:
+        # Make sure the certificate is x509.Certificate object.
+        certificate_x509 = cryptographyw.convert_object_to_x509(certificate)
+        # Get the certificate thumbprint.
+        provided_thumbprint = cryptographyw.get_sha1_thumbprint_from_x509(certificate_x509)
+        provided_issuer_common_name: str = cryptographyw.get_issuer_common_name_from_x509(certificate_x509)
+    elif issuer_name:
+        provided_thumbprint = None
+        provided_issuer_common_name = issuer_name
+    else:
+        raise ValueError('At least one of the parameters "certificate" or "issuer_name" must be provided.')
 
-    for cert, encoding, trust in ssl.enum_certificates("ROOT"):
+    # Iterate over all certificates in the store specifically in the ROOT.
+    # for store in ["CA", "ROOT", "MY"]:
+    result_found_list: list = []
+    found: bool = False
+    for cert, encoding, trust in ssl.enum_certificates(store_location):
         store_certificate = cryptographyw.convert_object_to_x509(cert)
         store_issuer_common_name: str = cryptographyw.get_issuer_common_name_from_x509(store_certificate)
+        store_thumbprint = cryptographyw.get_sha1_thumbprint_from_x509(store_certificate)
 
-        if store_issuer_common_name == issuer_name:
-            certificates_list.append(store_certificate)
+        if certificate:
+            if by_cert_issuer and not by_cert_thumbprint:
+                if store_issuer_common_name == provided_issuer_common_name:
+                    result_found_list.append(store_certificate)
+                    found = True
+            elif by_cert_thumbprint and not by_cert_issuer:
+                if store_thumbprint == provided_thumbprint:
+                    result_found_list.append(store_certificate)
+                    found = True
+            elif by_cert_issuer and by_cert_thumbprint:
+                if store_thumbprint == provided_thumbprint and store_issuer_common_name == provided_issuer_common_name:
+                    result_found_list.append(store_certificate)
+                    found = True
+        elif issuer_name:
+            if store_issuer_common_name == provided_issuer_common_name:
+                result_found_list.append(store_certificate)
+                found = True
+
+    return found, result_found_list
+
+
+def delete_certificate_by_issuer_name(
+        issuer_name: str,
+        store_location: Literal[
+            "ROOT",
+            "CA",
+            "MY"] = "ROOT",
+        print_kwargs: dict = None
+):
+    """
+    NEED ADMIN RIGHTS.
+    The function will remove all certificates with the specified issuer name.
+    There can be several certificates with this name.
 
-    if certificates_list:
-        for certificate_single in certificates_list:
-            issuer_name = cryptographyw.get_issuer_common_name_from_x509(certificate_single)
-            thumbprint = cryptographyw.get_sha1_thumbprint_from_x509(certificate_single)
-            message = f'Issuer name: {issuer_name} | Thumbprint: {thumbprint}'
-            print_api(message, **print_kwargs)
-    else:
-        message = f'No certificates with issuer name: {issuer_name}'
-        print_api(message, **print_kwargs)
+    :param issuer_name: string, issuer name to search for.
+    :param store_location: string, store location to search in. Default is "ROOT".
+    :param print_kwargs: dict, print_api kwargs.
+    """
+
+    cert_store.delete_certificate_by_issuer_name(issuer_name, store_location, print_kwargs)
+
+
+def install_certificate_file(
+        file_path: str,
+        store_location: Literal[
+            "ROOT", "CA", "MY"] = "ROOT",
+        print_kwargs: dict = None
+):
+    """
+    The function will install the certificate from the file to the specified store location.
+    NEED ADMIN RIGHTS.
+
+    :param file_path: string, full file path to the certificate file.
+    :param store_location: string, store location to install the certificate. Default is "ROOT".
+    :param print_kwargs: dict, print_api kwargs.
+    """
 
-    return certificates_list
+    cert_store.install_certificate_file(file_path, store_location, print_kwargs)

atomicshop/mitm/config_static.py

@@ -4,9 +4,9 @@ from dataclasses import dataclass
 from . import import_config
 
 
-SCRIPT_VERSION: str = '1.7.5'
+SCRIPT_VERSION: str = '1.7.6'
 """
-Added logs backup days
+added ca cert check and installation
 """
 
 
@@ -23,6 +23,8 @@ LIST_OF_BOOLEANS: list = [
     ('tcp', 'engines_usage'),
     ('tcp', 'server_response_mode'),
     ('logrec', 'enable_request_response_recordings_in_logs'),
+    ('certificates', 'install_ca_certificate_to_root_store'),
+    ('certificates', 'uninstall_unused_ca_certificates_with_mitm_ca_name'),
     ('certificates', 'default_server_certificate_usage'),
     ('certificates', 'sni_add_new_domains_to_default_server_certificate'),
     ('certificates', 'custom_server_certificate_usage'),
@@ -55,8 +57,11 @@ class MainConfig:
     # Certificates.
     default_server_certificate_name: str = 'default'
     ca_certificate_name: str = 'ElaborateCA'
+    ca_certificate_pem_filename: str = f'{ca_certificate_name}.pem'
+    ca_certificate_crt_filename: str = f'{ca_certificate_name}_for_manual_installation_not_used_by_script.crt'
     # CA Certificate name and file name without extension.
     ca_certificate_filepath: str = None
+    ca_certificate_crt_filepath: str = None
     # Default server certificate file name and path.
     default_server_certificate_filename = f'{default_server_certificate_name}.pem'
     default_server_certificate_filepath: str = None
@@ -65,7 +70,8 @@ class MainConfig:
     def update(cls):
         # This runs after the dataclass is initialized
         cls.ENGINES_DIRECTORY_PATH = cls.SCRIPT_DIRECTORY + os.sep + cls.ENGINES_DIRECTORY_NAME
-        cls.ca_certificate_filepath = f'{cls.SCRIPT_DIRECTORY}{os.sep}{cls.ca_certificate_name}.pem'
+        cls.ca_certificate_filepath = f'{cls.SCRIPT_DIRECTORY}{os.sep}{cls.ca_certificate_pem_filename}'
+        cls.ca_certificate_crt_filepath = f'{cls.SCRIPT_DIRECTORY}{os.sep}{cls.ca_certificate_crt_filename}'
         cls.default_server_certificate_filepath = \
             f'{cls.SCRIPT_DIRECTORY}{os.sep}{cls.default_server_certificate_filename}'
 
@@ -115,6 +121,9 @@ class LogRec:
 
 @dataclass
 class Certificates:
+    install_ca_certificate_to_root_store: bool
+    uninstall_unused_ca_certificates_with_mitm_ca_name: bool
+
     default_server_certificate_usage: bool
     sni_add_new_domains_to_default_server_certificate: bool
 

atomicshop/mitm/import_config.py

@@ -117,6 +117,14 @@ def check_configurations() -> int:
             print_api(message, color='red')
             return 1
 
+    # This is checked directly in the SocketWrapper.
+    # if (config_static.Certificates.install_ca_certificate_to_root_store and not is_admin) or \
+    #         (config_static.Certificates.uninstall_unused_ca_certificates_with_mitm_ca_name and not is_admin):
+    #     message: str = \
+    #         "Need to run the script with administrative rights to install or uninstall CA certificate.\nExiting..."
+    #     print_api(message, color='red')
+    #     return 1
+
     return 0
 
 

atomicshop/mitm/mitm_main.py

@@ -263,6 +263,10 @@ def mitm_server_main(config_file_path: str):
                 listening_port_list=config_static.TCPServer.listening_port_list,
                 ca_certificate_name=config_static.MainConfig.ca_certificate_name,
                 ca_certificate_filepath=config_static.MainConfig.ca_certificate_filepath,
+                ca_certificate_crt_filepath=config_static.MainConfig.ca_certificate_crt_filepath,
+                install_ca_certificate_to_root_store=config_static.Certificates.install_ca_certificate_to_root_store,
+                uninstall_unused_ca_certificates_with_ca_certificate_name=(
+                    config_static.Certificates.uninstall_unused_ca_certificates_with_mitm_ca_name),
                 default_server_certificate_usage=config_static.Certificates.default_server_certificate_usage,
                 default_server_certificate_name=config_static.MainConfig.default_server_certificate_name,
                 default_certificate_domain_list=config_static.Certificates.domains_all_times,
@@ -316,11 +320,10 @@ def mitm_server_main(config_file_path: str):
             dns_gateway_server_list = [base.DEFAULT_IPV4]
             set_dns_gateway = True
 
+        # Get current network interface state.
+        global NETWORK_INTERFACE_IS_DYNAMIC, NETWORK_INTERFACE_IPV4_ADDRESS_LIST
+        NETWORK_INTERFACE_IS_DYNAMIC, NETWORK_INTERFACE_IPV4_ADDRESS_LIST = dns.get_default_dns_gateway()
         if set_dns_gateway:
-            # Get current network interface state.
-            global NETWORK_INTERFACE_IS_DYNAMIC, NETWORK_INTERFACE_IPV4_ADDRESS_LIST
-            NETWORK_INTERFACE_IS_DYNAMIC, NETWORK_INTERFACE_IPV4_ADDRESS_LIST = dns.get_default_dns_gateway()
-
             # Set the DNS gateway to the specified one only if the DNS gateway is dynamic or it is static but different
             # from the one specified in the configuration file.
             if (NETWORK_INTERFACE_IS_DYNAMIC or (not NETWORK_INTERFACE_IS_DYNAMIC and

atomicshop/mitm/recs_files.py

@@ -2,7 +2,6 @@ import datetime
 import os
 import multiprocessing
 
-from ..wrappers.loggingw import reading
 from ..archiver import zips
 from .. import filesystem
 

atomicshop/process_poller/process_pool.py

@@ -3,7 +3,6 @@ import multiprocessing
 import time
 from typing import Literal, Union
 
-from ..print_api import print_api
 from .tracers import sysmon_etw, event_log
 from .pollers import psutil_pywin32wmi_dll
 from ..wrappers.pywin32w.win_event_log.subscribes import process_terminate

atomicshop/process_poller/simple_process_pool.py

@@ -4,7 +4,6 @@ import time
 
 from ..wrappers.pywin32w.win_event_log.subscribes import process_create, process_terminate
 from .. import get_process_list
-from ..print_api import print_api
 
 
 WAIT_BEFORE_PROCESS_TERMINATION_CHECK_SECONDS: float = 3

atomicshop/wrappers/cryptographyw.py

@@ -36,7 +36,9 @@ def convert_object_to_x509(certificate):
     """
 
     # Check if 'certificate' is a string and a path.
-    if isinstance(certificate, str) and os.path.isfile(certificate):
+    if isinstance(certificate, str):
+        if not os.path.isfile(certificate):
+            raise FileNotFoundError(f'File not found: {certificate}')
         # Import the certificate from the path.
         certificate = file_io.read_file(certificate, file_mode='rb')
 

atomicshop/wrappers/ctyping/msi_windows_installer/extract_msi_main.py

@@ -1,5 +1,4 @@
 import os
-import sys
 import argparse
 
 from .base import msi

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/elasticsearchw/install_elastic.py

@@ -4,7 +4,7 @@ from ...print_api import print_api
 from ... import process
 from ...permissions import permissions
 from .. import ubuntu_terminal
-from . import config_basic, infrastructure
+from . import config_basic, elastic_infra
 
 
 def install_elastic_kibana_ubuntu(install_elastic: bool = True, install_kibana: bool = True):
@@ -202,29 +202,29 @@ def install_elastic_kibana_ubuntu(install_elastic: bool = True, install_kibana:
             sys.exit(1)
 
         # Check if the configuration file exists.
-        infrastructure.is_elastic_config_file_exists(exit_on_error=True, output_message=True)
+        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.
-        infrastructure.modify_xpack_security_setting(setting=False, output_message=True)
+        elastic_infra.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:
+        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)
 
-        infrastructure.start_elastic_and_check_service_availability()
+        elastic_infra.start_elastic_and_check_service_availability()
 
         print_api("Creating custom JVM options file with 4GB memory usage.")
-        infrastructure.create_jvm_options_custom_4gb_memory_heap_file()
+        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.
-        infrastructure.start_kibana_and_check_service_availability()
+        elastic_infra.start_kibana_and_check_service_availability()
 
     print_api("Installation completed.", color='green')
     if install_elastic:

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/githubw.py

@@ -3,7 +3,6 @@ import fnmatch
 
 from .. import web, urls
 from ..print_api import print_api
-from ..basics import strings
 
 
 class GitHubWrapper:

atomicshop/wrappers/loggingw/handlers.py

@@ -84,27 +84,42 @@ def add_stream_handler(
 
 # Function to start the interval-based rotation check
 def _start_interval_rotation(handler):
+    # def check_rotation():
+    #     while True:
+    #         next_rollover = _calculate_next_rollover()
+    #         while datetime.now() < next_rollover:
+    #             time.sleep(0.1)
+    #
+    #             # Check if the next_rollover has changed (indicating a rollover by an event)
+    #             if _calculate_next_rollover() != next_rollover:
+    #                 next_rollover = _calculate_next_rollover()
+    #                 break
+    #
+    #         # Perform manual rollover if needed
+    #         if datetime.now() >= next_rollover:
+    #             handler.doRollover()
+    #
+    #         # handler.doRollover()
+    #
+    # def _calculate_next_rollover():
+    #     return datetime.fromtimestamp(handler.rolloverAt)
     def check_rotation():
-        while True:
-            next_rollover = _calculate_next_rollover()
-            while datetime.now() < next_rollover:
-                time.sleep(0.1)
+        last_rollover_at = handler.rolloverAt  # Initial rollover time
 
-                # Check if the next_rollover has changed (indicating a rollover by an event)
-                if _calculate_next_rollover() != next_rollover:
-                    next_rollover = _calculate_next_rollover()
-                    break
+        while True:
+            current_time = datetime.now()
+            next_rollover = datetime.fromtimestamp(handler.rolloverAt)
 
-            # Perform manual rollover if needed
-            if datetime.now() >= next_rollover:
-                _rotate_log()
+            # Check if the rollover time has passed and it hasn't been handled yet
+            if current_time >= next_rollover and handler.rolloverAt == last_rollover_at:
+                # Perform manual rollover
+                handler.doRollover()
 
-    def _calculate_next_rollover():
-        return datetime.fromtimestamp(handler.rolloverAt)
+                # Update last_rollover_at to the new rolloverAt
+                last_rollover_at = handler.rolloverAt
 
-    # Function to rotate logs
-    def _rotate_log():
-        handler.doRollover()
+            # Sleep for a short interval before checking again
+            time.sleep(0.1)
 
     rotation_thread = threading.Thread(target=check_rotation)
     rotation_thread.daemon = True

atomicshop/wrappers/loggingw/loggingw.py

@@ -5,6 +5,7 @@ from typing import Literal, Union
 from . import loggers, handlers
 
 
+# noinspection PyPep8Naming
 def create_logger(
         logger_name: str,
         file_path: str = None,
@@ -74,7 +75,9 @@ def create_logger(
         in the formatter in case you provide 'asctime' element.
     :param filehandler_rotate_at_rollover_time: bool,
         If set to True, the log file will be rotated at the rollover time, even if there's nothing to write.
+            This behavior overrides the TimedRotatingFileHandler default behavior on doRollover.
         If set to False, the log file will be rotated after 'when' time, but only when event occurs.
+            This is the default doRollover behavior of the TimedRotatingFileHandler.
     :param filehandler_rotation_date_format: string, Date format to use for the log file rotation.
         Example for 'when="midnight"': the default date format is '%Y-%m-%d', resulting in filename on rotation like:
             "test.log.2021-11-25"

atomicshop/wrappers/mongodbw/install_mongodb.py

@@ -8,7 +8,7 @@ from ... import urls, web
 from ...permissions import permissions
 from ...print_api import print_api
 from .. import msiw
-from . import infrastructure
+from . import mongo_infra
 
 
 MONGODB_DOWNLOAD_PAGE_URL: str = 'https://www.mongodb.com/try/download/community'
@@ -111,7 +111,7 @@ def download_install_latest_main(
         print_api("This function requires administrator privileges.", color='red')
         return 1
 
-    if infrastructure.is_service_running():
+    if mongo_infra.is_service_running():
         print_api("MongoDB service is running - already installed.", color='blue')
 
         if not force:
@@ -119,8 +119,8 @@ def download_install_latest_main(
     else:
         print_api("MongoDB is service is not running.")
 
-        mongo_is_installed: Union[str, None] = infrastructure.is_installed()
-        if infrastructure.is_installed():
+        mongo_is_installed: Union[str, None] = mongo_infra.is_installed()
+        if mongo_infra.is_installed():
             message = f"MongoDB is installed in: {mongo_is_installed}\n" \
                       f"The service is not running. Fix the service or use the 'force' parameter to reinstall."
             print_api(message, color='yellow')
@@ -151,11 +151,11 @@ def download_install_latest_main(
 
     # Check if MongoDB is installed.
     message: str = ''
-    mongo_is_installed = infrastructure.is_installed()
+    mongo_is_installed = mongo_infra.is_installed()
     if not mongo_is_installed:
         message += "MongoDB Executable not found.\n"
 
-    if not infrastructure.is_service_running():
+    if not mongo_infra.is_service_running():
         message += "MongoDB service is not running.\n"
 
     if message:

atomicshop/wrappers/mongodbw/{infrastructure.py → mongo_infra.py}

@@ -1,9 +1,13 @@
+import os
 from typing import Union
 
 from pymongo import MongoClient
 import pymongo.errors
 
-from ... import get_process_list, filesystem
+from ... import filesystem
+
+if os.name == 'nt':
+    from ... import get_process_list
 
 
 WHERE_TO_SEARCH_FOR_MONGODB_EXE: str = 'C:\\Program Files\\MongoDB\\Server\\'
@@ -34,12 +38,16 @@ def is_service_running() -> bool:
     Check if the MongoDB service is running.
     :return: bool, True if the MongoDB service is running, False otherwise.
     """
-    current_processes: dict = (
-        get_process_list.GetProcessList(get_method='pywin32', connect_on_init=True).get_processes())
 
-    for pid, process_info in current_processes.items():
-        if MONGODB_EXE_NAME in process_info['name']:
-            return True
+    if os.name == 'nt':
+        current_processes: dict = (
+            get_process_list.GetProcessList(get_method='pywin32', connect_on_init=True).get_processes())
+
+        for pid, process_info in current_processes.items():
+            if MONGODB_EXE_NAME in process_info['name']:
+                return True
+    else:
+        raise NotImplementedError("This function is not implemented for this OS.")
 
     return False