openfeature-provider-flagd 0.1.4__py3-none-any.whl → 0.2.0__py3-none-any.whl

openfeature/.gitignore

@@ -0,0 +1,2 @@
+
+schemas

openfeature/contrib/provider/flagd/config.py

@@ -1,5 +1,53 @@
+import dataclasses
 import os
 import typing
+from enum import Enum
+
+
+class ResolverType(Enum):
+    RPC = "rpc"
+    IN_PROCESS = "in-process"
+    FILE = "file"
+
+
+class CacheType(Enum):
+    LRU = "lru"
+    DISABLED = "disabled"
+
+
+DEFAULT_CACHE = CacheType.LRU
+DEFAULT_CACHE_SIZE = 1000
+DEFAULT_DEADLINE = 500
+DEFAULT_HOST = "localhost"
+DEFAULT_KEEP_ALIVE = 0
+DEFAULT_OFFLINE_SOURCE_PATH: typing.Optional[str] = None
+DEFAULT_OFFLINE_POLL_MS = 5000
+DEFAULT_PORT_IN_PROCESS = 8015
+DEFAULT_PORT_RPC = 8013
+DEFAULT_RESOLVER_TYPE = ResolverType.RPC
+DEFAULT_RETRY_BACKOFF = 1000
+DEFAULT_RETRY_BACKOFF_MAX = 120000
+DEFAULT_RETRY_GRACE_PERIOD_SECONDS = 5
+DEFAULT_STREAM_DEADLINE = 600000
+DEFAULT_TLS = False
+DEFAULT_TLS_CERT: typing.Optional[str] = None
+
+ENV_VAR_CACHE_SIZE = "FLAGD_MAX_CACHE_SIZE"
+ENV_VAR_CACHE_TYPE = "FLAGD_CACHE"
+ENV_VAR_DEADLINE_MS = "FLAGD_DEADLINE_MS"
+ENV_VAR_HOST = "FLAGD_HOST"
+ENV_VAR_KEEP_ALIVE_TIME_MS = "FLAGD_KEEP_ALIVE_TIME_MS"
+ENV_VAR_OFFLINE_FLAG_SOURCE_PATH = "FLAGD_OFFLINE_FLAG_SOURCE_PATH"
+ENV_VAR_OFFLINE_POLL_MS = "FLAGD_OFFLINE_POLL_MS"
+ENV_VAR_PORT = "FLAGD_PORT"
+ENV_VAR_RESOLVER_TYPE = "FLAGD_RESOLVER"
+ENV_VAR_RETRY_BACKOFF_MS = "FLAGD_RETRY_BACKOFF_MS"
+ENV_VAR_RETRY_BACKOFF_MAX_MS = "FLAGD_RETRY_BACKOFF_MAX_MS"
+ENV_VAR_RETRY_GRACE_PERIOD_SECONDS = "FLAGD_RETRY_GRACE_PERIOD"
+ENV_VAR_SELECTOR = "FLAGD_SOURCE_SELECTOR"
+ENV_VAR_STREAM_DEADLINE_MS = "FLAGD_STREAM_DEADLINE_MS"
+ENV_VAR_TLS = "FLAGD_TLS"
+ENV_VAR_TLS_CERT = "FLAGD_SERVER_CERT_PATH"
 
 T = typing.TypeVar("T")
 
@@ -8,6 +56,14 @@ def str_to_bool(val: str) -> bool:
     return val.lower() == "true"
 
 
+def convert_resolver_type(val: typing.Union[str, ResolverType]) -> ResolverType:
+    if isinstance(val, str):
+        v = val.lower()
+        return ResolverType(v)
+    else:
+        return ResolverType(val)
+
+
 def env_or_default(
     env_var: str, default: T, cast: typing.Optional[typing.Callable[[str], T]] = None
 ) -> typing.Union[str, T]:
@@ -17,19 +73,157 @@ def env_or_default(
     return val if cast is None else cast(val)
 
 
+@dataclasses.dataclass
 class Config:
-    def __init__(
+    def __init__(  # noqa: PLR0913
         self,
         host: typing.Optional[str] = None,
         port: typing.Optional[int] = None,
         tls: typing.Optional[bool] = None,
-        timeout: typing.Optional[int] = None,
+        selector: typing.Optional[str] = None,
+        resolver: typing.Optional[ResolverType] = None,
+        offline_flag_source_path: typing.Optional[str] = None,
+        offline_poll_interval_ms: typing.Optional[int] = None,
+        retry_backoff_ms: typing.Optional[int] = None,
+        retry_backoff_max_ms: typing.Optional[int] = None,
+        retry_grace_period: typing.Optional[int] = None,
+        deadline_ms: typing.Optional[int] = None,
+        stream_deadline_ms: typing.Optional[int] = None,
+        keep_alive_time: typing.Optional[int] = None,
+        cache: typing.Optional[CacheType] = None,
+        max_cache_size: typing.Optional[int] = None,
+        cert_path: typing.Optional[str] = None,
     ):
-        self.host = env_or_default("FLAGD_HOST", "localhost") if host is None else host
-        self.port = (
-            env_or_default("FLAGD_PORT", 8013, cast=int) if port is None else port
-        )
+        self.host = env_or_default(ENV_VAR_HOST, DEFAULT_HOST) if host is None else host
+
         self.tls = (
-            env_or_default("FLAGD_TLS", False, cast=str_to_bool) if tls is None else tls
+            env_or_default(ENV_VAR_TLS, DEFAULT_TLS, cast=str_to_bool)
+            if tls is None
+            else tls
+        )
+
+        self.retry_backoff_ms: int = (
+            int(
+                env_or_default(
+                    ENV_VAR_RETRY_BACKOFF_MS, DEFAULT_RETRY_BACKOFF, cast=int
+                )
+            )
+            if retry_backoff_ms is None
+            else retry_backoff_ms
+        )
+        self.retry_backoff_max_ms: int = (
+            int(
+                env_or_default(
+                    ENV_VAR_RETRY_BACKOFF_MAX_MS, DEFAULT_RETRY_BACKOFF_MAX, cast=int
+                )
+            )
+            if retry_backoff_max_ms is None
+            else retry_backoff_max_ms
+        )
+
+        self.retry_grace_period: int = (
+            int(
+                env_or_default(
+                    ENV_VAR_RETRY_GRACE_PERIOD_SECONDS,
+                    DEFAULT_RETRY_GRACE_PERIOD_SECONDS,
+                    cast=int,
+                )
+            )
+            if retry_grace_period is None
+            else retry_grace_period
+        )
+
+        self.resolver = (
+            env_or_default(
+                ENV_VAR_RESOLVER_TYPE, DEFAULT_RESOLVER_TYPE, cast=convert_resolver_type
+            )
+            if resolver is None
+            else resolver
+        )
+
+        default_port = (
+            DEFAULT_PORT_RPC
+            if self.resolver is ResolverType.RPC
+            else DEFAULT_PORT_IN_PROCESS
+        )
+
+        self.port: int = (
+            int(env_or_default(ENV_VAR_PORT, default_port, cast=int))
+            if port is None
+            else port
+        )
+
+        self.offline_flag_source_path = (
+            env_or_default(
+                ENV_VAR_OFFLINE_FLAG_SOURCE_PATH, DEFAULT_OFFLINE_SOURCE_PATH
+            )
+            if offline_flag_source_path is None
+            else offline_flag_source_path
+        )
+
+        if (
+            self.offline_flag_source_path is not None
+            and self.resolver is ResolverType.IN_PROCESS
+        ):
+            self.resolver = ResolverType.FILE
+
+        if self.resolver is ResolverType.FILE and self.offline_flag_source_path is None:
+            raise AttributeError(
+                "Resolver Type 'FILE' requires a offlineFlagSourcePath"
+            )
+
+        self.offline_poll_interval_ms: int = (
+            int(
+                env_or_default(
+                    ENV_VAR_OFFLINE_POLL_MS, DEFAULT_OFFLINE_POLL_MS, cast=int
+                )
+            )
+            if offline_poll_interval_ms is None
+            else offline_poll_interval_ms
+        )
+
+        self.deadline_ms: int = (
+            int(env_or_default(ENV_VAR_DEADLINE_MS, DEFAULT_DEADLINE, cast=int))
+            if deadline_ms is None
+            else deadline_ms
+        )
+
+        self.stream_deadline_ms: int = (
+            int(
+                env_or_default(
+                    ENV_VAR_STREAM_DEADLINE_MS, DEFAULT_STREAM_DEADLINE, cast=int
+                )
+            )
+            if stream_deadline_ms is None
+            else stream_deadline_ms
+        )
+
+        self.keep_alive_time: int = (
+            int(
+                env_or_default(ENV_VAR_KEEP_ALIVE_TIME_MS, DEFAULT_KEEP_ALIVE, cast=int)
+            )
+            if keep_alive_time is None
+            else keep_alive_time
+        )
+
+        self.cache = (
+            CacheType(env_or_default(ENV_VAR_CACHE_TYPE, DEFAULT_CACHE))
+            if cache is None
+            else cache
+        )
+
+        self.max_cache_size: int = (
+            int(env_or_default(ENV_VAR_CACHE_SIZE, DEFAULT_CACHE_SIZE, cast=int))
+            if max_cache_size is None
+            else max_cache_size
+        )
+
+        self.cert_path = (
+            env_or_default(ENV_VAR_TLS_CERT, DEFAULT_TLS_CERT)
+            if cert_path is None
+            else cert_path
+        )
+
+        self.selector = (
+            env_or_default(ENV_VAR_SELECTOR, None) if selector is None else selector
         )
-        self.timeout = 5 if timeout is None else timeout

openfeature/contrib/provider/flagd/provider.py

@@ -22,25 +22,15 @@
 """
 
 import typing
-
-import grpc
-from google.protobuf.struct_pb2 import Struct
+import warnings
 
 from openfeature.evaluation_context import EvaluationContext
-from openfeature.exception import (
-    FlagNotFoundError,
-    GeneralError,
-    InvalidContextError,
-    ParseError,
-    TypeMismatchError,
-)
 from openfeature.flag_evaluation import FlagResolutionDetails
+from openfeature.provider import AbstractProvider
 from openfeature.provider.metadata import Metadata
-from openfeature.provider.provider import AbstractProvider
 
-from .config import Config
-from .flag_type import FlagType
-from .proto.schema.v1 import schema_pb2, schema_pb2_grpc
+from .config import CacheType, Config, ResolverType
+from .resolvers import AbstractResolver, GrpcResolver, InProcessResolver
 
 T = typing.TypeVar("T")
 
@@ -48,12 +38,24 @@ T = typing.TypeVar("T")
 class FlagdProvider(AbstractProvider):
     """Flagd OpenFeature Provider"""
 
-    def __init__(
+    def __init__(  # noqa: PLR0913
         self,
         host: typing.Optional[str] = None,
         port: typing.Optional[int] = None,
         tls: typing.Optional[bool] = None,
+        deadline_ms: typing.Optional[int] = None,
         timeout: typing.Optional[int] = None,
+        retry_backoff_ms: typing.Optional[int] = None,
+        selector: typing.Optional[str] = None,
+        resolver_type: typing.Optional[ResolverType] = None,
+        offline_flag_source_path: typing.Optional[str] = None,
+        stream_deadline_ms: typing.Optional[int] = None,
+        keep_alive_time: typing.Optional[int] = None,
+        cache: typing.Optional[CacheType] = None,
+        max_cache_size: typing.Optional[int] = None,
+        retry_backoff_max_ms: typing.Optional[int] = None,
+        retry_grace_period: typing.Optional[int] = None,
+        cert_path: typing.Optional[str] = None,
     ):
         """
         Create an instance of the FlagdProvider
@@ -61,21 +63,73 @@ class FlagdProvider(AbstractProvider):
         :param host: the host to make requests to
         :param port: the port the flagd service is available on
         :param tls: enable/disable secure TLS connectivity
-        :param timeout: the maximum to wait before a request times out
+        :param deadline_ms: the maximum to wait before a request times out
+        :param timeout: the maximum time to wait before a request times out
+        :param retry_backoff_ms: the number of milliseconds to backoff
+        :param offline_flag_source_path: the path to the flag source file
+        :param stream_deadline_ms: the maximum time to wait before a request times out
+        :param keep_alive_time: the number of milliseconds to keep alive
+        :param resolver_type: the type of resolver to use
         """
+        if deadline_ms is None and timeout is not None:
+            deadline_ms = timeout * 1000
+            warnings.warn(
+                "'timeout' property is deprecated, please use 'deadline' instead, be aware that 'deadline' is in milliseconds",
+                DeprecationWarning,
+                stacklevel=2,
+            )
+
         self.config = Config(
             host=host,
             port=port,
             tls=tls,
-            timeout=timeout,
+            deadline_ms=deadline_ms,
+            retry_backoff_ms=retry_backoff_ms,
+            retry_backoff_max_ms=retry_backoff_max_ms,
+            retry_grace_period=retry_grace_period,
+            selector=selector,
+            resolver=resolver_type,
+            offline_flag_source_path=offline_flag_source_path,
+            stream_deadline_ms=stream_deadline_ms,
+            keep_alive_time=keep_alive_time,
+            cache=cache,
+            max_cache_size=max_cache_size,
+            cert_path=cert_path,
         )
 
-        channel_factory = grpc.secure_channel if tls else grpc.insecure_channel
-        self.channel = channel_factory(f"{self.config.host}:{self.config.port}")
-        self.stub = schema_pb2_grpc.ServiceStub(self.channel)
+        self.resolver = self.setup_resolver()
+
+    def setup_resolver(self) -> AbstractResolver:
+        if self.config.resolver == ResolverType.RPC:
+            return GrpcResolver(
+                self.config,
+                self.emit_provider_ready,
+                self.emit_provider_error,
+                self.emit_provider_stale,
+                self.emit_provider_configuration_changed,
+            )
+        elif (
+            self.config.resolver == ResolverType.IN_PROCESS
+            or self.config.resolver == ResolverType.FILE
+        ):
+            return InProcessResolver(
+                self.config,
+                self.emit_provider_ready,
+                self.emit_provider_error,
+                self.emit_provider_stale,
+                self.emit_provider_configuration_changed,
+            )
+        else:
+            raise ValueError(
+                f"`resolver_type` parameter invalid: {self.config.resolver}"
+            )
+
+    def initialize(self, evaluation_context: EvaluationContext) -> None:
+        self.resolver.initialize(evaluation_context)
 
     def shutdown(self) -> None:
-        self.channel.close()
+        if self.resolver:
+            self.resolver.shutdown()
 
     def get_metadata(self) -> Metadata:
         """Returns provider metadata"""
@@ -87,7 +141,9 @@ class FlagdProvider(AbstractProvider):
         default_value: bool,
         evaluation_context: typing.Optional[EvaluationContext] = None,
     ) -> FlagResolutionDetails[bool]:
-        return self._resolve(key, FlagType.BOOLEAN, default_value, evaluation_context)
+        return self.resolver.resolve_boolean_details(
+            key, default_value, evaluation_context
+        )
 
     def resolve_string_details(
         self,
@@ -95,7 +151,9 @@ class FlagdProvider(AbstractProvider):
         default_value: str,
         evaluation_context: typing.Optional[EvaluationContext] = None,
     ) -> FlagResolutionDetails[str]:
-        return self._resolve(key, FlagType.STRING, default_value, evaluation_context)
+        return self.resolver.resolve_string_details(
+            key, default_value, evaluation_context
+        )
 
     def resolve_float_details(
         self,
@@ -103,7 +161,9 @@ class FlagdProvider(AbstractProvider):
         default_value: float,
         evaluation_context: typing.Optional[EvaluationContext] = None,
     ) -> FlagResolutionDetails[float]:
-        return self._resolve(key, FlagType.FLOAT, default_value, evaluation_context)
+        return self.resolver.resolve_float_details(
+            key, default_value, evaluation_context
+        )
 
     def resolve_integer_details(
         self,
@@ -111,7 +171,9 @@ class FlagdProvider(AbstractProvider):
         default_value: int,
         evaluation_context: typing.Optional[EvaluationContext] = None,
     ) -> FlagResolutionDetails[int]:
-        return self._resolve(key, FlagType.INTEGER, default_value, evaluation_context)
+        return self.resolver.resolve_integer_details(
+            key, default_value, evaluation_context
+        )
 
     def resolve_object_details(
         self,
@@ -119,76 +181,6 @@ class FlagdProvider(AbstractProvider):
         default_value: typing.Union[dict, list],
         evaluation_context: typing.Optional[EvaluationContext] = None,
     ) -> FlagResolutionDetails[typing.Union[dict, list]]:
-        return self._resolve(key, FlagType.OBJECT, default_value, evaluation_context)
-
-    def _resolve(
-        self,
-        flag_key: str,
-        flag_type: FlagType,
-        default_value: T,
-        evaluation_context: typing.Optional[EvaluationContext],
-    ) -> FlagResolutionDetails[T]:
-        context = self._convert_context(evaluation_context)
-        call_args = {"timeout": self.config.timeout}
-        try:
-            if flag_type == FlagType.BOOLEAN:
-                request = schema_pb2.ResolveBooleanRequest(  # type:ignore[attr-defined]
-                    flag_key=flag_key, context=context
-                )
-                response = self.stub.ResolveBoolean(request, **call_args)
-            elif flag_type == FlagType.STRING:
-                request = schema_pb2.ResolveStringRequest(  # type:ignore[attr-defined]
-                    flag_key=flag_key, context=context
-                )
-                response = self.stub.ResolveString(request, **call_args)
-            elif flag_type == FlagType.OBJECT:
-                request = schema_pb2.ResolveObjectRequest(  # type:ignore[attr-defined]
-                    flag_key=flag_key, context=context
-                )
-                response = self.stub.ResolveObject(request, **call_args)
-            elif flag_type == FlagType.FLOAT:
-                request = schema_pb2.ResolveFloatRequest(  # type:ignore[attr-defined]
-                    flag_key=flag_key, context=context
-                )
-                response = self.stub.ResolveFloat(request, **call_args)
-            elif flag_type == FlagType.INTEGER:
-                request = schema_pb2.ResolveIntRequest(  # type:ignore[attr-defined]
-                    flag_key=flag_key, context=context
-                )
-                response = self.stub.ResolveInt(request, **call_args)
-            else:
-                raise ValueError(f"Unknown flag type: {flag_type}")
-
-        except grpc.RpcError as e:
-            code = e.code()
-            message = f"received grpc status code {code}"
-
-            if code == grpc.StatusCode.NOT_FOUND:
-                raise FlagNotFoundError(message) from e
-            elif code == grpc.StatusCode.INVALID_ARGUMENT:
-                raise TypeMismatchError(message) from e
-            elif code == grpc.StatusCode.DATA_LOSS:
-                raise ParseError(message) from e
-            raise GeneralError(message) from e
-
-        # Got a valid flag and valid type. Return it.
-        return FlagResolutionDetails(
-            value=response.value,
-            reason=response.reason,
-            variant=response.variant,
+        return self.resolver.resolve_object_details(
+            key, default_value, evaluation_context
         )
-
-    def _convert_context(
-        self, evaluation_context: typing.Optional[EvaluationContext]
-    ) -> Struct:
-        s = Struct()
-        if evaluation_context:
-            try:
-                s["targetingKey"] = evaluation_context.targeting_key
-                s.update(evaluation_context.attributes)
-            except ValueError as exc:
-                message = (
-                    "could not serialize evaluation context to google.protobuf.Struct"
-                )
-                raise InvalidContextError(message) from exc
-        return s

openfeature/contrib/provider/flagd/resolvers/__init__.py

@@ -0,0 +1,5 @@
+from .grpc import GrpcResolver
+from .in_process import InProcessResolver
+from .protocol import AbstractResolver
+
+__all__ = ["AbstractResolver", "GrpcResolver", "InProcessResolver"]