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

polaris/pkg/model/skill.py

@@ -0,0 +1,179 @@
+# 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.
+
+"""Public request and result models for the read-only Skill API."""
+
+from dataclasses import dataclass, field
+
+from polaris.pkg.model.error import ErrorCode, SDKError
+
+
+@dataclass
+class SkillGetRequest:
+    """Fetch a published skill, using the active version when version is empty."""
+
+    namespace: str
+    name: str
+    version: str = ""
+    timeout: int = 0
+
+    def validate(self):
+        """Validate the resource identity and optional timeout in milliseconds."""
+        if (not isinstance(self.namespace, str) or not self.namespace.strip()
+                or not isinstance(self.name, str) or not self.name.strip() or not isinstance(self.version, str)
+                or type(self.timeout) is not int or self.timeout < 0):
+            raise SDKError(ErrorCode.ErrCodeAPIInvalidArgument, "skill namespace/name are required and timeout must be >=0")
+
+
+@dataclass
+class SkillListRequest:
+    """Search published skills with filters, sorting and pagination."""
+
+    namespace: str = ""
+    name: str = ""
+    tag: str = ""
+    owner: str = ""
+    scope: str = ""
+    keyword: str = ""
+    order_by: str = ""
+    order_type: str = ""
+    offset: int = 0
+    limit: int = 100
+    timeout: int = 0
+
+    def validate(self):
+        """Validate pagination and optional request timeout."""
+        if (type(self.offset) is not int or type(self.limit) is not int or type(self.timeout) is not int
+                or self.offset < 0 or self.limit < 0 or self.timeout < 0):
+            raise SDKError(ErrorCode.ErrCodeAPIInvalidArgument, "skill offset, limit and timeout must be nonnegative integers")
+
+
+@dataclass
+class SkillDownloadRequest(SkillGetRequest):
+    """Download a skill as markdown or a complete ZIP archive."""
+
+    tag: str = ""
+    format: str = "markdown"
+
+    def validate(self):
+        """Validate the identity and supported download format."""
+        super().validate()
+        if self.format not in ("markdown", "zip"):
+            raise SDKError(ErrorCode.ErrCodeAPIInvalidArgument, "skill format must be markdown or zip")
+
+
+@dataclass
+class SkillVersionInfo:
+    """Version pointers published by the registry."""
+
+    active_version: str = ""
+    latest_version: str = ""
+    total_versions: int = 0
+
+
+@dataclass
+class SkillStorageInfo:
+    """Storage metadata for a skill package."""
+
+    provider: str = ""
+    files: list[str] = field(default_factory=list)
+    scope: str = ""
+    content_digest: str = ""
+
+
+@dataclass
+class SkillResource:
+    """Registry metadata describing a published skill."""
+
+    id: int = 0
+    name: str = ""
+    namespace: str = ""
+    description: str = ""
+    status: str = ""
+    tags: list[str] = field(default_factory=list)
+    examples: list[str] = field(default_factory=list)
+    ext: dict[str, str] = field(default_factory=dict)
+    source: str = ""
+    version_info: SkillVersionInfo = field(default_factory=SkillVersionInfo)
+    meta_version: int = 0
+    scope: str = ""
+    owner: str = ""
+    download_count: int = 0
+    create_time: str = ""
+    modify_time: str = ""
+
+
+@dataclass
+class SkillResourceVersion:
+    """Metadata for the resolved published version."""
+
+    id: int = 0
+    name: str = ""
+    namespace: str = ""
+    version: str = ""
+    author: str = ""
+    description: str = ""
+    status: str = ""
+    storage: SkillStorageInfo = field(default_factory=SkillStorageInfo)
+    download_count: int = 0
+    create_time: str = ""
+    modify_time: str = ""
+
+
+@dataclass
+class SkillGetResponse:
+    """A published skill and its SKILL.md content."""
+
+    resource: SkillResource
+    version: SkillResourceVersion
+    content: str
+    loaded_from_file: bool = False
+    code: int = 200000
+    info: str = ""
+
+    @property
+    def resource_version(self) -> SkillResourceVersion:
+        """Java-compatible name for the resolved version metadata."""
+        return self.version
+
+
+@dataclass
+class SkillListResponse:
+    """One page of skill search results."""
+
+    total: int
+    resources: list[SkillResource]
+    code: int = 200000
+    info: str = ""
+
+
+@dataclass
+class SkillDownloadResponse:
+    """A complete markdown document or ZIP package."""
+
+    version: str
+    content_type: str
+    content: str = ""
+    data: bytes = b""
+    total_size: int = 0
+    filename: str = ""
+    loaded_from_file: bool = False
+    code: int = 200000
+    info: str = ""
+
+    @property
+    def zip_content(self) -> bytes:
+        """Java-compatible name for the assembled ZIP payload."""
+        return self.data

polaris/pkg/model/stat.py

@@ -0,0 +1,168 @@
+# 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.
+
+import time
+import threading
+from typing import List, Tuple
+
+
+class InstanceGauge:
+    def get_id(self) -> str:
+        pass
+
+    def get_namespace(self) -> str:
+        pass
+
+    def get_service(self) -> str:
+        pass
+
+    def get_api(self) -> str:
+        pass
+
+    def get_host(self) -> str:
+        pass
+
+    def get_port(self) -> int:
+        pass
+
+    def get_ret_status(self) -> int:
+        pass
+
+    def get_ret_code(self) -> int:
+        pass
+
+    def get_delay(self) -> int:
+        pass
+
+    def validate(self) -> bool:
+        pass
+
+
+class BucketMetric:
+    def __init__(self):
+        self.success = 0
+        self.total_failed = 0
+        self.continuous_failed = 0
+
+
+class Bucket:
+    def __init__(self, begin_time=0, end_time=0):
+        self.lock = threading.RLock()
+        self.begin_time = begin_time
+        self.end_time = end_time
+        self.metric = BucketMetric()
+
+    @property
+    def success(self):
+        return self.metric.success
+
+    @success.setter
+    def success(self, val):
+        self.metric.success = val
+
+    @property
+    def total_failed(self):
+        return self.metric.total_failed
+
+    @total_failed.setter
+    def total_failed(self, val):
+        self.metric.total_failed = val
+
+    @property
+    def continuous_failed(self):
+        return self.metric.continuous_failed
+
+    @continuous_failed.setter
+    def continuous_failed(self, val):
+        self.metric.continuous_failed = val
+
+
+class SlidingWindow:
+    def __init__(self, bucket_count: int, bucket_interval: int):
+        """
+
+        :param bucket_count: 窗口内桶总数
+        :param bucket_interval: 桶的时长(ms)
+        """
+        self.win_chain: List[Bucket] = []
+        self.bucket_count = bucket_count
+        self.bucket_interval = bucket_interval
+        self.lock = threading.RLock()
+
+    @property
+    def window_length(self):
+        return self.bucket_count * self.bucket_interval
+
+    def _bucket_for(self, now: int) -> Bucket:
+        tail = self.win_chain[-1] if self.win_chain else None
+        if tail is not None and tail.begin_time <= now < tail.end_time:
+            return tail
+
+        # A long idle gap recreates the window; otherwise append the bucket
+        # that contains the current timestamp.
+        if tail is None or tail.end_time + self.window_length <= now:
+            self.win_chain = [Bucket(now, now + self.bucket_interval)]
+            return self.win_chain[0]
+
+        next_start = tail.end_time + (now - tail.end_time) // self.bucket_interval
+        bucket = Bucket(next_start, next_start + self.bucket_interval)
+        while (self.win_chain and
+               self.win_chain[0].begin_time + self.window_length <= next_start):
+            self.win_chain.pop(0)
+        self.win_chain.append(bucket)
+        return bucket
+
+    def add(self, value, cb, *, now=None):
+        if now is None:
+            now = int(time.time() * 1000)
+        with self.lock:
+            cur_bucket = self._bucket_for(now)
+            with cur_bucket.lock:
+                ret = cb(cur_bucket, value)
+        return ret
+
+    def lookup(self, cur_time: int) -> Bucket:
+        with self.lock:
+            return self._bucket_for(cur_time)
+
+    def calc_interval_values(self, begin_time: int, end_time: int) -> Tuple:
+        total_success = 0
+        total_failed = 0
+        continuous_failed = 0
+
+        with self.lock:
+            for b in self.win_chain:
+                with b.lock:
+                    if begin_time >= b.end_time:
+                        continue
+                    if end_time <= b.begin_time:
+                        continue
+
+                    total_success += b.success
+                    total_failed += b.total_failed
+                    continuous_failed += b.continuous_failed
+
+        return total_success, total_failed, continuous_failed
+
+
+ApiGetOneInstance = "Consumer::GetOneInstance"
+ApiGetInstances = "Consumer::GetInstances"
+ApiAsyncGetOneInstance = "Consumer::AsyncGetOneInstance"
+ApiAsyncGetInstances = "Consumer::AsyncGetInstances"
+ApiGetRouteRule = "Consumer::GetRouteRule"
+
+ApiRegister = "Provider::Register"
+ApiDeregister = "Provider::Deregister"
+ApiHeartbeat = "Provider::Heartbeat"

polaris/pkg/model/util.py

@@ -0,0 +1,58 @@
+# 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.
+
+import asyncio
+import ipaddress
+import socket
+from contextlib import suppress
+
+import psutil
+
+
+def get_ip(ifname: str) -> str:
+    """Return an IP from the named interface without falling back to another one."""
+    for address in psutil.net_if_addrs().get(ifname, ()):
+        if address.family in (socket.AF_INET, socket.AF_INET6):
+            return str(ipaddress.ip_address(address.address.split("%", 1)[0]))
+    raise OSError(f"no IP address found for interface {ifname}")
+
+
+async def get_local_ip(address: str, timeout: int) -> str:
+    """Probe the TCP source IP for a configured server within a millisecond timeout."""
+    host, port = get_ip_from_int_with_port(address)
+    if not host or not 0 < port < 65536:
+        raise ValueError(f"invalid server address {address}")
+    async with asyncio.timeout(timeout / 1000):
+        _, writer = await asyncio.open_connection(host, port)
+        try:
+            local_address = writer.get_extra_info("sockname")
+            if not local_address or not local_address[0]:
+                raise OSError("TCP connection has no local IP address")
+            return str(ipaddress.ip_address(local_address[0]))
+        finally:
+            writer.close()
+            with suppress(OSError):
+                await writer.wait_closed()
+
+
+def get_ip_from_int_with_port(ipstr):
+    host, port = ipstr.rsplit(":", 1)
+    if host.startswith("[") and host.endswith("]"):
+        host = host[1:-1]
+    try:
+        host = str(ipaddress.IPv4Address(int(host)))
+    except ValueError:
+        pass
+    return host, int(port)

polaris/pkg/version/__init__.py

@@ -0,0 +1,18 @@
+# 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._version import __version__
+
+version = __version__

polaris/plugin/__init__.py

@@ -0,0 +1,32 @@
+# 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 . import circuit_breaker
+from . import event
+from . import load_balancer
+from . import local_registry
+from . import server_connector
+from . import service_router
+from . import stat_reporter
+from .skill import connector
+
+__all__ = [
+    "circuit_breaker",
+    "event",
+    "load_balancer",
+    "local_registry",
+    "server_connector",
+    "service_router",
+]

polaris/plugin/circuit_breaker/__init__.py

@@ -0,0 +1,19 @@
+# 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 .base import BaseCircuitBreaker, CircuitBreakResult
+from .composite import CircuitBreaker
+
+__all__ = ["BaseCircuitBreaker", "CircuitBreakResult", "CircuitBreaker"]

polaris/plugin/circuit_breaker/base.py

@@ -0,0 +1,54 @@
+# 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 abc import ABC, abstractmethod
+from typing import Dict, List
+
+from polaris.pkg.model.service import Instance
+
+__all__ = ["BaseCircuitBreaker", "CircuitBreakResult"]
+
+
+class CircuitBreakResult:
+    def __init__(self, ts=None):
+        self.now = ts
+        self.instance_2_open = []
+        self.instance_2_halfopen = []
+        self.instance_2_close = []
+
+
+class BaseCircuitBreaker(ABC):
+    """
+    熔断判断返回是否需要进行熔断
+    """
+
+    @abstractmethod
+    def realtime_circuit_break(self, instance: Instance, ret: int, cost: int) -> bool:
+        pass
+
+    def timing_circuit_break(self, instance_list: List[Instance]) -> CircuitBreakResult:
+        pass
+
+    def next_check_time(self, instance: Instance):
+        return None
+
+    def now(self):
+        raise NotImplementedError
+
+    def on_state_change(self, instance: Instance):
+        pass
+
+    def get_half_open_request_count(self):
+        return 3