switcher-client 0.1.2__py3-none-any.whl

switcher_client/lib/remote_auth.py

@@ -0,0 +1,74 @@
+from time import time
+from datetime import datetime
+
+from switcher_client.lib.remote import Remote
+from switcher_client.lib.globals.global_context import Context
+from switcher_client.lib.globals import GlobalAuth, RetryOptions
+from switcher_client.lib.utils.date_moment import DateMoment
+
+class RemoteAuth:
+    """
+    RemoteAuth handles authentication with the remote switcher service.
+    It manages the authentication token, checks for token expiration, and handles silent mode token updates.
+    """
+
+    __context: Context = Context.empty()
+    __retry_options: RetryOptions
+
+    @staticmethod
+    def init(context: Context):
+        RemoteAuth.__context = context
+        GlobalAuth.init()
+
+    @staticmethod
+    def set_retry_options(silent_mode: str):
+        RemoteAuth.__retry_options = RetryOptions(
+            retry_time=int(silent_mode[:-1]),
+            retry_duration_in=silent_mode[-1]
+        )
+
+    @staticmethod
+    def auth():
+        token, exp = Remote.auth(RemoteAuth.__context)
+        GlobalAuth.set_token(token)
+        GlobalAuth.set_exp(exp)
+
+    @staticmethod
+    def check_health():
+        if GlobalAuth.get_token() != 'SILENT':
+            return
+
+        if RemoteAuth.is_token_expired():
+            RemoteAuth.update_silent_token()
+            if Remote.check_api_health(RemoteAuth.__context):
+                RemoteAuth.auth()
+
+    @staticmethod
+    def is_token_expired() -> bool:
+        exp = GlobalAuth.get_exp()
+        if exp is None:
+            return True
+
+        return float(exp) < time()
+
+    @staticmethod
+    def update_silent_token():
+        expiration_time = DateMoment(datetime.now()).add(
+            RemoteAuth.__retry_options.retry_time,
+            RemoteAuth.__retry_options.retry_duration_in
+        ).get_date().timestamp()
+
+        GlobalAuth.set_token('SILENT')
+        GlobalAuth.set_exp(str(round(expiration_time)))
+
+    @staticmethod
+    def is_valid():
+        required_fields = [
+            ('url', RemoteAuth.__context.url),
+            ('component', RemoteAuth.__context.component),
+            ('api_key', RemoteAuth.__context.api_key),
+        ]
+
+        errors = [name for name, value in required_fields if not value]
+        if errors:
+            raise ValueError(f"Something went wrong: Missing or empty required fields ({', '.join(errors)})")

switcher_client/lib/resolver.py

@@ -0,0 +1,99 @@
+from typing import Optional
+
+from switcher_client.lib.types import Config, Domain, Entry, Group, ResultDetail, Snapshot, StrategyConfig
+from switcher_client.lib.snapshot import process_operation
+from switcher_client.lib.utils import get, get_entry
+from switcher_client.errors import LocalCriteriaError
+from switcher_client.switcher_data import SwitcherData
+
+# pylint: disable=too-few-public-methods
+class Resolver:
+    """
+    Resolver is responsible for resolving the criteria against the snapshot domain.
+    It provides methods to check the criteria for a given switcher request and return the result.
+    The resolution process involves checking the domain, groups, configs, and strategies in a hierarchical manner,
+    ensuring that all conditions are evaluated correctly to determine the final result.
+    """
+
+    @staticmethod
+    def check_criteria(snapshot: Snapshot | None, switcher: SwitcherData) -> ResultDetail:
+        """ Resolves the criteria for a given switcher request against the snapshot domain. """
+        if not snapshot:
+            raise LocalCriteriaError("Snapshot not loaded. Try to use 'Client.load_snapshot()'")
+
+        return Resolver._check_domain(snapshot.domain, switcher)
+
+    @staticmethod
+    def _check_domain(domain: Domain, switcher: SwitcherData) -> ResultDetail:
+        """ Checks if the domain is activated and proceeds to check groups. """
+        if domain.activated is False:
+            return ResultDetail.disabled("Domain is disabled")
+
+        return Resolver._check_group(domain.group, switcher)
+
+    @staticmethod
+    def _check_group(groups: list[Group], switcher: SwitcherData) -> ResultDetail:
+        """ Finds the correct config in the groups and checks it. """
+        key = switcher.key
+
+        for group in groups:
+            config_found = next((c for c in group.config if c.key == key), None)
+
+            if config_found is not None:
+                if group.activated is False:
+                    return ResultDetail.disabled("Group disabled")
+
+                return Resolver._check_config(config_found, switcher)
+
+        raise LocalCriteriaError(f"Config with key '{key}' not found in the snapshot")
+
+    @staticmethod
+    def _check_config(config: Config, switcher: SwitcherData) -> ResultDetail:
+        """ Checks if the config is activated and proceeds to check strategies. """
+        if config.activated is False:
+            return ResultDetail.disabled("Config disabled")
+
+        if Resolver._has_relay_enabled(config) and switcher.is_restrict_relay():
+            return ResultDetail.disabled("Config has relay enabled")
+
+        if config.strategies is not None and len(config.strategies) > 0:
+            return Resolver._check_strategy(config.strategies, switcher.inputs)
+
+        return ResultDetail.success()
+
+    @staticmethod
+    def _check_strategy(strategy_configs: list[StrategyConfig], inputs: list[list[str]]) -> ResultDetail:
+        """ Checks each strategy configuration against the provided inputs. """
+        entry = get_entry(get(inputs, []))
+
+        for strategy_config in strategy_configs:
+            if not strategy_config.activated:
+                continue
+
+            strategy_result = Resolver._check_strategy_config(strategy_config, entry)
+            if strategy_result is not None:
+                return strategy_result
+
+        return ResultDetail.success()
+
+    @staticmethod
+    def _check_strategy_config(strategy_config: StrategyConfig, entry: list[Entry]) -> Optional[ResultDetail]:
+        """ Checks a single strategy configuration against the provided entries. """
+        if len(entry) == 0:
+            return ResultDetail.disabled(f"Strategy '{strategy_config.strategy}' did not receive any input")
+
+        strategy_entry = [e for e in entry if e.strategy == strategy_config.strategy]
+        if not Resolver._is_strategy_fulfilled(strategy_entry, strategy_config):
+            return ResultDetail.disabled(f"Strategy '{strategy_config.strategy}' does not agree")
+
+        return None
+
+    @staticmethod
+    def _is_strategy_fulfilled(strategy_entry: list[Entry], strategy_config: StrategyConfig) -> bool:
+        """ Determines if the strategy conditions are fulfilled based on the entries and configuration. """
+        return len(strategy_entry) > 0 and process_operation(strategy_config, strategy_entry[0].input) is True
+
+    @staticmethod
+    def _has_relay_enabled(config: Config) -> bool:
+        """ Checks if the config has relay enabled. """
+        return config.relay.activated if config.relay else False

switcher_client/lib/snapshot.py

@@ -0,0 +1,214 @@
+import re
+
+from enum import Enum
+from typing import Optional
+from datetime import datetime
+
+from switcher_client.lib.types import StrategyConfig
+from switcher_client.lib.utils.payload_reader import parse_json, payload_reader
+from switcher_client.lib.utils.ipcidr import IPCIDR
+from switcher_client.lib.utils.timed_match import TimedMatch
+
+class StrategiesType(Enum):
+    """ Enum for strategy types used in criteria evaluation. """
+    VALUE = "VALUE_VALIDATION"
+    NUMERIC = "NUMERIC_VALIDATION"
+    DATE = "DATE_VALIDATION"
+    TIME = "TIME_VALIDATION"
+    PAYLOAD = "PAYLOAD_VALIDATION"
+    NETWORK = "NETWORK_VALIDATION"
+    REGEX = "REGEX_VALIDATION"
+
+class OperationsType(Enum):
+    """ Enum for operation types used in strategy evaluation. """
+    EXIST = "EXIST"
+    NOT_EXIST = "NOT_EXIST"
+    EQUAL = "EQUAL"
+    NOT_EQUAL = "NOT_EQUAL"
+    GREATER = "GREATER"
+    LOWER = "LOWER"
+    BETWEEN = "BETWEEN"
+    HAS_ONE = "HAS_ONE"
+    HAS_ALL = "HAS_ALL"
+
+# pylint: disable=too-many-return-statements
+def process_operation(strategy_config: StrategyConfig, input_value: str) -> Optional[bool]:
+    """Process the operation based on strategy configuration and input value."""
+
+    strategy = strategy_config.strategy
+    operation = strategy_config.operation
+    values = strategy_config.values
+
+    match strategy:
+        case StrategiesType.VALUE.value:
+            return _process_value(operation, values, input_value)
+        case StrategiesType.NUMERIC.value:
+            return _process_numeric(operation, values, input_value)
+        case StrategiesType.DATE.value:
+            return _process_date(operation, values, input_value)
+        case StrategiesType.TIME.value:
+            return _process_time(operation, values, input_value)
+        case StrategiesType.PAYLOAD.value:
+            return _process_payload(operation, values, input_value)
+        case StrategiesType.NETWORK.value:
+            return _process_network(operation, values, input_value)
+        case StrategiesType.REGEX.value:
+            return _process_regex(operation, values, input_value)
+
+def _process_value(operation: str, values: list, input_value: str) -> Optional[bool]:
+    """ Process VALUE strategy operations."""
+
+    match operation:
+        case OperationsType.EXIST.value:
+            return input_value in values
+        case OperationsType.NOT_EXIST.value:
+            return input_value not in values
+        case OperationsType.EQUAL.value:
+            return input_value in values
+        case OperationsType.NOT_EQUAL.value:
+            return input_value not in values
+
+# pylint: disable=too-many-return-statements
+def _process_numeric(operation: str, values: list, input_value: str) -> Optional[bool]:
+    """ Process NUMERIC strategy operations."""
+
+    try:
+        numeric_input = float(input_value)
+    except ValueError:
+        return None
+
+    numeric_values = [float(v) for v in values]
+
+    match operation:
+        case OperationsType.EXIST.value:
+            return numeric_input in numeric_values
+        case OperationsType.NOT_EXIST.value:
+            return numeric_input not in numeric_values
+        case OperationsType.EQUAL.value:
+            return numeric_input in numeric_values
+        case OperationsType.NOT_EQUAL.value:
+            return numeric_input not in numeric_values
+        case OperationsType.GREATER.value:
+            return any(numeric_input > v for v in numeric_values)
+        case OperationsType.LOWER.value:
+            return any(numeric_input < v for v in numeric_values)
+        case OperationsType.BETWEEN.value:
+            return numeric_values[0] <= numeric_input <= numeric_values[1]
+
+def _process_date(operation: str, values: list, input_value: str) -> Optional[bool]:
+    """ Process DATE strategy operations."""
+
+    try:
+        date_input = _parse_datetime(input_value)
+        date_values = [_parse_datetime(v) for v in values]
+    except ValueError:
+        return None
+
+    match operation:
+        case OperationsType.LOWER.value:
+            return any(date_input <= v for v in date_values)
+        case OperationsType.GREATER.value:
+            return any(date_input >= v for v in date_values)
+        case OperationsType.BETWEEN.value:
+            return date_values[0] <= date_input <= date_values[1]
+
+def _process_time(operation: str, values: list, input_value: str) -> Optional[bool]:
+    """ Process TIME strategy operations."""
+
+    try:
+        time_input = datetime.strptime(input_value, '%H:%M').time()
+        time_values = [datetime.strptime(v, '%H:%M').time() for v in values]
+    except ValueError:
+        return None
+
+    match operation:
+        case OperationsType.LOWER.value:
+            return any(time_input <= v for v in time_values)
+        case OperationsType.GREATER.value:
+            return any(time_input >= v for v in time_values)
+        case OperationsType.BETWEEN.value:
+            return time_values[0] <= time_input <= time_values[1]
+
+def _process_payload(operation: str, values: list, input_value: str) -> Optional[bool]:
+    """ Process PAYLOAD strategy operations."""
+
+    input_json = parse_json(input_value)
+    if input_json is None:
+        return False
+
+    keys = payload_reader(input_json)
+
+    match operation:
+        case OperationsType.HAS_ONE.value:
+            return any(value in keys for value in values)
+        case OperationsType.HAS_ALL.value:
+            return all(value in keys for value in values)
+
+def _process_network(operation: str, values: list, input_value: str) -> Optional[bool]:
+    """Process NETWORK strategy operations."""
+
+    cidr_regex = re.compile(r'^(\d{1,3}\.){3}\d{1,3}(\/(\d|[1-2]\d|3[0-2]))$')
+
+    match operation:
+        case OperationsType.EXIST.value:
+            return _process_network_exist(input_value, values, cidr_regex)
+        case OperationsType.NOT_EXIST.value:
+            return _process_network_not_exist(input_value, values, cidr_regex)
+
+    return False
+
+def _process_network_exist(input_value: str, values: list, cidr_regex) -> bool:
+    """Check if input IP exists in any of the network ranges/IPs."""
+
+    for value in values:
+        if cidr_regex.match(value):
+            cidr = IPCIDR(value)
+            if cidr.is_ip4_in_cidr(input_value):
+                return True
+        else:
+            if input_value in values:
+                return True
+
+    return False
+
+def _process_network_not_exist(input_value: str, values: list, cidr_regex) -> bool:
+    """Check if input IP does not exist in any of the network ranges/IPs."""
+
+    result = []
+    for element in values:
+        if cidr_regex.match(element):
+            cidr = IPCIDR(element)
+            if cidr.is_ip4_in_cidr(input_value):
+                result.append(element)
+        else:
+            if input_value in values:
+                result.append(element)
+
+    return len(result) == 0
+
+def _process_regex(operation: str, values: list, input_value: str) -> Optional[bool]:
+    """ Process REGEX strategy operations with timeout protection."""
+
+    match operation:
+        case OperationsType.EXIST.value:
+            return TimedMatch.try_match(values, input_value, use_fullmatch=False)
+        case OperationsType.NOT_EXIST.value:
+            result = TimedMatch.try_match(values, input_value, use_fullmatch=False)
+            return not result
+        case OperationsType.EQUAL.value:
+            return TimedMatch.try_match(values, input_value, use_fullmatch=True)
+        case OperationsType.NOT_EQUAL.value:
+            result = TimedMatch.try_match(values, input_value, use_fullmatch=True)
+            return not result
+
+def _parse_datetime(date_str: str):
+    """Parse datetime string that can be either date-only or datetime format."""
+
+    formats = ['%Y-%m-%dT%H:%M', '%Y-%m-%d']
+    for fmt in formats:
+        try:
+            return datetime.strptime(date_str, fmt)
+        except ValueError:
+            continue
+
+    raise ValueError(f"Unable to parse date: {date_str}")

switcher_client/lib/snapshot_auto_updater.py

@@ -0,0 +1,63 @@
+import threading
+import time
+
+from typing import Callable, Optional
+
+class SnapshotAutoUpdater:
+    """ Schedules periodic snapshot updates in a background thread """
+
+    def __init__(self):
+        self._timer_thread: Optional[threading.Thread] = None
+        self._stop_event: Optional[threading.Event] = None
+
+    def schedule(
+            self, interval: int,
+            check_snapshot: Callable[[], bool],
+            callback: Callable[[Optional[Exception], bool], None]) -> None:
+        """
+        Schedule periodic snapshot updates in a background thread.
+
+        :param interval: Update interval in seconds
+        :param check_snapshot: Function that checks and updates snapshot, returns True if updated
+        :param callback: Callback function called with (error, updated) after each check
+        """
+
+        self.terminate()
+        self._stop_event = threading.Event()
+
+        self._timer_thread = threading.Thread(
+            target=self._update_worker,
+            args=(interval, check_snapshot, callback),
+            daemon=True,
+            name="SnapshotAutoUpdater"
+        )
+        self._timer_thread.start()
+
+    def terminate(self) -> None:
+        """
+        Terminate the scheduled snapshot auto-update thread gracefully.
+        """
+        if self._stop_event is not None:
+            self._stop_event.set()
+
+        if self._timer_thread is not None and self._timer_thread.is_alive():
+            self._timer_thread.join(timeout=5.0)
+
+        self._timer_thread = None
+        self._stop_event = None
+
+    def _update_worker(
+            self, interval: int,
+            check_snapshot: Callable[[], bool],
+            callback: Callable[[Optional[Exception], bool], None]) -> None:
+        stop_event = self._stop_event
+
+        time.sleep(interval) # delay start
+        while stop_event is not None and not stop_event.is_set():
+            try:
+                updated = check_snapshot()
+                callback(None, updated)
+            except Exception as error:  # pylint: disable=broad-exception-caught
+                callback(error, False)
+
+            stop_event.wait(interval)

switcher_client/lib/snapshot_loader.py

@@ -0,0 +1,77 @@
+import json
+import os
+
+from switcher_client.lib.globals.global_auth import GlobalAuth
+from switcher_client.lib.globals.global_context import Context
+from switcher_client.lib.remote import Remote
+from switcher_client.lib.types import Snapshot
+from switcher_client.errors import LocalSwitcherError
+
+def load_domain(snapshot_location: str, environment: str):
+    """ Load Domain from snapshot file """
+
+    snapshot_file = f"{snapshot_location}/{environment}.json"
+    json_data = {}
+
+    if not os.path.exists(snapshot_file):
+        json_data = {
+            'domain': {
+                'version': 0,
+            }
+        }
+
+        if snapshot_location:
+            os.makedirs(snapshot_location, exist_ok=True)
+            with open(snapshot_file, 'w', encoding='utf-8') as file:
+                json.dump(json_data, file, indent=4)
+
+    elif os.path.exists(snapshot_file):
+        with open(snapshot_file, 'r', encoding='utf-8') as file:
+            json_data = json.load(file)
+
+    snapshot = Snapshot(json_data.get('domain', {}))
+
+    return snapshot
+
+def validate_snapshot(
+    context: Context,
+    snapshot_version: int
+) -> Snapshot | None:
+    """ Validate the snapshot data """
+
+    status = Remote.check_snapshot_version(
+        token=GlobalAuth.get_token(),
+        context=context,
+        snapshot_version=snapshot_version)
+
+    if not status:
+        snapshot_str = Remote.resolve_snapshot(GlobalAuth.get_token(), context)
+        graphql_response = json.loads(snapshot_str or '{}')
+        return Snapshot(graphql_response.get('domain', '{}'))
+
+    return None
+
+def save_snapshot(snapshot: Snapshot, snapshot_location: str, environment: str):
+    """ Save snapshot to file """
+
+    os.makedirs(snapshot_location, exist_ok=True)
+    snapshot_file = f"{snapshot_location}/{environment}.json"
+    with open(snapshot_file, 'w', encoding='utf-8') as file:
+        json.dump(snapshot.to_dict(), file, indent=4)
+
+def check_switchers(snapshot: Snapshot | None, switcher_keys: list[str]) -> None:
+    """ Check if switchers are properly configured in snapshot """
+    groups = getattr(snapshot.domain, 'group', []) if snapshot else []
+    not_found = []
+
+    for switcher in switcher_keys:
+        found = False
+        for group in groups:
+            if any(c.key == switcher for c in getattr(group, 'config', [])):
+                found = True
+                break
+        if not found:
+            not_found.append(switcher)
+
+    if not_found:
+        raise LocalSwitcherError(not_found)

switcher_client/lib/snapshot_watcher.py

@@ -0,0 +1,67 @@
+import os
+import threading
+
+from dataclasses import dataclass, field
+from typing import Callable
+
+from switcher_client.lib.snapshot_loader import load_domain
+from switcher_client.lib.globals.global_snapshot import GlobalSnapshot
+
+_POLL_INTERVAL = 1  # seconds between file stat checks
+
+@dataclass
+class WatchSnapshotCallback:
+    """ Typed callback contract for Client.watch_snapshot """
+    success: Callable[[], None] = field(default_factory=lambda: (lambda: None))
+    reject: Callable[[Exception], None] = field(default_factory=lambda: (lambda _: None))
+
+class SnapshotWatcher:
+    """ Watches the snapshot file for changes and updates the switcher accordingly """
+
+    def __init__(self):
+        self._stop_event: threading.Event = threading.Event()
+        self._ready_event: threading.Event = threading.Event()
+        self._thread: threading.Thread | None = None
+
+    def watch_snapshot(self, snapshot_location: str, environment: str, callback: WatchSnapshotCallback) -> None:
+        """ Watch snapshot file for changes and invoke callbacks on result """
+        self._stop_event.clear()
+        self._ready_event.clear()
+        self._thread = threading.Thread(
+            target=self._watch,
+            args=(snapshot_location, environment, callback),
+            daemon=True,
+            name="SnapshotWatcher"
+        )
+        self._thread.start()
+        self._ready_event.wait()
+
+    def unwatch_snapshot(self) -> None:
+        """ Stop watching the snapshot file """
+        self._stop_event.set()
+        if self._thread is not None:
+            self._thread.join(timeout=5.0)
+            self._thread = None
+
+    def _watch(self, snapshot_location: str, environment: str, callback: WatchSnapshotCallback) -> None:
+        snapshot_file = f"{snapshot_location}/{environment}.json"
+        last_mtime = self._get_mtime(snapshot_file)
+        self._ready_event.set()
+
+        while not self._stop_event.is_set():
+            self._stop_event.wait(_POLL_INTERVAL)
+            current_mtime = self._get_mtime(snapshot_file)
+            if current_mtime != last_mtime:
+                last_mtime = current_mtime
+                self._on_modify_snapshot(snapshot_location, environment, callback)
+
+    def _get_mtime(self, snapshot_file: str) -> float:
+        return os.stat(snapshot_file).st_mtime
+
+    def _on_modify_snapshot(self, snapshot_location: str, environment: str, callback: WatchSnapshotCallback) -> None:
+        try:
+            snapshot = load_domain(snapshot_location, environment)
+            GlobalSnapshot.init(snapshot)
+            callback.success()
+        except Exception as error:  # pylint: disable=broad-exception-caught
+            callback.reject(error)