switcher-client 0.1.2__py3-none-any.whl

switcher_client/lib/types.py

@@ -0,0 +1,169 @@
+from dataclasses import dataclass
+from typing import Optional
+
+class ResultDetail:
+    """
+    ResultDetail holds the result of a criteria check, including the boolean result,
+    reason for the result, and any additional metadata.
+    It provides static methods to create instances for success, disabled, or custom results.
+    """
+    def __init__(self, result: bool, reason: Optional[str], metadata: Optional[dict] = None):
+        self.result = result
+        self.reason = reason
+        self.metadata = metadata
+
+    @staticmethod
+    def create(result: bool, reason: Optional[str], metadata: Optional[dict] = None) -> 'ResultDetail':
+        return ResultDetail(result=result, reason=reason, metadata=metadata)
+
+    @staticmethod
+    def disabled(reason: str, metadata: Optional[dict] = None) -> 'ResultDetail':
+        return ResultDetail(result=False, reason=reason, metadata=metadata)
+
+    @staticmethod
+    def success(reason: str = "Success", metadata: Optional[dict] = None) -> 'ResultDetail':
+        return ResultDetail(result=True, reason=reason, metadata=metadata)
+
+    def to_dict(self) -> dict:
+        return {
+            'result': self.result,
+            'reason': self.reason,
+            'metadata': self.metadata
+        }
+
+@dataclass
+class Domain:
+    """ Domain represents the top-level structure of the snapshot, containing groups and their configurations. """
+    def __init__(self):
+        self.name: str
+        self.version: int = 0
+        self.activated: bool
+        self.group: list[Group]
+
+@dataclass
+class Group:
+    """ Group represents a collection of configurations within a domain. """
+    def __init__(self):
+        self.name: str
+        self.activated: bool
+        self.config: list[Config]
+
+@dataclass
+class Config:
+    """ Config represents a specific configuration within a group. """
+    def __init__(self):
+        self.key: str
+        self.activated: bool
+        self.strategies: Optional[list[StrategyConfig]] = None
+        self.relay: Optional[Relay] = None
+
+@dataclass
+class StrategyConfig:
+    """ StrategyConfig represents a specific strategy within a configuration. """
+    def __init__(self):
+        self.strategy: str
+        self.activated: bool
+        self.operation: str
+        self.values: list[str]
+
+@dataclass
+class Entry:
+    """ Entry represents an input entry for strategy evaluation, containing the strategy type and input value. """
+    # pylint: disable=redefined-builtin
+    def __init__(self, strategy: str, input: str):
+        self.strategy = strategy
+        self.input = input
+
+    def to_dict(self) -> dict:
+        return {
+            'strategy': self.strategy,
+            'input': self.input
+        }
+
+@dataclass
+class Relay:
+    """ Relay represents a relay configuration within a configuration. """
+    def __init__(self):
+        self.type: str
+        self.activated: bool
+
+@dataclass
+class Snapshot:
+    """
+    Snapshot represents the entire snapshot data structure,
+    including the domain and its nested groups and configurations.
+    """
+    def __init__(self, json_data: dict):
+        self._original_data = json_data
+        self.domain = self._parse_domain(json_data)
+
+    def _parse_domain(self, domain_data: dict) -> Domain:
+        """ Parse domain data from JSON """
+
+        domain = Domain()
+        domain.name = domain_data.get('name', '')
+        domain.activated = domain_data.get('activated', False)
+        domain.version = domain_data.get('version', 0)
+
+        if 'group' in domain_data and domain_data['group']:
+            domain.group = []
+            for group_data in domain_data['group']:
+                domain.group.append(self._parse_group(group_data))
+
+        return domain
+
+    def _parse_group(self, group_data: dict) -> Group:
+        """ Parse group data from JSON """
+
+        group = Group()
+        group.name = group_data.get('name', '')
+        group.activated = group_data.get('activated', False)
+
+        if 'config' in group_data and group_data['config']:
+            group.config = []
+            for config_data in group_data['config']:
+                group.config.append(self._parse_config(config_data))
+
+        return group
+
+    def _parse_config(self, config_data: dict) -> Config:
+        """ Parse config data from JSON """
+
+        config = Config()
+        config.key = config_data.get('key', '')
+        config.activated = config_data.get('activated', False)
+
+        if 'strategies' in config_data and config_data['strategies']:
+            config.strategies = []
+            for strategy_data in config_data['strategies']:
+                config.strategies.append(self._parse_strategy(strategy_data))
+
+        if 'relay' in config_data and config_data['relay']:
+            config.relay = self._parse_relay(config_data['relay'])
+
+        return config
+
+    def _parse_strategy(self, strategy_data: dict) -> StrategyConfig:
+        """ Parse strategy data from JSON """
+
+        strategy = StrategyConfig()
+        strategy.strategy = strategy_data.get('strategy', '')
+        strategy.activated = strategy_data.get('activated', False)
+        strategy.operation = strategy_data.get('operation', '')
+        strategy.values = strategy_data.get('values', [])
+
+        return strategy
+
+    def _parse_relay(self, relay_data: dict) -> Relay:
+        """ Parse relay data from JSON """
+
+        relay = Relay()
+        relay.type = relay_data.get('type', '')
+        relay.activated = relay_data.get('activated', False)
+
+        return relay
+
+    def to_dict(self) -> dict:
+        """ Convert Snapshot back to dictionary format for JSON serialization """
+
+        return {'domain': self._original_data}

switcher_client/lib/utils/__init__.py

@@ -0,0 +1,21 @@
+from switcher_client.lib.types import Entry
+from switcher_client.lib.utils.execution_logger import ExecutionLogger
+
+def get(value, default_value):
+    """ Return value if not None, otherwise return default_value """
+    return value if value is not None else default_value
+
+# pylint: disable=redefined-builtin
+def get_entry(input: list) -> list[Entry]:
+    """ Prepare entry dictionary from input strategy handling """
+    entry: list[Entry] = []
+    for strategy_type, input_value in input:
+        entry.append(Entry(strategy_type, input_value))
+
+    return entry
+
+__all__ = [
+    'ExecutionLogger',
+    'get_entry',
+    'get',
+]

switcher_client/lib/utils/date_moment.py

@@ -0,0 +1,26 @@
+from datetime import datetime, timedelta
+
+class DateMoment:
+    """
+    A utility class for date and time manipulation, similar to moment.js functionality.
+    """
+
+    def __init__(self, date: datetime):
+        self.date = date
+
+    def get_date(self) -> datetime:
+        return self.date
+
+    def add(self, amount: int, unit: str) -> 'DateMoment':
+        unit_lower = unit.lower()
+
+        if unit_lower == 's':
+            self.date += timedelta(seconds=amount)
+        elif unit_lower == 'm':
+            self.date += timedelta(minutes=amount)
+        elif unit_lower == 'h':
+            self.date += timedelta(hours=amount)
+        else:
+            raise ValueError(f"Unit {unit} not compatible - try [s, m or h]")
+
+        return self

switcher_client/lib/utils/execution_logger.py

@@ -0,0 +1,96 @@
+# pylint: disable=redefined-builtin
+from typing import Optional, Callable, List
+
+from switcher_client.lib.types import ResultDetail
+
+# Global logger storage
+_logger: List['ExecutionLogger'] = []
+
+class ExecutionLogger:
+    """It keeps track of latest execution results."""
+
+    _callback_error: Optional[Callable[[Exception], None]] = None
+
+    def __init__(self):
+        self.key: Optional[str] = None
+        self.input: Optional[List[List[str]]] = None
+        self.response: ResultDetail = ResultDetail(result=False, reason=None, metadata=None)
+
+    @staticmethod
+    def add(response: ResultDetail, key: str, input: Optional[List[List[str]]] = None) -> None:
+        """Add new execution result"""
+        # Remove existing execution with same key and input
+        for index, log in enumerate(_logger):
+            if ExecutionLogger._has_execution(log, key, input):
+                _logger.pop(index)
+                break
+
+        # Create new execution log entry
+        new_log = ExecutionLogger()
+        new_log.key = key
+        new_log.input = input
+        new_log.response = ResultDetail(
+            result=response.result,
+            reason=response.reason,
+            metadata={**(response.metadata or {}), 'cached': True}
+        )
+
+        _logger.append(new_log)
+
+    @staticmethod
+    def get_execution(key: str, input: Optional[List[List[str]]] = None) -> 'ExecutionLogger':
+        """Retrieve a specific result given a key and an input"""
+        for log in _logger:
+            if ExecutionLogger._has_execution(log, key, input):
+                return log
+
+        return ExecutionLogger()
+
+    @staticmethod
+    def get_by_key(key: str) -> List['ExecutionLogger']:
+        """Retrieve results given a switcher key"""
+        return [log for log in _logger if log.key == key]
+
+    @staticmethod
+    def clear_logger() -> None:
+        """Clear all results"""
+        _logger.clear()
+
+    @classmethod
+    def callback_error(cls) -> Optional[Callable[[Exception], None]]:
+        """Returns the subscribed error callback."""
+        return cls._callback_error
+
+    @staticmethod
+    def subscribe_notify_error(callback: Callable[[Exception], None]) -> None:
+        """Subscribe to notify when an asynchronous error is thrown."""
+        ExecutionLogger._callback_error = callback
+
+    @staticmethod
+    def _has_execution(log: 'ExecutionLogger', key: str, input: Optional[List[List[str]]]) -> bool:
+        """Check if log matches the given key and input"""
+        return log.key == key and ExecutionLogger._check_strategy_inputs(log.input, input)
+
+    @staticmethod
+    def _check_strategy_inputs(logger_inputs: Optional[List[List[str]]], inputs: Optional[List[List[str]]]) -> bool:
+        """Check if strategy inputs match between logger and current inputs"""
+        if not logger_inputs:
+            return not inputs or len(inputs) == 0
+
+        if not inputs:
+            return False
+
+        for strategy_input in logger_inputs:
+            if len(strategy_input) >= 2:
+                strategy, input_value = strategy_input[0], strategy_input[1]
+                # Find matching strategy and input in current inputs
+                found = any(
+                    len(current_input) >= 2 and
+                    current_input[0] == strategy and
+                    current_input[1] == input_value
+                    for current_input in inputs
+                )
+                if not found:
+                    return False
+
+        return True

switcher_client/lib/utils/ipcidr.py

@@ -0,0 +1,46 @@
+# pylint: disable=too-few-public-methods
+class IPCIDR:
+    """Class for checking if an IP address is within a CIDR range."""
+
+    def __init__(self, cidr: str) -> None:
+        """
+        Initialize IPCIDR with a CIDR string.
+
+        Args:
+            cidr: CIDR notation string (e.g., '192.168.1.0/24')
+        """
+        self.cidr = cidr
+
+    def _ip4_to_int(self, ip: str) -> int:
+        """
+        Convert an IPv4 address string to a 32-bit integer.
+
+        Args:
+            ip: IPv4 address string (e.g., '192.168.1.1')
+
+        Returns:
+            32-bit integer representation of the IP address
+        """
+        octets = ip.split('.')
+        result = 0
+        for octet in octets:
+            result = (result << 8) + int(octet)
+        return result & 0xFFFFFFFF  # Ensure 32-bit unsigned integer
+
+    def is_ip4_in_cidr(self, ip: str) -> bool:
+        """
+        Check if an IPv4 address is within the CIDR range.
+
+        Args:
+            ip: IPv4 address string to check
+
+        Returns:
+            True if the IP is within the CIDR range, False otherwise
+        """
+        cidr_parts = self.cidr.split('/')
+        range_ip = cidr_parts[0]
+        bits = int(cidr_parts[1]) if len(cidr_parts) > 1 else 32
+
+        mask = ~(2 ** (32 - bits) - 1) & 0xFFFFFFFF
+
+        return (self._ip4_to_int(ip) & mask) == (self._ip4_to_int(range_ip) & mask)

switcher_client/lib/utils/payload_reader.py

@@ -0,0 +1,43 @@
+import json
+
+from typing import Any, List, Union
+
+def payload_reader(payload: Any) -> List[str]:
+    """Extract all field keys from a JSON payload structure.
+
+    This function recursively traverses a JSON structure
+    and returns all possible field paths in dot notation.
+    """
+    # Handle string payload - if it's a string, try to parse it as JSON
+    if isinstance(payload, str):
+        parsed = parse_json(payload)
+        if parsed is not None:
+            payload = parsed
+
+    # If payload is a list/array, recursively process each element
+    if isinstance(payload, list):
+        result = []
+        for item in payload:
+            result.extend(payload_reader(item))
+        return result
+
+    # If payload is not a dict, return empty list (primitive values don't have keys)
+    if not isinstance(payload, dict):
+        return []
+
+    # Process dictionary keys
+    result = []
+
+    for field in payload.keys():
+        result.append(field)
+        nested_fields = payload_reader(payload[field])
+        for nested_field in nested_fields:
+            result.append(f"{field}.{nested_field}")
+
+    return result
+
+def parse_json(json_str: str) -> Union[Any, None]:
+    try:
+        return json.loads(json_str)
+    except (json.JSONDecodeError, TypeError):
+        return None

switcher_client/lib/utils/timed_match/__init__.py

@@ -0,0 +1,3 @@
+from .timed_match import TimedMatch
+
+__all__ = ['TimedMatch']

switcher_client/lib/utils/timed_match/timed_match.py

@@ -0,0 +1,246 @@
+import multiprocessing
+import time
+
+from typing import List, Optional, Any
+from dataclasses import dataclass
+
+from switcher_client.lib.globals.global_context import DEFAULT_REGEX_MAX_BLACKLISTED, DEFAULT_REGEX_MAX_TIME_LIMIT
+from switcher_client.lib.utils.timed_match.worker import TaskType, WorkerResult, WorkerTask, persistent_regex_worker
+
+@dataclass
+class Blacklist:
+    """Represents a blacklisted regex pattern and input combination."""
+    patterns: List[str]
+    input_value: str
+
+class TimedMatch:
+    """
+    This class provides regex match operations with timeout-based ReDoS protection.
+
+    Operations are executed in isolated processes with configurable timeouts.
+    Processes that exceed the timeout are terminated, preventing ReDoS attacks.
+    Failed operations are cached in a blacklist to avoid repeated resource usage.
+    """
+
+    _blacklisted: List[Blacklist] = []
+    _max_blacklisted: int = DEFAULT_REGEX_MAX_BLACKLISTED
+    _max_time_limit: float = DEFAULT_REGEX_MAX_TIME_LIMIT / 1000.0  # Convert to seconds
+
+    # Persistent worker management
+    _worker_process: Optional[multiprocessing.Process] = None
+    _task_queue: Optional[multiprocessing.Queue] = None
+    _result_queue: Optional[multiprocessing.Queue] = None
+    _worker_ctx: Optional[Any] = None
+    _task_counter: int = 0
+    _worker_needs_restart: bool = False
+    _old_workers_to_cleanup: List[multiprocessing.Process] = []
+
+    @classmethod
+    def initialize_worker(cls) -> bool:
+        """
+        Initialize the persistent worker process for regex matching.
+
+        Creates a new worker process with communication queues. If a worker
+        already exists, it will be terminated before creating a new one.
+
+        Returns:
+            True if worker was successfully initialized, False otherwise
+        """
+        # Terminate existing worker if any
+        cls.terminate_worker()
+
+        # Create multiprocessing context
+        cls._worker_ctx = multiprocessing.get_context('spawn')
+
+        # Create communication queues
+        cls._task_queue = cls._worker_ctx.Queue()
+        cls._result_queue = cls._worker_ctx.Queue()
+
+        # Create and start worker process
+        cls._worker_process = cls._worker_ctx.Process(
+            target=persistent_regex_worker,
+            args=(cls._task_queue, cls._result_queue)
+        )
+        if cls._worker_process:
+            cls._worker_process.start()
+
+        # Reset task counter
+        cls._task_counter = 0
+
+        return cls._worker_process is not None and cls._worker_process.is_alive()
+
+    @classmethod
+    def terminate_worker(cls) -> None:
+        """
+        Terminate all worker processes (current and old ones).
+
+        Sends a shutdown signal to workers and forcefully terminates them if needed.
+        Cleans up all worker-related resources.
+        """
+        try:
+            # Terminate current worker
+            if cls._worker_process and cls._worker_process.is_alive():
+                cls._graceful_shutdown()
+
+            # Terminate all old workers waiting for cleanup
+            cls._terminate_all_old_workers()
+        finally:
+            cls._cleanup_resources()
+
+    @classmethod
+    def _graceful_shutdown(cls) -> None:
+        """Attempt graceful shutdown of worker process."""
+        if cls._task_queue:
+            shutdown_task = WorkerTask(
+                task_type=TaskType.SHUTDOWN,
+                task_id=f"shutdown_{time.time()}"
+            )
+            cls._task_queue.put(shutdown_task, timeout=1.0)
+            if cls._worker_process:
+                cls._worker_process.join(timeout=2.0)
+
+    @classmethod
+    def _cleanup_resources(cls) -> None:
+        """Clean up all worker-related resources."""
+        cls._worker_process = None
+        cls._task_queue = None
+        cls._result_queue = None
+        cls._worker_ctx = None
+        cls._task_counter = 0
+        cls._worker_needs_restart = False
+        cls._old_workers_to_cleanup.clear()
+
+    @classmethod
+    def try_match(cls, patterns: List[str], input_value: str, use_fullmatch: bool = False) -> bool:
+        """
+        Executes regex matching operation with timeout protection.
+
+        The operation runs in an isolated process with timeout protection to prevent
+        runaway regex operations that could lead to ReDoS attacks.
+
+        Failed operations (timeouts, errors) are automatically added to a blacklist
+        to prevent repeated attempts with the same problematic patterns.
+
+        Args:
+            patterns: Array of regular expression patterns to test against the input
+            input_value: The input string to match against the regex patterns
+            use_fullmatch: If True, uses re.fullmatch; if False, uses re.search
+
+        Returns:
+            True if any of the regex patterns match the input, false otherwise
+        """
+        if cls._is_blacklisted(patterns, input_value):
+            return False
+
+        return cls._safe_match(patterns, input_value, use_fullmatch)
+
+    @classmethod
+    def _safe_match(cls, patterns: List[str], input_value: str, use_fullmatch: bool) -> bool:
+        """ Run regex match with timeout protection using persistent worker."""
+        task_id = cls._create_and_send_task(patterns, input_value, use_fullmatch)
+        return cls._wait_for_result(task_id, patterns, input_value)
+
+    @classmethod
+    def _create_and_send_task(cls, patterns: List[str], input_value: str, use_fullmatch: bool) -> str:
+        """Create task and send to worker."""
+        cls._task_counter += 1
+        task_id = f"task_{cls._task_counter}_{time.time()}"
+
+        task = WorkerTask(
+            task_type=TaskType.MATCH,
+            patterns=patterns,
+            input_value=input_value,
+            use_fullmatch=use_fullmatch,
+            task_id=task_id
+        )
+
+        if cls._task_queue:
+            cls._task_queue.put(task, timeout=1.0)
+        return task_id
+
+    @classmethod
+    def _wait_for_result(cls, task_id: str, patterns: List[str], input_value: str) -> bool:
+        """Wait for result from worker with timeout."""
+        start_time = time.time()
+        while time.time() - start_time < cls._max_time_limit:
+            try:
+                if cls._result_queue:
+                    result = cls._result_queue.get(timeout=0.1)
+                    if result.task_id == task_id:
+                        return cls._process_worker_result(result, patterns, input_value)
+            except Exception:  # pylint: disable=broad-exception-caught
+                continue
+
+        # Timeout occurred - start new worker immediately and defer cleanup of old one
+        cls._replace_worker_immediately()
+        cls._add_to_blacklist(patterns, input_value)
+        return False
+
+    @classmethod
+    def _process_worker_result(cls, result: WorkerResult, patterns: List[str], input_value: str) -> bool:
+        """Process result from worker."""
+        if result.success:
+            return result.result if result.result is not None else False
+        cls._add_to_blacklist(patterns, input_value)
+        return False
+
+    @classmethod
+    def _is_blacklisted(cls, patterns: List[str], input_value: str) -> bool:
+        for blacklisted in cls._blacklisted:
+            # Check if input can contain same segment that could fail matching
+            if blacklisted.input_value in input_value or input_value in blacklisted.input_value:
+                # Check if any of the patterns match (regex order should not affect)
+                matching_patterns = [p for p in patterns if p in blacklisted.patterns]
+                if matching_patterns:
+                    return True
+        return False
+
+    @classmethod
+    def _add_to_blacklist(cls, patterns: List[str], input_value: str) -> None:
+        # Maintain blacklist size limit
+        if len(cls._blacklisted) >= cls._max_blacklisted:
+            cls._blacklisted.pop(0)  # Remove oldest entry
+
+        cls._blacklisted.append(Blacklist(
+            patterns=patterns.copy(),
+            input_value=input_value
+        ))
+
+    @classmethod
+    def _replace_worker_immediately(cls) -> None:
+        """Replace worker immediately without waiting for cleanup."""
+        # Move current worker to cleanup list if it exists
+        if cls._worker_process:
+            cls._old_workers_to_cleanup.append(cls._worker_process)
+
+        # Clear current worker references (but don't cleanup yet)
+        cls._worker_process = None
+        cls._task_queue = None
+        cls._result_queue = None
+        cls._worker_ctx = None
+        cls._task_counter = 0
+
+        # Initialize new worker immediately
+        cls.initialize_worker()
+
+    @classmethod
+    def _terminate_all_old_workers(cls) -> None:
+        """Forcefully terminate all old workers synchronously."""
+        for worker in cls._old_workers_to_cleanup[:]:
+            if worker and worker.is_alive():
+                worker.terminate()
+                worker.join(timeout=1.0)
+
+        cls._old_workers_to_cleanup.clear()
+
+    @classmethod
+    def clear_blacklist(cls) -> None:
+        cls._blacklisted.clear()
+
+    @classmethod
+    def set_max_blacklisted(cls, value: int) -> None:
+        cls._max_blacklisted = value
+
+    @classmethod
+    def set_max_time_limit(cls, value: int) -> None:
+        cls._max_time_limit = value / 1000.0  # Convert to seconds