polaris-python 0.0.1.dev3__py3-none-any.whl

polaris/pkg/flow/admin_server.py

@@ -0,0 +1,104 @@
+# Tencent is pleased to support the open source community by making polaris-python available.
+#
+# Copyright (C) 2021 Tencent. All rights reserved.
+#
+# Licensed under the BSD 3-Clause License (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# https://opensource.org/licenses/BSD-3-Clause
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+"""Shared admin HTTP server for stats and lossless endpoints."""
+
+from __future__ import annotations
+
+import time
+
+from aiohttp import web
+
+import polaris.api.log as logger
+from polaris.pkg.config.stat_reporter import AdminConfig
+from polaris.pkg.model.error import ErrorCode, SDKError
+
+admin_logger = logger.get_logger("admin")
+
+
+class AdminHttpServer:
+    """Expose one aiohttp application for every SDK component on the admin port."""
+
+    def __init__(self, admin_config: AdminConfig):
+        self.admin_config = admin_config
+        self.app = web.Application(middlewares=[self._log_request])
+        self.runner = None
+        self.port = None
+        self._routes = {}
+        self._started = False
+
+    @staticmethod
+    @web.middleware
+    async def _log_request(request, handler):
+        started = time.monotonic()
+        try:
+            response = await handler(request)
+        except Exception as error:
+            admin_logger.error("admin http %s %s failed: %s", request.method, request.path, error)
+            raise
+        admin_logger.debug(
+            "admin http %s %s status=%d cost=%.3fms",
+            request.method, request.path, response.status, (time.monotonic() - started) * 1000,
+        )
+        return response
+
+    def add_route(self, method: str, path: str, handler) -> None:
+        key = (method, path)
+        if key in self._routes:
+            raise SDKError(ErrorCode.ErrCodeAPIInvalidArgument,
+                           f"duplicated admin HTTP route {method} {path}")
+        self._routes[key] = handler
+        self.app.router.add_route(method, path, handler)
+
+    def has_routes(self) -> bool:
+        return bool(self._routes)
+
+    async def start(self) -> None:
+        """Bind the configured admin address once all routes have been added."""
+        if self._started:
+            return
+        if not self._routes or self.admin_config.port is None or self.admin_config.port < 0:
+            admin_logger.info(
+                "admin http server disabled host=%s port=%s routes=%d",
+                self.admin_config.host, self.admin_config.port, len(self._routes),
+            )
+            return
+        self.runner = web.AppRunner(self.app, access_log=None)
+        await self.runner.setup()
+        site = web.TCPSite(self.runner, self.admin_config.host, self.admin_config.port)
+        try:
+            await site.start()
+        except OSError as error:
+            await self.runner.cleanup()
+            self.runner = None
+            raise SDKError(ErrorCode.ErrCodeAPIInvalidConfig,
+                           f"Cannot bind admin listener {self.admin_config.host}:{self.admin_config.port}: {error}") from error
+        self.port = site._server.sockets[0].getsockname()[1]
+        self._started = True
+        admin_logger.info(
+            "admin http server listening host=%s port=%s routes=%d",
+            self.admin_config.host, self.port, len(self._routes),
+        )
+
+    async def close(self) -> None:
+        started = self._started
+        if self.runner is not None:
+            await self.runner.cleanup()
+            self.runner = None
+        self._started = False
+        self.port = None
+        if started:
+            admin_logger.info("admin http server stopped")

polaris/pkg/flow/async_flow.py

@@ -0,0 +1,55 @@
+# Tencent is pleased to support the open source community by making polaris-python available.
+#
+# Copyright (C) 2021 Tencent. All rights reserved.
+#
+# Licensed under the BSD 3-Clause License (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# https://opensource.org/licenses/BSD-3-Clause
+#
+# Unless required by applicable law or agreed to in writing, software distributed
+# under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR
+# CONDITIONS OF ANY KIND, either express or implied. See the License for the
+# specific language governing permissions and limitations under the License.
+
+from polaris.pkg.model.service import GetOneInstanceRequest, GetInstancesRequest
+from polaris.pkg.flow.base_flow import CacheFilter, CacheResult
+from polaris.pkg.flow.impl import Engine
+from polaris.pkg.flow.base_flow import get_load_cache_values
+
+
+class FutureRequest:
+    def __init__(self, request: GetOneInstanceRequest, hash_value: int, do_load_balance: bool):
+        self.request = request
+        self.hash_value = hash_value
+        self.do_load_balance = do_load_balance
+
+
+class AsyncFlowFuture:
+    def __init__(self, request: FutureRequest, filter_request: CacheFilter, redirect_times: int, engine: Engine):
+        self.request = request
+        self.filter_request = filter_request
+        self.redirect_times = redirect_times
+        self.engine = engine
+
+
+class AsyncEngine(Engine):
+
+    def create_async_flow_future(self, req: FutureRequest):
+        future = AsyncFlowFuture(request=req)
+        future.engine = AsyncEngine
+        return future
+
+    async def async_get_instances(self, req: GetInstancesRequest, do_balance: bool):
+        req = self.set_default_value_for_instances_request(req)
+        async_future = self.create_async_flow_future(req)
+        async_future.filter_request = self.instance_request_to_cache_filter(req=req, redirect_service=None)
+        request = async_future.filter_request
+        result = await get_load_cache_values(self.registry, request, True)
+        return result
+
+    async def async_get_one_instance(self, req: GetOneInstanceRequest):
+        instance_request = GetInstancesRequest(flow_id=req.flow_id, service=req.service, namespace=req.namespave,
+                                               timeout=req.timeout)
+        return await self.async_get_instances(instance_request, True)

polaris/pkg/flow/base_flow.py

@@ -0,0 +1,111 @@
+# Tencent is pleased to support the open source community by making polaris-python available.
+#
+# Copyright (C) 2021 Tencent. All rights reserved.
+#
+# Licensed under the BSD 3-Clause License (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# https://opensource.org/licenses/BSD-3-Clause
+#
+# Unless required by applicable law or agreed to in writing, software distributed
+# under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR
+# CONDITIONS OF ANY KIND, either express or implied. See the License for the
+# specific language governing permissions and limitations under the License.
+
+from polaris.plugin.local_registry.local_cache import InstanceFilter
+from polaris.pkg.model.rule import ServiceRule
+from polaris.pkg.model.service import ServiceInstances
+from polaris.plugin.local_registry.local_cache import LocalCache
+from polaris.pkg.model.core import ServiceKey
+from polaris.plugin.local_registry.local_cache import ServiceUpdateRequest
+from typing import Dict
+from polaris.api.log import get_logger
+import copy
+from polaris.plugin.circuit_breaker.composite import CircuitBreakResult
+from polaris.pkg.model.error import ErrorCode, SDKError
+
+logger = get_logger("cache")
+
+
+class RealTimeLimitTask:
+    def __init__(self, svc: ServiceKey = None, ins_id: str = None, host: str = None, port: int = None,
+                 cb_name: str = None):
+        self.service_key = svc
+        self.instance_id = ins_id
+        self.host = host
+        self.port = port
+        self.cb_name = cb_name
+
+    def get_host(self):
+        return self.host
+
+    def get_port(self):
+        return self.port
+
+    def get_instance_id(self):
+        return self.instance_id
+
+    def get_service_key(self):
+        return self.service_key
+
+    def get_cb_name(self):
+        return self.cb_name
+
+
+class CacheFilter:
+    def __init__(self, namespace: str, service: str, dest_instance_fileter: InstanceFilter):
+        self.namespace = namespace
+        self.service = service
+        self.desc_instances_filter = dest_instance_fileter
+
+    def to_context_key(self):
+        pass
+
+
+class CacheResult:
+    def __init__(self, source_route_rule: ServiceRule = None, dest_route_rule: ServiceRule = None,
+                 dest_instances: ServiceInstances = None):
+        self.source_route_rule = source_route_rule
+        self.dest_route_rule = dest_route_rule
+        self.dest_instances = dest_instances
+        self.combineContext = ""
+
+
+async def get_load_cache_values(registry: LocalCache, filters: CacheFilter, load: bool,
+                                use_discover_cache=True, timeout=None) -> CacheResult:
+    result = CacheResult()
+    instances = registry.get_instances(instance_filter=filters.desc_instances_filter)
+    if instances and instances.is_initialized():
+        result.dest_instances = copy.copy(instances)
+    elif load:
+        logger.debug("miss local cache and begin to load remote value for %s",
+                     filters.desc_instances_filter.__dict__)
+        try:
+            await registry.load_instances(filters.service, filters.namespace, use_discover_cache, timeout=timeout)
+        except SDKError as error:
+            if error.err_code not in (ErrorCode.ErrCodeNetworkError, ErrorCode.ErrCodeAPITimeoutError):
+                raise
+            fallback_filter = copy.copy(filters.desc_instances_filter)
+            fallback_filter.include_cache = True
+            instances = registry.get_instances(fallback_filter)
+            if instances is None:
+                raise
+            logger.warning("remote discovery unavailable; using local snapshot for %s/%s",
+                           filters.namespace, filters.service)
+        else:
+            instances = registry.get_instances(instance_filter=filters.desc_instances_filter)
+        result.dest_instances = copy.copy(instances) if instances is not None else None
+    else:
+        return None
+    return result
+
+
+def build_instance_property(now, allowed_request: int, instances):
+    pass
+
+
+def build_service_update_request(svc: ServiceKey, results: Dict[str, CircuitBreakResult]) -> ServiceUpdateRequest:
+    request = ServiceUpdateRequest(service=svc.get_service(), namespace=svc.get_namespace())
+    for cb_name, result in results.items():
+        pass