mobilus-client 0.1.dev0__py3-none-any.whl

mobilus_client/__main__.py

@@ -0,0 +1,60 @@
+import argparse
+import logging
+import sys
+from typing import Tuple, Dict
+from mobilus_client.config import Config
+from mobilus_client.app import App
+
+logger = logging.getLogger(__name__)
+
+
+def main() -> None:
+    parser = argparse.ArgumentParser(
+        description="Run Mobilus Client with specific commands and parameters."
+    )
+    parser.add_argument('--host', required=True, help="Cosmo GTW address")
+    parser.add_argument('--login', required=True, help="User login")
+    parser.add_argument('--password', required=True, help="User password")
+    parser.add_argument('--verbose', action='store_true', help="Enable verbose logging")
+    parser.add_argument('commands', nargs='+', help="Commands to run")
+
+    # Parse arguments
+    args = parser.parse_args()
+
+    # Create a config object
+    config = Config(
+        gateway_host=args.host,
+        user_login=args.login,
+        user_password=args.password,
+    )
+
+    # Set up logging
+    logging.basicConfig(
+        stream=sys.stdout,
+        level=logging.DEBUG if args.verbose else logging.WARNING,
+        format='{"name": "[%(name)s]", "levelname": "%(levelname)s", "message": "%(message)s"}'
+    )
+
+    commands = []
+    for command_str in args.commands:
+        command, params = _parse_command(command_str)
+        commands.append((command, params))
+
+    app = App(config)
+    responses = app.call(commands)
+    print(responses)
+
+
+def _parse_command(command_str: str) -> Tuple[str, Dict[str, str]]:
+    """
+    " Parse a command string into a command and a dictionary of parameters. "
+    " Example: 'command:param1=value1,param2=value2' "
+    " Returns: ('command', {'param1': 'value1', 'param2': 'value2'}) "
+    """
+    command, *params = command_str.split(':', 1)
+    params_dict = dict(param.split('=') for param in params[0].split(',')) if params else {}
+    return command, params_dict
+
+
+if __name__ == '__main__':
+    main()

mobilus_client/app.py

@@ -0,0 +1,63 @@
+import logging
+import socket
+from typing import Dict, List, Tuple
+from mobilus_client.config import Config
+from mobilus_client.messages.serializer import MessageSerializer
+from mobilus_client.mqtt_client import MqttClient
+from mobilus_client.registries.message import MessageRegistry
+from mobilus_client.registries.key import KeyRegistry
+
+logger = logging.getLogger(__name__)
+
+
+class App:
+    def __init__(self, config: Config) -> None:
+        self.config = config
+        self.message_registry = MessageRegistry()
+        self.key_registry = KeyRegistry(config.user_key)
+        self.client = MqttClient(
+            client_id=config.client_id,
+            transport=config.gateway_protocol,
+            userdata={
+                "config": config,
+                "key_registry": self.key_registry,
+                "message_registry": self.message_registry,
+            }
+        )
+
+    def call(self, commands: List[Tuple[str, Dict[str, str]]]) -> str:
+        if not commands:
+            return self._empty_response()
+
+        try:
+            # Connect to the MQTT broker and start the loop
+            self.client.connect(self.config.gateway_host, self.config.gateway_port, 60)
+            self.client.loop_start()
+
+            # Wait for the client to authenticate
+            self.client.authenticated_event.wait(timeout=self.config.auth_timeout_period)
+
+            if not self.client.authenticated_event.is_set():
+                logger.error("Failed to authenticate with the gateway host")
+                return self._empty_response()
+
+            # Execute the provided commands
+            for command, params in commands:
+                self.client.send_request(command, **params)
+
+            # Wait for the completion event to be triggered
+            self.client.completed_event.wait(timeout=self.config.timeout_period)
+        except socket.gaierror:
+            logger.error("Failed to connect to the gateway host")
+        except TimeoutError:
+            logger.error("Timeout occurred")
+        finally:
+            self.client.disconnect()
+
+        # Return serialized responses from the message registry
+        return MessageSerializer.serialize_list_to_json(
+            self.message_registry.get_responses()
+        )
+
+    def _empty_response(self) -> str:
+        return MessageSerializer.serialize_list_to_json([])

mobilus_client/config.py

@@ -0,0 +1,20 @@
+import random
+from dataclasses import dataclass
+from mobilus_client.utils.encryption import create_key
+
+
+@dataclass
+class Config:
+    gateway_host: str
+    user_login: str
+    user_password: str
+
+    auth_timeout_period: float = 30
+    client_id: str = ''.join(random.choice('0123456789ABCDEF') for _ in range(12))
+    gateway_port: int = 8884
+    gateway_protocol: str = "websockets"
+    timeout_period: float = 30
+    user_key: bytes = b''
+
+    def __post_init__(self) -> None:
+        self.user_key = create_key(self.user_password)

mobilus_client/messages/encryptor.py

@@ -0,0 +1,88 @@
+import struct
+import time
+from google.protobuf.message import DecodeError
+from typing import cast, Optional
+from mobilus_client.registries.key import KeyRegistry
+from mobilus_client.proto import (
+    CallEventsRequest,
+    CurrentStateRequest,
+    CurrentStateResponse,
+    DevicesListRequest,
+    DevicesListResponse,
+    LoginRequest,
+    LoginResponse
+)
+from mobilus_client.utils.encryption import create_iv, decrypt_body, encrypt_body
+from mobilus_client.utils.types import MessageRequest, MessageResponse
+
+
+class MessageEncryptor:
+    CATEGORY_MAP = {
+        1: LoginRequest,
+        2: LoginResponse,
+        3: DevicesListRequest,
+        4: DevicesListResponse,
+        13: CallEventsRequest,
+        26: CurrentStateRequest,
+        27: CurrentStateResponse,
+    }
+    CLASS_TO_CATEGORY_MAP = {v: k for k, v in CATEGORY_MAP.items()}
+
+    @staticmethod
+    def encrypt(message: MessageRequest, client_id: str, key_registry: KeyRegistry) -> bytes:
+        category = MessageEncryptor.CLASS_TO_CATEGORY_MAP.get(type(message))
+        body = message.SerializeToString()
+        timestamp = int(time.time())
+        length = 13
+
+        private_key = key_registry.get_encryption_key(type(message))
+
+        if private_key is None:
+            encrypted_body = body
+        else:
+            iv = create_iv(timestamp)
+            encrypted_body = encrypt_body(private_key, iv, body)
+
+        return (
+            struct.pack('>IBI', length, category, timestamp) +
+            bytes.fromhex(client_id) +
+            struct.pack('>2B', 4, 0) +
+            encrypted_body
+        )
+
+    @staticmethod
+    def decrypt(encrypted_message: bytes, key_registry: KeyRegistry) -> Optional[MessageResponse]:
+        # Define header format and calculate size
+        header_format = '>IBI6sBB'
+        header_size = struct.calcsize(header_format)
+
+        # Do early return if message is too short
+        if len(encrypted_message) < header_size:
+            return None
+
+        # Unpack header
+        length, category, timestamp, user_id, platform, response_code = struct.unpack(
+            header_format, encrypted_message[:header_size])
+
+        # Extract encrypted body
+        encrypted_body = encrypted_message[header_size:]
+
+        # Choose proper klass
+        message_klass = MessageEncryptor.CATEGORY_MAP.get(category)
+        if message_klass is None:
+            return None
+
+        # Choose proper decryption key
+        key = key_registry.get_decryption_key(message_klass)
+
+        # Decrypt body
+        iv = create_iv(timestamp)
+        body = decrypt_body(key, iv, encrypted_body)
+
+        try:
+            message = cast(MessageResponse, message_klass())
+            message.ParseFromString(body)
+        except DecodeError:
+            return None
+
+        return message

mobilus_client/messages/factory.py

@@ -0,0 +1,66 @@
+from abc import ABC, abstractmethod
+from typing import Any, Optional
+from mobilus_client.proto import (
+    CallEvent,
+    CallEventsRequest,
+    CurrentStateRequest,
+    DevicesListRequest,
+    LoginRequest,
+)
+from mobilus_client.utils.types import MessageRequest
+
+
+class MessageBuilder(ABC):
+    @abstractmethod
+    def build(self, **kwargs: Any) -> Optional[MessageRequest]:
+        pass
+
+
+class LoginMessageBuilder(MessageBuilder):
+    def build(self, **kwargs: Any) -> Optional[LoginRequest]:
+        if 'login' not in kwargs or 'password' not in kwargs:
+            return None
+
+        request = LoginRequest()
+        request.login = str(kwargs['login'])
+        request.password = bytes(kwargs['password'])
+        return request
+
+
+class DevicesListMessageBuilder(MessageBuilder):
+    def build(self, **kwargs: Any) -> DevicesListRequest:
+        return DevicesListRequest()
+
+
+class CurrentStateMessageBuilder(MessageBuilder):
+    def build(self, **kwargs: Any) -> CurrentStateRequest:
+        return CurrentStateRequest()
+
+
+class CallEventsMessageBuilder(MessageBuilder):
+    def build(self, **kwargs: Any) -> Optional[CallEventsRequest]:
+        if 'device_id' not in kwargs or 'value' not in kwargs:
+            return None
+
+        event = CallEvent()
+        event.event_number = int(kwargs.get('event_number', 6))
+        event.device_id = int(kwargs['device_id'])
+        event.value = str(kwargs['value'])
+
+        request = CallEventsRequest()
+        request.events.append(event)
+        return request
+
+
+class MessageFactory:
+    _builders = {
+        "call_events": CallEventsMessageBuilder(),
+        "current_state": CurrentStateMessageBuilder(),
+        "devices_list": DevicesListMessageBuilder(),
+        "login": LoginMessageBuilder(),
+    }
+
+    @staticmethod
+    def create_message(message_name: str, **kwargs: Any) -> Optional[MessageRequest]:
+        builder = MessageFactory._builders.get(message_name)
+        return builder.build(**kwargs) if builder else None

mobilus_client/messages/serializer.py

@@ -0,0 +1,20 @@
+import json
+from google.protobuf.json_format import MessageToJson
+from mobilus_client.utils.types import MessageResponse
+
+
+class MessageSerializer:
+    @staticmethod
+    def serialize_to_json(message: MessageResponse) -> str:
+        return MessageToJson(message)
+
+    @staticmethod
+    def serialize_list_to_json(messages: list[MessageResponse]) -> str:
+        return json.dumps(
+            [
+                json.loads(
+                    MessageSerializer.serialize_to_json(message)
+                )
+                for message in messages
+            ]
+        )

mobilus_client/messages/status.py

@@ -0,0 +1,7 @@
+from enum import Enum
+
+
+class MessageStatus(Enum):
+    SUCCESS = 0
+    AUTHENTICATION_ERROR = 1
+    UNKNOWN_MESSAGE = 2

mobilus_client/messages/validator.py

@@ -0,0 +1,16 @@
+from typing import Optional, Union
+from mobilus_client.messages.status import MessageStatus
+from mobilus_client.proto import LoginResponse
+from mobilus_client.utils.types import MessageRequest, MessageResponse
+
+
+class MessageValidator():
+    @staticmethod
+    def validate(message: Optional[Union[MessageRequest, MessageResponse]]) -> MessageStatus:
+        if message is None:
+            return MessageStatus.UNKNOWN_MESSAGE
+
+        if isinstance(message, LoginResponse) and message.login_status == 1:
+            return MessageStatus.AUTHENTICATION_ERROR
+
+        return MessageStatus.SUCCESS

mobilus_client/mqtt_client.py

@@ -0,0 +1,87 @@
+import logging
+import paho.mqtt.client as mqtt
+import threading
+from typing import Any, Dict, cast
+from mobilus_client.messages.encryptor import MessageEncryptor
+from mobilus_client.messages.factory import MessageFactory
+from mobilus_client.messages.status import MessageStatus
+from mobilus_client.messages.validator import MessageValidator
+from mobilus_client.proto import (LoginRequest, LoginResponse)
+from mobilus_client.utils.types import MessageRequest
+
+
+logger = logging.getLogger(__name__)
+
+
+class MqttClient(mqtt.Client):
+    _userdata: Dict[str, Any]
+
+    def __init__(self, *args: Any, **kwargs: Any) -> None:
+        super().__init__(*args, **kwargs)
+        self.authenticated_event = threading.Event()
+        self.completed_event = threading.Event()
+        self.enable_logger(logger)
+
+    def send_request(self, command: str, **params: Any) -> None:
+        if not self.is_connected():
+            logger.error(f"Sending request - {command} failed. Client is not connected.")
+            return
+
+        message = MessageFactory.create_message(command, **params)
+        status = MessageValidator.validate(message)
+
+        if status != MessageStatus.SUCCESS:
+            logger.error(f"Command - {command} returned an error - {status.name}")
+            self.disconnect()
+            return
+
+        if not isinstance(message, LoginRequest):
+            self._userdata['message_registry'].register_request(message)
+
+        encrypted_message = MessageEncryptor.encrypt(
+            cast(MessageRequest, message),
+            self._userdata["config"].client_id,
+            self._userdata['key_registry']
+        )
+
+        self.publish("module", encrypted_message)
+
+    def on_disconnect(self, client: mqtt.Client, userdata: Any, reason_code: Any) -> None:  # type: ignore
+        logger.info(f"Disconnected with result code - {reason_code}")
+
+    def on_connect(self, client: mqtt.Client, userdata: Any, flags: Any, reason_code: Any) -> None:  # type: ignore
+        client.subscribe([
+            (userdata["config"].client_id, 0),
+            ("clients", 0)
+        ])
+
+    def on_subscribe(self, client: mqtt.Client, userdata: Any, mid: Any, granted_qos: Any) -> None:  # type: ignore
+        self.send_request(
+            "login",
+            login=userdata["config"].user_login,
+            password=userdata["config"].user_key
+        )
+
+    def on_message(self, client: mqtt.Client, userdata: Any, message: Any) -> None:  # type: ignore
+        logger.info(f"Received message on topic - {message.topic}")
+
+        message = MessageEncryptor.decrypt(message.payload, userdata["key_registry"])
+        logger.info(f"Decrypted message - {type(message).__name__}")
+
+        status = MessageValidator.validate(message)
+
+        if status != MessageStatus.SUCCESS:
+            logger.error(f"Message - {type(message).__name__} returned an error - {status.name}")
+            self.disconnect()
+            return
+
+        logger.info(f"Message - {type(message).__name__} validated successfully")
+
+        if isinstance(message, LoginResponse):
+            userdata["key_registry"].register_keys(message)
+            self.authenticated_event.set()
+        else:
+            userdata["message_registry"].register_response(message)
+
+            if userdata["message_registry"].all_responses_received():
+                self.completed_event.set()

mobilus_client/proto/__init__.py

@@ -0,0 +1,20 @@
+from mobilus_client.proto.call_events_request_pb2 import CallEventsRequest, CallEvent
+from mobilus_client.proto.current_state_request_pb2 import CurrentStateRequest
+from mobilus_client.proto.current_state_response_pb2 import CurrentStateResponse, CurrentStateEvent
+from mobilus_client.proto.devices_list_request_pb2 import DevicesListRequest
+from mobilus_client.proto.devices_list_response_pb2 import DevicesListResponse, Device
+from mobilus_client.proto.login_request_pb2 import LoginRequest
+from mobilus_client.proto.login_response_pb2 import LoginResponse
+
+__all__ = [
+    "CallEvent",
+    "CallEventsRequest",
+    "CurrentStateRequest",
+    "CurrentStateResponse",
+    "CurrentStateEvent",
+    "Device",
+    "DevicesListRequest",
+    "DevicesListResponse",
+    "LoginRequest",
+    "LoginResponse"
+]

mobilus_client/proto/call_events_request.proto

@@ -0,0 +1,15 @@
+syntax = "proto2";
+
+message CallEvent {
+  optional int64 id = 1;
+  optional int64 device_id = 2;
+  optional int32 event_number = 3;
+  optional string value = 4;
+  optional int32 platform = 5;
+  optional int64 user = 6;
+  optional int64 inserttime = 7;
+}
+
+message CallEventsRequest {
+  repeated CallEvent events = 1;
+}

mobilus_client/proto/call_events_request_pb2.py

@@ -0,0 +1,38 @@
+# -*- coding: utf-8 -*-
+# Generated by the protocol buffer compiler.  DO NOT EDIT!
+# NO CHECKED-IN PROTOBUF GENCODE
+# source: call_events_request.proto
+# Protobuf Python Version: 5.28.1
+"""Generated protocol buffer code."""
+from google.protobuf import descriptor as _descriptor
+from google.protobuf import descriptor_pool as _descriptor_pool
+from google.protobuf import runtime_version as _runtime_version
+from google.protobuf import symbol_database as _symbol_database
+from google.protobuf.internal import builder as _builder
+_runtime_version.ValidateProtobufRuntimeVersion(
+    _runtime_version.Domain.PUBLIC,
+    5,
+    28,
+    1,
+    '',
+    'call_events_request.proto'
+)
+# @@protoc_insertion_point(imports)
+
+_sym_db = _symbol_database.Default()
+
+
+
+
+DESCRIPTOR = _descriptor_pool.Default().AddSerializedFile(b'\n\x19\x63\x61ll_events_request.proto\"\x83\x01\n\tCallEvent\x12\n\n\x02id\x18\x01 \x01(\x03\x12\x11\n\tdevice_id\x18\x02 \x01(\x03\x12\x14\n\x0c\x65vent_number\x18\x03 \x01(\x05\x12\r\n\x05value\x18\x04 \x01(\t\x12\x10\n\x08platform\x18\x05 \x01(\x05\x12\x0c\n\x04user\x18\x06 \x01(\x03\x12\x12\n\ninserttime\x18\x07 \x01(\x03\"/\n\x11\x43\x61llEventsRequest\x12\x1a\n\x06\x65vents\x18\x01 \x03(\x0b\x32\n.CallEvent')
+
+_globals = globals()
+_builder.BuildMessageAndEnumDescriptors(DESCRIPTOR, _globals)
+_builder.BuildTopDescriptorsAndMessages(DESCRIPTOR, 'call_events_request_pb2', _globals)
+if not _descriptor._USE_C_DESCRIPTORS:
+  DESCRIPTOR._loaded_options = None
+  _globals['_CALLEVENT']._serialized_start=30
+  _globals['_CALLEVENT']._serialized_end=161
+  _globals['_CALLEVENTSREQUEST']._serialized_start=163
+  _globals['_CALLEVENTSREQUEST']._serialized_end=210
+# @@protoc_insertion_point(module_scope)

mobilus_client/proto/call_events_request_pb2.pyi

@@ -0,0 +1,63 @@
+"""
+@generated by mypy-protobuf.  Do not edit manually!
+isort:skip_file
+"""
+
+import builtins
+import collections.abc
+import google.protobuf.descriptor
+import google.protobuf.internal.containers
+import google.protobuf.message
+import typing
+
+DESCRIPTOR: google.protobuf.descriptor.FileDescriptor
+
+@typing.final
+class CallEvent(google.protobuf.message.Message):
+    DESCRIPTOR: google.protobuf.descriptor.Descriptor
+
+    ID_FIELD_NUMBER: builtins.int
+    DEVICE_ID_FIELD_NUMBER: builtins.int
+    EVENT_NUMBER_FIELD_NUMBER: builtins.int
+    VALUE_FIELD_NUMBER: builtins.int
+    PLATFORM_FIELD_NUMBER: builtins.int
+    USER_FIELD_NUMBER: builtins.int
+    INSERTTIME_FIELD_NUMBER: builtins.int
+    id: builtins.int
+    device_id: builtins.int
+    event_number: builtins.int
+    value: builtins.str
+    platform: builtins.int
+    user: builtins.int
+    inserttime: builtins.int
+    def __init__(
+        self,
+        *,
+        id: builtins.int | None = ...,
+        device_id: builtins.int | None = ...,
+        event_number: builtins.int | None = ...,
+        value: builtins.str | None = ...,
+        platform: builtins.int | None = ...,
+        user: builtins.int | None = ...,
+        inserttime: builtins.int | None = ...,
+    ) -> None: ...
+    def HasField(self, field_name: typing.Literal["device_id", b"device_id", "event_number", b"event_number", "id", b"id", "inserttime", b"inserttime", "platform", b"platform", "user", b"user", "value", b"value"]) -> builtins.bool: ...
+    def ClearField(self, field_name: typing.Literal["device_id", b"device_id", "event_number", b"event_number", "id", b"id", "inserttime", b"inserttime", "platform", b"platform", "user", b"user", "value", b"value"]) -> None: ...
+
+global___CallEvent = CallEvent
+
+@typing.final
+class CallEventsRequest(google.protobuf.message.Message):
+    DESCRIPTOR: google.protobuf.descriptor.Descriptor
+
+    EVENTS_FIELD_NUMBER: builtins.int
+    @property
+    def events(self) -> google.protobuf.internal.containers.RepeatedCompositeFieldContainer[global___CallEvent]: ...
+    def __init__(
+        self,
+        *,
+        events: collections.abc.Iterable[global___CallEvent] | None = ...,
+    ) -> None: ...
+    def ClearField(self, field_name: typing.Literal["events", b"events"]) -> None: ...
+
+global___CallEventsRequest = CallEventsRequest

mobilus_client/proto/current_state_request.proto

@@ -0,0 +1,4 @@
+syntax = "proto2";
+
+message CurrentStateRequest {
+}

mobilus_client/proto/current_state_request_pb2.py

@@ -0,0 +1,36 @@
+# -*- coding: utf-8 -*-
+# Generated by the protocol buffer compiler.  DO NOT EDIT!
+# NO CHECKED-IN PROTOBUF GENCODE
+# source: current_state_request.proto
+# Protobuf Python Version: 5.28.1
+"""Generated protocol buffer code."""
+from google.protobuf import descriptor as _descriptor
+from google.protobuf import descriptor_pool as _descriptor_pool
+from google.protobuf import runtime_version as _runtime_version
+from google.protobuf import symbol_database as _symbol_database
+from google.protobuf.internal import builder as _builder
+_runtime_version.ValidateProtobufRuntimeVersion(
+    _runtime_version.Domain.PUBLIC,
+    5,
+    28,
+    1,
+    '',
+    'current_state_request.proto'
+)
+# @@protoc_insertion_point(imports)
+
+_sym_db = _symbol_database.Default()
+
+
+
+
+DESCRIPTOR = _descriptor_pool.Default().AddSerializedFile(b'\n\x1b\x63urrent_state_request.proto\"\x15\n\x13\x43urrentStateRequest')
+
+_globals = globals()
+_builder.BuildMessageAndEnumDescriptors(DESCRIPTOR, _globals)
+_builder.BuildTopDescriptorsAndMessages(DESCRIPTOR, 'current_state_request_pb2', _globals)
+if not _descriptor._USE_C_DESCRIPTORS:
+  DESCRIPTOR._loaded_options = None
+  _globals['_CURRENTSTATEREQUEST']._serialized_start=31
+  _globals['_CURRENTSTATEREQUEST']._serialized_end=52
+# @@protoc_insertion_point(module_scope)

mobilus_client/proto/current_state_request_pb2.pyi

@@ -0,0 +1,20 @@
+"""
+@generated by mypy-protobuf.  Do not edit manually!
+isort:skip_file
+"""
+
+import google.protobuf.descriptor
+import google.protobuf.message
+import typing
+
+DESCRIPTOR: google.protobuf.descriptor.FileDescriptor
+
+@typing.final
+class CurrentStateRequest(google.protobuf.message.Message):
+    DESCRIPTOR: google.protobuf.descriptor.Descriptor
+
+    def __init__(
+        self,
+    ) -> None: ...
+
+global___CurrentStateRequest = CurrentStateRequest

mobilus_client/proto/current_state_response.proto

@@ -0,0 +1,15 @@
+syntax = "proto2";
+
+message CurrentStateEvent {
+  optional int64 id = 1;
+  optional int64 device_id = 2;
+  optional int32 event_number = 3;
+  optional string value = 4;
+  optional int32 platform = 5;
+  optional int64 user = 6;
+  optional int64 inserttime = 7;
+}
+
+message CurrentStateResponse {
+  repeated CurrentStateEvent events = 1;
+}