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

atomicshop/wrappers/socketw/exception_wrapper.py

@@ -1,7 +1,7 @@
 import ssl
 import functools
 
-from . import base
+from . import socket_base
 from ...print_api import print_api
 from ...inspect_wrapper import get_target_function_default_args_and_combine_with_current
 
@@ -14,7 +14,13 @@ def connection_exception_decorator(function_name):
         args, kwargs = get_target_function_default_args_and_combine_with_current(function_name, *args, **kwargs)
 
         wrapper_handle_connection_exceptions.message = None
-        port = kwargs['socket_object'].getsockname()[1]
+        listen_ipv4, port = kwargs['socket_object'].getsockname()
+
+        domain_from_dns_server = kwargs['domain_from_dns_server']
+        if not domain_from_dns_server:
+            # If the domain is not passed, we will use the TCP data.
+            # This is needed for the decorator to work properly.
+            domain_from_dns_server = listen_ipv4
 
         try:
             # Since our 'kwargs' has already all the needed arguments, we don't need 'args'.
@@ -24,17 +30,15 @@ def connection_exception_decorator(function_name):
             # After that second exception will be "pass"-ed. This is an exception inside an exception handling.
             # Looks like was introduced in Python 3 in PEP 3134.
         except ConnectionAbortedError:
-            message = f"Socket Accept: {kwargs['dns_domain']}:{port}: " \
+            message = f"Socket Accept: {domain_from_dns_server}:{port}: " \
                       f"* Established connection was aborted by software on the host..."
             wrapper_handle_connection_exceptions.message = message
             print_api(message, logger_method='error', traceback_string=True, oneline=True, **kwargs['print_kwargs'])
-            pass
         except ConnectionResetError:
-            message = f"Socket Accept: {kwargs['dns_domain']}:{port}: " \
+            message = f"Socket Accept: {domain_from_dns_server}:{port}: " \
                       f"* An existing connection was forcibly closed by the remote host..."
             wrapper_handle_connection_exceptions.message = message
             print_api(message, logger_method='error', traceback_string=True, oneline=True, **kwargs['print_kwargs'])
-            pass
         except ssl.SSLEOFError as e:
             # A subclass of SSLError raised when the SSL connection has been terminated abruptly. Generally, you
             # shouldn't try to reuse the underlying transport when this error is encountered.
@@ -45,10 +49,11 @@ def connection_exception_decorator(function_name):
             wrapper_handle_connection_exceptions.message = message
             try:
                 message = \
-                    f"Socket Accept: {kwargs['dns_domain']}:{port}: {message}"
+                    f"Socket Accept: {domain_from_dns_server}:{port}: {message}"
                 wrapper_handle_connection_exceptions.message = message
-                print_api(message, error_type=True, logger_method='error', **kwargs['print_kwargs'])
-            except Exception:
+                print_api(message, error_type=True, logger_method='error', oneline=True, **kwargs['print_kwargs'])
+            except Exception as e:
+                _ = e
                 message = f"Socket Accept: port {port}: {message}"
                 wrapper_handle_connection_exceptions.message = message
                 print_api(message, logger_method='error', traceback_string=True, oneline=True, **kwargs['print_kwargs'])
@@ -59,36 +64,36 @@ def connection_exception_decorator(function_name):
             wrapper_handle_connection_exceptions.message = message
             try:
                 message = \
-                    f"Socket Accept: {kwargs['dns_domain']}:{port}: {message}"
+                    f"Socket Accept: {domain_from_dns_server}:{port}: {message}"
                 wrapper_handle_connection_exceptions.message = message
-                print_api(message, logger_method='error', **kwargs['print_kwargs'])
-            except Exception:
+                print_api(message, logger_method='error', oneline=True, **kwargs['print_kwargs'])
+            except Exception as e:
+                _ = e
                 message = f"Socket Accept: port {port}: {message}"
                 wrapper_handle_connection_exceptions.message = message
                 print_api(message, logger_method='error', traceback_string=True, oneline=True, **kwargs['print_kwargs'])
                 pass
             pass
         except ssl.SSLError as exception_object:
-            # Getting the exact reason of "ssl.SSLError"
-            if exception_object.reason == "HTTP_REQUEST":
-                message = f"Socket Accept: HTTP Request on SSL Socket: " \
-                          f"{base.get_source_destination(kwargs['socket_object'])}"
-                wrapper_handle_connection_exceptions.message = message
-                print_api(message, logger_method='error', traceback_string=True, oneline=True, **kwargs['print_kwargs'])
-            elif exception_object.reason == "TSV1_ALERT_UNKNOWN_CA":
-                message = f"Socket Accept: Check CA certificate on the client " \
-                          f"{base.get_source_destination(kwargs['socket_object'])}"
-                wrapper_handle_connection_exceptions.message = message
-                print_api(message, logger_method='error', traceback_string=True, oneline=True, **kwargs['print_kwargs'])
-            # elif exception_object.reason == "SSLV3_ALERT_CERTIFICATE_UNKNOWN":
-            #     message = f"ssl.SSLError:{exception_object}"
-            #     message = f"Socket Accept: {domain_name}:{socket_object.getsockname()[1]}: {message}"
-            #     print_api(message, logger=self.logger, logger_method='error', traceback_string=True, oneline=True)
-            # elif exception_object.reason == "NO_SHARED_CIPHER":
-            #     message = f"ssl.SSLError:{exception_object}"
-            #     message = f"Socket Accept: {domain_name}:{socket_object.getsockname()[1]}: {message}"
-            #     print_api(message, logger=self.logger, logger_method='error', traceback_string=True, oneline=True)
-            else:
+            excepted: bool = False
+            if getattr(exception_object, "reason", None):
+                # Getting the exact reason of "ssl.SSLError"
+                if exception_object.reason == "HTTP_REQUEST":
+                    message = f"Socket Accept: HTTP Request on SSL Socket: " \
+                              f"{socket_base.get_source_destination(kwargs['socket_object'])}"
+                    wrapper_handle_connection_exceptions.message = message
+                    print_api(message, logger_method='error', traceback_string=True, oneline=True, **kwargs['print_kwargs'])
+
+                    excepted = True
+                elif exception_object.reason == "TSV1_ALERT_UNKNOWN_CA":
+                    message = f"Socket Accept: Check CA certificate on the client " \
+                              f"{socket_base.get_source_destination(kwargs['socket_object'])}"
+                    wrapper_handle_connection_exceptions.message = message
+                    print_api(message, logger_method='error', traceback_string=True, oneline=True, **kwargs['print_kwargs'])
+
+                    excepted = True
+
+            if not excepted:
                 # Not all requests have the server name passed through Client Hello.
                 # If it is not passed an error of undefined variable will be raised.
                 # So, we'll check if the variable as a string is in the "locals()" variable pool.
@@ -96,39 +101,27 @@ def connection_exception_decorator(function_name):
 
                 message = "SSLError on accept. Not documented..."
                 wrapper_handle_connection_exceptions.message = message
-                print_api(message, logger_method='error', **kwargs['print_kwargs'])
-                # try:
-                #     message = f"Socket Accept: {domain_name}:{socket_object.getsockname()[1]}: {message}"
-                #     print_api(message, logger=self.logger, logger_method='error', traceback_string=True, oneline=True)
-                # except Exception:
-                #     message = f"Socket Accept: port {socket_object.getsockname()[1]}: {message}"
-                #     print_api(message, logger=self.logger, logger_method='error', traceback_string=True, oneline=True)
-                # pass
+                print_api(message, logger_method='error', oneline=True, **kwargs['print_kwargs'])
 
                 message = f'ssl.SSLError:{exception_object}'
                 wrapper_handle_connection_exceptions.message = message
                 message = \
-                    f"Socket Accept: {kwargs['dns_domain']}:{port}: {message}"
+                    f"Socket Accept: {domain_from_dns_server}:{port}: {message}"
                 wrapper_handle_connection_exceptions.message = message
-                print_api(message, logger_method='error', **kwargs['print_kwargs'])
-            pass
+                print_api(message, logger_method='error', oneline=True, **kwargs['print_kwargs'])
+
         except FileNotFoundError:
             message = "'SSLSocket.accept()' crashed: 'FileNotFoundError'. Some problem with SSL during Handshake - " \
                       "Could be certificate, client, or server."
-            message = f"Socket Accept: {kwargs['dns_domain']}:{port}: {message}"
+            message = f"Socket Accept: {domain_from_dns_server}:{port}: {message}"
             wrapper_handle_connection_exceptions.message = message
             print_api(message, logger_method='error', traceback_string=True, oneline=True, **kwargs['print_kwargs'])
-            # except Exception:
-            #     message = f"Socket Accept: port {socket_object.getsockname()[1]}: {message}"
-            #     print_api(message, logger=self.logger, logger_method='error', traceback_string=True, oneline=True)
-            #     pass
-            pass
-        except Exception:
+        except Exception as e:
+            _ = e
             message = "Undocumented exception on accept."
-            message = f"Socket Accept: {kwargs['dns_domain']}:{port}: {message}"
+            message = f"Socket Accept: {domain_from_dns_server}:{port}: {message}"
             wrapper_handle_connection_exceptions.message = message
             print_api(message, logger_method='error', traceback_string=True, oneline=True, **kwargs['print_kwargs'])
-            pass
 
     wrapper_handle_connection_exceptions.message = None
     return wrapper_handle_connection_exceptions

atomicshop/wrappers/socketw/process_getter.py

@@ -0,0 +1,86 @@
+import logging
+
+from . import socket_base
+from ...print_api import print_api
+from ...ssh_remote import SSHRemote
+from ... import package_mains_processor
+
+
+GET_LOCALHOST_FUNCTION_NAME = 'find_cmdline_by_port'
+
+
+class GetCommandLine:
+    def __init__(
+            self,
+            client_ip: str,
+            client_port: int = None,
+            package_processor: package_mains_processor.PackageMainsProcessor = None,
+            ssh_client: SSHRemote = None,
+            logger: logging.Logger = None
+    ):
+        self.client_ip: str = client_ip
+        self.client_port: int = client_port
+        self.package_processor: package_mains_processor.PackageMainsProcessor = package_processor
+        self.ssh_client: SSHRemote = ssh_client
+        self.logger: logging.Logger = logger
+
+    def get_process_name(self, print_kwargs: dict = None):
+        if print_kwargs is None:
+            print_kwargs = {}
+
+        # Checking if we're on localhost. If not, we'll execute SSH connection to get calling process name.
+        if self.client_ip not in socket_base.THIS_DEVICE_IP_LIST:
+            # Tried using paramiko SSH concurrently within threads, but with bigger loads it just breaks.
+            # So, better using it separately for each thread.
+
+            print_api(f"Initializing SSH connection to [{self.client_ip}]", **print_kwargs)
+
+            script_string: str = self.package_processor.read_script_file_to_string()
+
+            execution_output, execution_error = self.ssh_client.connect_get_client_commandline(port=self.client_port, script_string=script_string)
+        # Else, if we're on localhost, then execute the script directly without SSH.
+        else:
+            print_api(f"Executing LOCALHOST command to get the calling process.", **print_kwargs)
+            # execution_output, execution_error, rc = self.package_processor.execute_script_with_subprocess(arguments=[str(client_port)])
+            execution_output = self.package_processor.execute_script_file(
+                function_name=GET_LOCALHOST_FUNCTION_NAME, args=(self.client_port,))
+            execution_error = None
+
+        # This section is generic for both remote SSH and localhost executions of the script.
+        process_name = self.get_commandline_and_error(execution_output, execution_error, print_kwargs=print_kwargs)
+
+        return process_name
+
+    @staticmethod
+    def get_commandline_and_error(
+            execution_output,
+            execution_error,
+            print_kwargs: dict = None
+    ):
+        # If there was known error on localhost / known error on remote or any kind of error on remote, it was
+        # already logged, so we'll just put the error into 'process_name'.
+        if execution_error:
+            process_name = execution_error
+            print_api(
+                f"Error During Command Execution: {process_name}", error_type=True,
+                logger_method='error', **(print_kwargs or {}))
+        # If there wasn't any error of above types, then we can put the output from either local or remote script
+        # execution into 'process_name' and log it / output to console.
+        else:
+            # If the output that was returned is not empty.
+            if execution_output:
+                # Replacing '\r\n' escape lines with string, so that the line will not be escaped in logs.
+                if '\r\n' in execution_output:
+                    execution_output = execution_output.replace('\r\n', '')
+                elif '\n' in execution_output:
+                    execution_output = execution_output.replace('\n', '')
+
+                process_name = execution_output
+                print_api(f"Client Process Command Line: {process_name}", **(print_kwargs or {}))
+            # Else if the script output came back empty.
+            else:
+                process_name = ''
+                message = "Client Process Command Line came back empty after script execution."
+                print_api(message, error_type=True, logger_method='error', **(print_kwargs or {}))
+
+        return process_name

atomicshop/wrappers/socketw/receiver.py

@@ -1,28 +1,75 @@
+import logging
 import socket
 import ssl
 
+import select
+from pathlib import Path
+
 from ...print_api import print_api
+from ...basics import tracebacks
 from ..loggingw import loggingw
 
 
-def peek_first_bytes(client_socket, bytes_amount: int = 1) -> bytes:
+def peek_first_bytes(
+        client_socket,
+        bytes_amount: int = 1,
+        timeout: float = None
+) -> bytes:
     """
     Peek first byte from the socket without removing it from the buffer.
 
     :param client_socket: Socket object.
     :param bytes_amount: Amount of bytes to peek.
+    :param timeout: float, Timeout in seconds.
 
     :return: the first X bytes from the socket buffer.
     """
 
-    return client_socket.recv(bytes_amount, socket.MSG_PEEK)
+    error: bool = False
+    client_socket.settimeout(timeout)
+
+    try:
+        peek_a_bytes: bytes = client_socket.recv(bytes_amount, socket.MSG_PEEK)
+    except socket.timeout:
+        error = True
+    finally:
+        client_socket.settimeout(None)
+
+    if error:
+        raise TimeoutError
+
+    return peek_a_bytes
+
+
+def is_socket_ready_for_read(socket_instance, timeout: float = 0) -> bool:
+    """
+    Check if socket is ready for read.
+
+    :param socket_instance: Socket object.
+    :param timeout: Timeout in seconds. The default is no timeout.
+
+    :return: True if socket is ready for read, False otherwise.
+    """
+
+    # Check if the socket is closed.
+    if socket_instance.fileno() == -1:
+        return False
+
+    # Use select to check if the socket is ready for reading.
+    # 'readable' returns a list of sockets that are ready for reading.
+    # Since we use only one socket, it will return a list with one element if the socket is ready for reading,
+    # or an empty list if the socket is not ready for reading.
+    readable, _, _ = select.select([socket_instance], [], [], timeout)
+    return bool(readable)
 
 
 class Receiver:
     """ Receiver Class is responsible for receiving the message from socket and populate the message class """
-    logger = loggingw.get_logger_with_level("network." + __name__.rpartition('.')[2])
-
-    def __init__(self, ssl_socket: ssl.SSLSocket):
+    def __init__(
+            self,
+            ssl_socket: ssl.SSLSocket,
+            logger: logging.Logger = None
+    ):
         self.ssl_socket: ssl.SSLSocket = ssl_socket
         self.buffer_size_receive: int = 16384
         # Timeout of 2 is enough for regular HTTP sessions`.
@@ -39,130 +86,125 @@ class Receiver:
         # Will get client Local port from the socket
         self.class_client_local_port: int = int()
 
+        if logger:
+            # Create child logger for the provided logger with the module's name.
+            self.logger: logging.Logger = loggingw.get_logger_with_level(f'{logger.name}.{Path(__file__).stem}')
+        else:
+            self.logger: logging.Logger = logger
+
     # Function to receive only the buffer, with error handling
-    def socket_receive_message_buffer(self):
+    def chunk_from_buffer(self) -> tuple[bytes, str]:
+        """
+        Receive a chunk from the socket buffer.
+
+        :return: Tuple(received chunk binary bytes data, error message string).
+        """
         # Defining the data variable
-        class_data: bytes = bytes()
+        # noinspection PyTypeChecker
+        received_data: bytes = None
+        # noinspection PyTypeChecker
+        error_message: str = None
 
+        # All excepts will be treated as empty message, indicate that socket was closed and will be handled properly.
         try:
             # "recv(byte buffer size)" to read the server's response.
-            class_data = self.ssl_socket.recv(self.buffer_size_receive)
+            # A signal to close connection will be empty bytes string: b''.
+            received_data = self.ssl_socket.recv(self.buffer_size_receive)
         except ConnectionAbortedError:
-            message = "* Connection was aborted by the client. Exiting..."
-            print_api(message, logger=self.logger, logger_method='critical', traceback_string=True, oneline=True)
-            # This will be treated as empty message - indicate that socket was closed and will be handled properly.
-            pass
+            error_message = "ConnectionAbortedError: Connection was aborted by local TCP stack (not remote close)..."
         except ConnectionResetError:
-            message = "* Connection was forcibly closed by the client. Exiting..."
-            print_api(message, logger=self.logger, logger_method='critical', traceback_string=True, oneline=True)
-            # This will be treated as empty message - indicate that socket was closed and will be handled properly.
-            pass
+            error_message = "ConnectionResetError: Connection was forcibly closed by the other side..."
+        except TimeoutError as e:
+            if e.errno == 10060:
+                error_message = "TimeoutError: [WinError 10060] Socket receive operation timed out..."
+            else:
+                raise e
         except ssl.SSLError:
-            message = "* Encountered SSL error on packet receive. Exiting..."
-            print_api(message, logger=self.logger, logger_method='critical', traceback_string=True, oneline=True)
-            # This will be treated as empty message - indicate that socket was closed and will be handled properly.
-            pass
+            error_message = f"ssl.SSLError: Encountered SSL error on receive...\n{tracebacks.get_as_string()}"
 
-        if not class_data:
+        if received_data == b'':
             self.logger.info("Empty message received, socket closed on the other side.")
 
-        return class_data
+        return received_data, error_message
 
-    # Function to receive message
-    def socket_receive_message_full(self):
-        # Setting timeout for the client to receive connections, since there is no way to know when the message has
-        # ended and the message is longer than the receiving buffer.
-        # So we need to set the timeout for the client socket.
-        # If you set "timeout" on the listening main socket, it is not inherited to the child socket when client
-        # connected, so you need to set it for the new socket as well.
-        # Each function need to set the timeout independently
-        self.ssl_socket.settimeout(self.socket_timeout)
-        # variable that is responsible to retry over the same receive session if packet is less than buffer
-        partial_data_received: bool = False
+    def socket_receive_message_full(self) -> tuple[bytes, bool, str]:
+        """
+        Receive the full message from the socket.
 
+        :return: Tuple(full data binary bytes, is socket closed boolean, error message string).
+        """
         # Define the variable that is going to aggregate the whole data received
-        class_data: bytearray = bytearray()
-        # Define the variable that will be responsible for receive buffer
-        class_data_received: bytes = bytes()
+        full_data: bytes = bytes()
+        # noinspection PyTypeChecker
+        error_message: str = None
 
         # Infinite loop to accept data from the client
+        # We'll skip the 'is_socket_ready_for_read' check on the first run, since we want to read the data anyway,
+        # to leave the socket in the blocking mode.
+        first_run: bool = True
         while True:
-            # SocketTimeout creates an exception that we need to handle with try and except.
-            try:
-                # The variable needs to be defined before receiving the socket data or else you will get an error
-                # - variable not defined.
-                # function_data_received: bytearray = bytearray()
-                # Receiving data from the socket with "recv" method, while 1024 byte is a buffer size for the data.
-                # "decode()" method converts byte message to string.
-                class_data_received: bytes = self.socket_receive_message_buffer()
-            # If there is no byte data received from the client and also the full message is not empty, then the loop
-            # needs to break, since it is the last message that was received from the client
-            except TimeoutError:
-                if partial_data_received:
-                    self.logger.info(f"Timed out after {self.socket_timeout} seconds - no more packets. "
-                                     f"Passing current request of total {len(class_data)} bytes down the network chain")
-                    # Pass the exception
-                    pass
-                    # Break the while loop, since we already have the request
+            # Check if there is data to be read from the socket.
+            is_there_data: bool = is_socket_ready_for_read(self.ssl_socket, timeout=0.5)
+
+            # noinspection PyTypeChecker
+            if is_there_data or first_run:
+                first_run = False
+                # Receive the data from the socket.
+                received_chunk, error_message = self.chunk_from_buffer()
+                received_chunk: bytes
+                error_message: str
+
+                # And if the message received is not empty then aggregate it to the main "data received" variable
+                if received_chunk != b'' and received_chunk is not None:
+                    full_data += received_chunk
+
+                    self.logger.info(f"Received packet bytes: [{len(received_chunk)}] | "
+                                     f"Total aggregated bytes: [{len(full_data)}]")
+
+                elif received_chunk == b'' or received_chunk is None:
+                    # If there received_chunk is None, this means that the socket was closed,
+                    # since it is a connection error.
+                    # Same goes for the empty message.
+                    is_socket_closed = True
                     break
-                else:
-                    self.logger.info(
-                        # Dividing number of seconds by 60 to get minutes
-                        f"{self.socket_timeout/60} minutes timeout reached on 'socket.recv()' - no data received from "
-                        f"{self.class_client_address}:{self.class_client_local_port}. Still waiting...")
-                    # Pass the exception
-                    pass
-                    # Changing the socket timeout back to none since receiving operation has been finished.
-                    self.ssl_socket.settimeout(None)
-                    # Continue to the next iteration inside while
-                    continue
-
-            # And if the message received is not empty then aggregate it to the main "data received" variable
-            if class_data_received:
-                class_data.extend(class_data_received)
-
-                self.logger.info(f"Received packet with {len(class_data_received)} bytes. "
-                                 f"Current aggregated request of total: {len(class_data)} bytes")
-
-                # If the first received session is less than the buffer size, then the full message was received
-                if len(class_data_received) < self.buffer_size_receive:
-                    # Since we already received some data from the other side, the retried variable will be true
-                    partial_data_received = True
-                    self.logger.info(f"Receiving the buffer again...")
-
-                    # In this case the socket timeout will be 2 seconds to wait for more packets.
-                    # If there are no more packets, receiver will end its activity and pass the message to
-                    # the rest of the components in the network chain
-                    if self.socket_timeout != 0.5:
-                        self.socket_timeout = 0.5
-                        self.ssl_socket.settimeout(self.socket_timeout)
-                        self.logger.info(f"Timeout changed to {self.socket_timeout} seconds")
-
-                    # Continue to the next receive on the socket
-                    continue
             else:
-                if class_data:
-                    self.logger.info(f"Since there's request received from the client of total {len(class_data)} "
-                                     f"bytes, we'll first process it, and when the receiver will ask for data from "
-                                     f"client in the next cycle - empty message will be received again, and current "
-                                     f"socket will be finally closed.")
+                # If there is no data to be read from the socket, it doesn't mean that the socket is closed.
+                is_socket_closed = False
+                received_chunk = None
                 break
 
-        return class_data
+        if full_data:
+            self.logger.info(f"Received total: [{len(full_data)}] bytes")
+
+        # In case the full data is empty, and the received chunk is None, it doesn't mean that the socket is closed.
+        # But it means that there was no data to be read from the socket, because of error or timeout.
+        if full_data == b'' and received_chunk is None:
+            full_data = None
+
+        return full_data, is_socket_closed, error_message
+
+    def receive(self) -> tuple[bytes, bool, str]:
+        """
+        Receive the message from the socket.
 
-    # noinspection PyBroadException
-    def receive(self):
-        # Getting client address from the socket
+        :return: Tuple(
+            data binary bytes,
+            is socket closed boolean,
+            error message string if there was a connection exception).
+        """
+        # Getting client address and Local port from the socket
         self.class_client_address = self.ssl_socket.getpeername()[0]
-        # Getting client Local port from the socket
         self.class_client_local_port = self.ssl_socket.getpeername()[1]
 
         # Receiving data from the socket and closing the socket if send is finished.
         self.logger.info(f"Waiting for data from {self.class_client_address}:{self.class_client_local_port}")
-        function_client_data: bytearray = self.socket_receive_message_full()
+        socket_data_bytes, is_socket_closed, error_message = self.socket_receive_message_full()
+        socket_data_bytes: bytes
+        is_socket_closed: bool
+        error_message: str
 
-        if function_client_data:
+        if socket_data_bytes:
             # Put only 100 characters to the log, since we record the message any way in full - later.
-            self.logger.info(f"Received: {function_client_data[0: 100]}...")
+            self.logger.info(f"Received: {socket_data_bytes[0: 100]}...")
 
-        return function_client_data
+        return socket_data_bytes, is_socket_closed, error_message