server.py

# Server implementation

import socket
import threading
from enum import Enum
import cv2 as camera_vision
import pickle

# WINDOW DIMENSIONS
WINDOW_WIDTH = 50
WINDOW_HEIGHT = 50

# WEB CAMERA PROPERTIES
WEB_CAMERA_WIDTH_PROPERTY = 3
WEB_CAMERA_HEIGHT_PROPERTY = 4
WEB_CAMERA_DEVICE_ID_PROPERTY = 0
WEB_CAMERA_BRIGHTNESS_PROPERTY = 10

# SETUP CAPTURED VIDEO STREAM
captured_video_stream = camera_vision.VideoCapture(WEB_CAMERA_DEVICE_ID_PROPERTY)
captured_video_stream.set(WEB_CAMERA_WIDTH_PROPERTY, WINDOW_WIDTH)
captured_video_stream.set(WEB_CAMERA_HEIGHT_PROPERTY, WINDOW_HEIGHT)
captured_video_stream.set(WEB_CAMERA_BRIGHTNESS_PROPERTY, 50)


class SocketConnectionStatus(Enum):
    PENDING = 0
    RUNNING = 1
    STOPPED = 2


class Server:
    # connection port
    __SERVER_PORT = 1989

    # local server's IPv4 ADDRESS
    __SERVER_IP_ADDRESS = socket.gethostbyname(socket.gethostname())

    # Server Socket
    __server_socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)

    # Server Connection BINDER
    __SERVER_CONNECTION_BINDER = (__SERVER_IP_ADDRESS, __SERVER_PORT)

    # Bind server_socket
    __server_socket.bind(__SERVER_CONNECTION_BINDER)

    # Protocol Bytes Accepted.
    __PROTOCOL_BYTES_ACCEPTED = 4096  # 1 Kilo Byte of information, is accepted; by this Server.

    # Protocol Communication Format.
    __PROTOCOL_FORMAT = "unicode_escape"  # "utf-8"

    # Disconnect Message
    __DISCONNECT_MESSAGE = "!DISCONNECT_MESSAGE"

    def __init__(self):
        self.display_server_connection_info()
        self.server_socket_connection_status = SocketConnectionStatus.PENDING
        self.display_socket_connection_status()
        pass

    def __set_server_socket_connection_status(self, to_socket_connection_status):
        self.server_socket_connection_status = to_socket_connection_status
        pass

    def get_server_socket_connection_status(self):
        return self.server_socket_connection_status

    def display_socket_connection_status(self):
        print()
        print(f"[SERVER SOCKET CONNECTION STATUS] {self.get_server_socket_connection_status().name.lower()}...")
        pass

    def display_server_connection_info(self):
        print()
        print(f"[SERVER CONNECTION INFO] {self.__SERVER_IP_ADDRESS}:{self.__SERVER_PORT}")
        pass

    def __initiate_client_connection(self, client_connection, client_address):

        print()

        print(f"[NEW CLIENT CONNECTED TO SERVER] {client_address}:{client_connection}")

        self.display_active_client_connection_count()

        print()

        is_client_connected = True

        # Server listens, to incoming client Messages.
        while is_client_connected:

            print()

            client_message_length = int(
                client_connection.recv(self.__PROTOCOL_BYTES_ACCEPTED).decode(self.__PROTOCOL_FORMAT))

            if client_message_length:

                client_message = client_connection.recv(client_message_length).decode(self.__PROTOCOL_FORMAT)

                print(f"[CLIENT {client_address}, SENT A MESSAGE TO SERVER; THAT READS] {client_message}")

                client_connection.send(f"eho, {client_message}".encode(self.__PROTOCOL_FORMAT))

                # When the client sends the self.__DISCONNECT_MESSAGE,
                # Server must stop listening; to client's messages.
                if client_message == self.__DISCONNECT_MESSAGE:
                    is_client_connected = False
                    client_connection.close()
                elif client_message == "s":
                    try:
                        success, image_stream = captured_video_stream.read()
                        if success:
                            for data in image_stream:
                                client_connection.send(pickle.dumps(data).decode(encoding=bytes))
                    finally:
                        if camera_vision.waitKey(1) & 0xFF == ord('z'):
                            break
            pass
        pass

    def start_server_connection_to_clients(self):
        # set server_socket_connection_status to SocketConnectionStatus.RUNNING
        self.__set_server_socket_connection_status(SocketConnectionStatus.RUNNING)

        # display_socket_connection_status
        self.display_socket_connection_status()

        # Start listening to clients; caution, this operation is Blocking.
        self.__server_socket.listen()

        # Server will remain connected to its Clients; until Connection is Stopped.
        while self.get_server_socket_connection_status() == SocketConnectionStatus.RUNNING:

            try:
                # Server will now accept, new Client Connection.
                client_connection, client_address = self.__server_socket.accept()

                if client_connection and client_address:
                    # Spawn a thread, that connects a client; to this Server.
                    threading.Thread(target=self.__initiate_client_connection(client_connection, client_address),
                                     args=(client_connection, client_address)).start()

            except KeyboardInterrupt:
                self.stop_server_connection_to_clients()
        pass

    def display_active_client_connection_count(self):
        print()
        if threading:
            active_client_count = threading.activeCount()
            if active_client_count >= 1:
                print(f"[ACTIVE CLIENTS ON SERVER SOCKET CONNECTION] {active_client_count}")
            else:
                print("[NO ACTIVE CLIENT ON SERVER SOCKET CONNECTION]")
        pass

    def stop_server_connection_to_clients(self):
        self.__set_server_socket_connection_status(SocketConnectionStatus.STOPPED)
        self.display_active_client_connection_count()
        self.display_socket_connection_status()
        pass

    pass


class ServerApp:
    def __init__(self):
        self.server = Server()
        self.server.start_server_connection_to_clients()
        pass

    pass


serverApp = ServerApp()