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

polaris/plugin/circuit_breaker/composite.py

@@ -0,0 +1,265 @@
+# 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
+
+from .base import BaseCircuitBreaker, CircuitBreakResult
+from ...pkg.model.service import Instance, CBStatusEnum
+from ...pkg.model.stat import Bucket
+from typing import List
+from . import config
+from polaris.plugin_manager import InitContext, EventType, PluginType, register_plugin
+from polaris.pkg.model.stat import SlidingWindow
+from polaris.api.log import get_logger
+
+logger = get_logger("circuitbreaker")
+
+
+class PluginConfig:
+    def __init__(self, continuous_err_threshold=config.DefaultOptions.DefaultContinuousErrorThreshold,
+                 metric_stat_time_window=config.DefaultOptions.DefaultMetricStatWindow,
+                 metric_num_bucket=config.DefaultOptions.DefaultMetricBucketCount,
+                 sleep_window=config.DefaultOptions.DefaultSleepTime,
+                 request_count_after_halfopen=config.DefaultOptions.DefaultRequestCountAfterHalfOpen,
+                 success_count_after_halfopen=config.DefaultOptions.DefaultSuccessCountAfterHalfOpen,
+                 err_rate_threshold=config.DefaultOptions.DefaultErrRateThreshold,
+                 err_rate_request_threshold=config.DefaultOptions.DefaultErrRateRequestThreshold):
+        # 连续失败数量
+        self.continuous_error_threshold = continuous_err_threshold
+        self.metric_stat_time_window = metric_stat_time_window
+        # bucket数量
+        self.metric_num_bucket = metric_num_bucket
+        # 熔断后多久转为半开
+        self.sleep_window = sleep_window
+        self.request_count_after_halfopen = request_count_after_halfopen
+        # 半开后多少请求后可以转为恢复
+        self.success_count_after_halfopen = success_count_after_halfopen
+
+        # 失败率
+        self.err_rate_threshold = err_rate_threshold
+        self.err_rate_request_threshold = err_rate_request_threshold
+
+
+class InstanceMetrics:
+    """Per-trigger counters, mirroring Java composite TriggerCounter state."""
+
+    def __init__(self, options: PluginConfig):
+        self.window = SlidingWindow(options.metric_num_bucket,
+                                    (options.metric_stat_time_window + options.metric_num_bucket - 1)
+                                    // options.metric_num_bucket)
+        self.consecutive_errors = 0
+        self.consecutive_suspended = False
+        self.consecutive_triggered = False
+        self.error_rate_suspended = False
+        self.error_rate_check_at = None
+
+
+@register_plugin(PluginType.CIRCUIT_BREAKER, "composite")
+class CircuitBreaker(BaseCircuitBreaker):
+    def __init__(self, ctx: InitContext = None):
+        self.ctx = ctx
+        self.config = ctx.config.get_consumer().get_circuit_breaker() if ctx is not None else None
+        self.plugin_config = PluginConfig()
+        self.enabled = self.config is None or (self.config.is_enable() and self.config.is_default_rule_enable())
+        if self.config is not None:
+            interval_seconds = self.config.get_default_interval() // 1000
+            if interval_seconds == 0:
+                interval_seconds = config.DefaultOptions.DefaultMetricStatWindow // 1000
+            sleep_seconds = self.config.get_sleep_window() // 1000
+            self.plugin_config = PluginConfig(
+                continuous_err_threshold=self.config.get_default_error_count(),
+                metric_stat_time_window=interval_seconds * 1000,
+                sleep_window=sleep_seconds * 1000 if sleep_seconds > 0 else self.config.get_sleep_window(),
+                request_count_after_halfopen=self.config.get_success_count_after_half_open(),
+                success_count_after_halfopen=self.config.get_success_count_after_half_open(),
+                err_rate_threshold=self.config.get_default_error_percent() / 100,
+                err_rate_request_threshold=self.config.get_default_minimum_request(),
+            )
+
+        if ctx is not None:
+            ctx.plugins.register_event_handle(EventType.ON_LOCALVALUE_CREATED, self)
+
+    @staticmethod
+    def now():
+        return int(time.time() * 1000)
+
+    def _metrics(self, local_value):
+        if local_value.circuit_breaker_metrics is None:
+            metrics = InstanceMetrics(self.plugin_config)
+            local_value.circuit_breaker_metrics = metrics
+            local_value.set_sliding_window(metrics.window)
+        return local_value.circuit_breaker_metrics
+
+    def realtime_circuit_break(self, instance: Instance, ret: int, cost: int) -> bool:
+        if not self.enabled:
+            return False
+        success = ret != -1 and not 500 <= ret <= 599
+        status = instance.get_circuit_breaker_status()
+        if status.get_status() == CBStatusEnum.HalfOpen:
+            status.report_half_open_result(success)
+            return (self.halfopen2open(instance, self.now()) or
+                    self.halfopen2close(instance, self.now()))
+
+        metrics = self._metrics(instance.get_local_value())
+        now = self.now()
+
+        if not metrics.error_rate_suspended:
+            def callback(bucket: Bucket, value):
+                if success:
+                    bucket.success += value
+                else:
+                    bucket.total_failed += value
+
+            metrics.window.add(1, callback, now=now)
+            if not success and metrics.error_rate_check_at is None:
+                metrics.error_rate_check_at = now + self.plugin_config.metric_stat_time_window
+
+        if not metrics.consecutive_suspended:
+            if success:
+                metrics.consecutive_errors = 0
+            else:
+                metrics.consecutive_errors += 1
+                if metrics.consecutive_errors == self.plugin_config.continuous_error_threshold:
+                    metrics.consecutive_suspended = True
+                    metrics.consecutive_errors = 0
+                    if status.get_status() == CBStatusEnum.Open:
+                        # The state change handler ignores close-to-open here.
+                        return False
+                    metrics.consecutive_triggered = True
+                    return True
+        return False
+
+    def timing_circuit_break(self, instance_list: List[Instance]) -> CircuitBreakResult:
+        now = self.now()
+        result = CircuitBreakResult(ts=now)
+        if not self.enabled:
+            return result
+        for instance in instance_list:
+            if self.close2Open(instance, now):
+                logger.info("open circuit break for %s:%d", instance.get_host(), instance.get_port())
+                result.instance_2_open.append(instance)
+                continue
+            elif self.open2halfopen(instance, now):
+                logger.info("half open circuit break for %s:%d", instance.get_host(), instance.get_port())
+                result.instance_2_halfopen.append(instance)
+                continue
+            elif self.halfopen2open(instance, now):
+                logger.info("open circuit break after half open for %s:%d", instance.get_host(), instance.get_port())
+                result.instance_2_open.append(instance)
+                continue
+            elif self.halfopen2close(instance, now):
+                logger.info("close circuit break after half open for %s:%d", instance.get_host(),
+                            instance.get_port())
+                result.instance_2_close.append(instance)
+                continue
+
+        return result
+
+    def close2Open(self, instance: Instance, now: int) -> bool:
+        status = instance.get_circuit_breaker_status().status
+        if status == CBStatusEnum.Open:
+            metrics = instance.get_local_value().circuit_breaker_metrics
+            if metrics is not None:
+                self._consume_due_error_rate_check(metrics, now)
+            return False
+        if status != CBStatusEnum.Closed:
+            return False
+
+        metrics = instance.get_local_value().circuit_breaker_metrics
+        if metrics is None:
+            return False
+        if metrics.consecutive_triggered:
+            return True
+        if metrics.error_rate_check_at is None or now < metrics.error_rate_check_at:
+            return False
+        metrics.error_rate_check_at = None
+        if self._error_rate_reaches_threshold(metrics, now):
+            metrics.error_rate_suspended = True
+            return True
+        return False
+
+    def _error_rate_reaches_threshold(self, metrics, now: int) -> bool:
+        total_success, total_failed, _ = metrics.window.calc_interval_values(
+            now - self.plugin_config.metric_stat_time_window, now)
+        total_request = total_failed + total_success
+        if total_request < self.plugin_config.err_rate_request_threshold:
+            return False
+        return total_failed / total_request >= self.plugin_config.err_rate_threshold
+
+    def _consume_due_error_rate_check(self, metrics, now: int):
+        if metrics.error_rate_check_at is None or now < metrics.error_rate_check_at:
+            return
+        metrics.error_rate_check_at = None
+        if self._error_rate_reaches_threshold(metrics, now):
+            metrics.error_rate_suspended = True
+
+    def open2halfopen(self, instance: Instance, now: int) -> bool:
+        cb_status = instance.get_circuit_breaker_status()
+        if cb_status.status != CBStatusEnum.Open:
+            return False
+
+        if now - cb_status.ts < self.plugin_config.sleep_window:
+            return False
+        metrics = instance.get_local_value().circuit_breaker_metrics
+        if metrics is not None:
+            self._consume_due_error_rate_check(metrics, now)
+        return True
+
+    def halfopen2open(self, instance: Instance, now: int) -> bool:
+        cb_status = instance.get_circuit_breaker_status()
+        if cb_status.status != CBStatusEnum.HalfOpen:
+            return False
+        return cb_status.failed_requests_after_half_open > 0
+
+    def halfopen2close(self, instance: Instance, now: int) -> bool:
+        cb_status = instance.get_circuit_breaker_status()
+        if cb_status.status != CBStatusEnum.HalfOpen:
+            return False
+        return (cb_status.failed_requests_after_half_open == 0 and
+                cb_status.successful_requests_after_half_open >= self.plugin_config.success_count_after_halfopen)
+
+    def next_check_time(self, instance: Instance):
+        if not self.enabled:
+            return None
+        status = instance.get_circuit_breaker_status()
+        if status.get_status() == CBStatusEnum.Open:
+            due = status.ts + self.plugin_config.sleep_window
+            metrics = instance.get_local_value().circuit_breaker_metrics
+            if metrics is not None and metrics.error_rate_check_at is not None:
+                due = min(due, metrics.error_rate_check_at)
+            return due
+        metrics = instance.get_local_value().circuit_breaker_metrics
+        if status.get_status() == CBStatusEnum.Closed and metrics is not None:
+            return metrics.error_rate_check_at
+        return None
+
+    def on_state_change(self, instance: Instance):
+        metrics = instance.get_local_value().circuit_breaker_metrics
+        if metrics is None:
+            return
+        status = instance.get_circuit_breaker_status().get_status()
+        if status == CBStatusEnum.Open:
+            metrics.consecutive_triggered = False
+        elif status == CBStatusEnum.Closed:
+            metrics.consecutive_suspended = False
+            metrics.error_rate_suspended = False
+
+    def get_half_open_request_count(self):
+        return self.plugin_config.request_count_after_halfopen
+
+    def on_plugin_event(self, event_type, params):
+        # Counters are created lazily on the first report, matching Java.
+        return
+

polaris/plugin/circuit_breaker/config.py

@@ -0,0 +1,36 @@
+# 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.config.default import DefaultConf
+
+
+class DefaultOptions:
+    # 连续错误数统计周期, 默认1分钟
+    DefaultContinuousWindow = 60000
+    # 触发熔断的连续错误数，默认10
+    DefaultContinuousErrorThreshold = DefaultConf.DefaultErrorCount
+    # 窗口时长(ms)
+    DefaultMetricStatWindow = DefaultConf.DefaultInterval
+    # 滑桶数量
+    DefaultMetricBucketCount = 10
+    DefaultSleepTime = DefaultConf.DefaultSleepWindow
+
+    # composite 默认规则按恢复成功数分配半开请求。
+    DefaultRequestCountAfterHalfOpen = DefaultConf.DefaultSuccessCountAfterHalfOpen
+    # 半开状态后默认3个成功请求则恢复
+    DefaultSuccessCountAfterHalfOpen = DefaultConf.DefaultSuccessCountAfterHalfOpen
+
+    DefaultErrRateThreshold = DefaultConf.DefaultErrorPercent / 100
+    DefaultErrRateRequestThreshold = DefaultConf.DefaultMinimumRequest

polaris/plugin/event/__init__.py

@@ -0,0 +1,21 @@
+# 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.
+
+"""Event reporter plugins."""
+
+from .pushgateway import PushGatewayEventReporter
+
+__all__ = ["PushGatewayEventReporter"]

polaris/plugin/event/pushgateway.py

@@ -0,0 +1,202 @@
+# 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.
+
+"""Batch SDK events and report them to the Polaris event Pushgateway."""
+
+from __future__ import annotations
+
+import asyncio
+from datetime import datetime
+import json
+import random
+from urllib.parse import urlsplit, urlunsplit
+
+from aiohttp import ClientSession, ClientTimeout
+
+from polaris.pkg.model.context import ContextKeyEventCenter
+from polaris.pkg.model.event import is_remote_reportable
+from polaris.pkg.model.service import GetOneInstanceRequest
+from polaris.plugin_manager import PluginType, register_plugin
+
+
+def _event_payload(event):
+    """Convert the public event to the flat wire fields used by Java and Go."""
+    return {
+        "event_type": event.event_type,
+        "event_name": event.event_name,
+        "event_time": datetime.fromtimestamp(event.timestamp / 1000).isoformat(timespec="milliseconds"),
+        "client_id": event.client_id,
+        "client_ip": event.client_ip,
+        "namespace": event.namespace,
+        "service": event.service,
+        "instance_id": event.instance_id,
+        "host": event.host,
+        "port": str(event.port) if event.port else "",
+        "previous_status": event.previous_status,
+        "current_status": event.current_status,
+        "resource_type": "INSTANCE",
+        "rule_name": event.rule_name,
+        "reason": event.reason,
+        "additional_params": event.additional,
+    }
+
+
+@register_plugin(PluginType.EVENT_REPORTER, "pushgateway")
+class PushGatewayEventReporter:
+    """Own one context-local event queue, batching task and HTTP session."""
+
+    def __init__(self, init_ctx):
+        reporter = init_ctx.config.get_global().get_event_reporter()
+        self.config = reporter.get_pushgateway()
+        self.enabled = reporter.is_enable() and "pushgateway" in reporter.get_chain()
+        self.value_context = init_ctx.value_ctx
+        self.logger = init_ctx.logger.get_logger("event") if init_ctx.logger is not None else None
+        self.engine = None
+        self.queue = None
+        self.task = None
+        self.session = None
+        self.stopping = None
+        self.closed = False
+        self.random = random.Random()
+
+    def on_sdk_event(self, event):
+        """Enqueue one Java-reportable event without blocking SDK control flow."""
+        if not self.enabled or self.closed or self.queue is None or not is_remote_reportable(event):
+            return
+        try:
+            self.queue.put_nowait(event)
+        except asyncio.QueueFull:
+            if self.logger is not None:
+                self.logger.warning("event Pushgateway queue is full; dropping %s", event.event_name)
+
+    async def start(self, engine):
+        """Create queue resources and subscribe on the context owner loop."""
+        if not self.enabled:
+            return
+        self.engine = engine
+        self.queue = asyncio.Queue(maxsize=self.config.event_queue_size)
+        self.stopping = asyncio.Event()
+        self.session = ClientSession(timeout=ClientTimeout(total=3))
+        event_center = self.value_context.core_map.get(ContextKeyEventCenter)
+        if event_center is not None:
+            event_center.register_listener(self)
+        self.task = asyncio.create_task(self._run(), name="polaris-event-pushgateway")
+
+    async def _run(self):
+        interval = self.config.push_interval / 1000
+        while not self.closed:
+            try:
+                await asyncio.wait_for(self.stopping.wait(), interval)
+            except TimeoutError:
+                pass
+            await self._flush_batches()
+            if self.stopping.is_set():
+                return
+
+    async def _address(self):
+        if self.config.address:
+            address = self.random.choice(self.config.address)
+        else:
+            node = await self.engine._async_get_one_instance(GetOneInstanceRequest(
+                namespace=self.config.namespace, service=self.config.service))
+            if node is None:
+                raise RuntimeError("No event Pushgateway instance available")
+            host = node.get_host()
+            address = f"[{host}]:{node.get_port()}" if ":" in host else f"{host}:{node.get_port()}"
+        url = urlsplit(address if "://" in address else f"http://{address}")
+        host = self.config.override_host or url.hostname
+        netloc = f"[{host}]" if ":" in host else host
+        if url.port:
+            netloc += f":{url.port}"
+        return urlunsplit((url.scheme or "http", netloc, self.config.report_path, "", ""))
+
+    def _log_post(self, level, message, *args):
+        if self.logger is None:
+            return
+        getattr(self.logger, level)(message, *args)
+
+    def _log_post_events(self, level, events, prefix, error=None):
+        """Record one line per event, including the same text as the local event log."""
+        for event in events:
+            detail = event.to_log_message()
+            if error is None:
+                self._log_post(level, "%s: %s", prefix, detail)
+            else:
+                self._log_post(level, "%s: %s: %s", prefix, detail, error)
+
+    async def _post(self, events):
+        body = json.dumps({"batch": [_event_payload(event) for event in events]},
+                          ensure_ascii=False, separators=(",", ":"))
+        try:
+            target = await self._address()
+        except Exception as error:
+            self._log_post_events("warning", events, "failed to report event to Pushgateway", error)
+            raise
+        last_error = None
+        for attempt in range(1, self.config.max_retries + 1):
+            try:
+                async with self.session.post(
+                        target, data=body.encode("utf-8"), headers={"Content-Type": "application/json"}) as response:
+                    await response.read()
+                    if not 200 <= response.status < 300:
+                        raise RuntimeError(f"Pushgateway returned HTTP {response.status}")
+                self._log_post_events("info", events, "reported event to Pushgateway")
+                return
+            except Exception as error:
+                last_error = error
+                self._log_post_events(
+                    "warning", events,
+                    f"failed to report event to Pushgateway (attempt {attempt}/{self.config.max_retries})",
+                    error)
+                if attempt < self.config.max_retries:
+                    await asyncio.sleep(self.config.retry_interval / 1000)
+        raise last_error
+
+    async def _flush_batches(self):
+        while self.queue is not None and not self.queue.empty():
+            events = []
+            while len(events) < self.config.max_batch_size:
+                try:
+                    events.append(self.queue.get_nowait())
+                except asyncio.QueueEmpty:
+                    break
+            if not events:
+                return
+            try:
+                await self._post(events)
+            except Exception:
+                pass
+
+    async def close(self):
+        """Stop consuming, flush accepted events, and close the HTTP session."""
+        if self.closed:
+            return
+        self.closed = True
+        event_center = self.value_context.core_map.get(ContextKeyEventCenter) if self.value_context else None
+        if event_center is not None:
+            event_center.unregister_listener(self)
+        if self.stopping is not None:
+            self.stopping.set()
+        if self.task is not None:
+            await asyncio.gather(self.task, return_exceptions=True)
+            self.task = None
+        if self.session is not None:
+            await self.session.close()
+            self.session = None
+
+    def destroy(self):
+        """Synchronous plugin lifecycle hook; async resources close with the engine."""
+        return None

polaris/plugin/load_balancer/__init__.py

@@ -0,0 +1,24 @@
+# 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 BaseLoadBalancer
+from .random import RandomLoadBalancer
+from .weighted_random import WeightedRandomLoadBalancer
+
+__all__ = [
+    "BaseLoadBalancer",
+    "RandomLoadBalancer",
+    "WeightedRandomLoadBalancer",
+]

polaris/plugin/load_balancer/base.py

@@ -0,0 +1,30 @@
+# 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 polaris.pkg.model.service import Instance, ServiceInstances
+
+__all__ = ["BaseLoadBalancer"]
+
+
+class BaseLoadBalancer(ABC):
+    """
+    负载均衡选择一个实例
+    """
+
+    @abstractmethod
+    def choose_instance(self, instances: ServiceInstances) -> Instance:
+        pass

polaris/plugin/load_balancer/random.py

@@ -0,0 +1,39 @@
+# 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 random import randint
+from polaris.plugin_manager import PluginType, register_plugin
+from polaris.pkg.model.service import ServiceInstances, Instance
+from ...pkg.model.error import ErrorCode, SDKError
+from polaris.plugin_manager import InitContext
+
+from .base import BaseLoadBalancer
+
+
+@register_plugin(PluginType.LOAD_BALANCE, 'random')
+class RandomLoadBalancer(BaseLoadBalancer):
+    def __init__(self, init_ctx: InitContext = None):
+        self.init_ctx = init_ctx
+
+    def choose_instance(self, instances: ServiceInstances) -> Instance:
+        svc_instances = instances.get_instances()
+        if len(svc_instances) == 0:
+            raise SDKError(ErrorCode.ErrCodeAPIInstanceNotFound, "instances of %s:%s not found for load balance"
+                           % (instances.get_namespace(), instances.get_service()))
+        n = randint(0, len(svc_instances) - 1)
+        return svc_instances[n]
+
+
+__all__ = ["RandomLoadBalancer"]

polaris/plugin/load_balancer/weighted_random.py

@@ -0,0 +1,50 @@
+# 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 BaseLoadBalancer
+from ...pkg.model.service import ServiceInstances, Instance
+import random
+from ...pkg.model.error import SDKError, ErrorCode
+from polaris.plugin_manager import PluginType, register_plugin, InitContext
+
+
+@register_plugin(PluginType.LOAD_BALANCE, 'weightedRandom')
+class WeightedRandomLoadBalancer(BaseLoadBalancer):
+    def __init__(self, init_ctx: InitContext = None):
+        self.config = init_ctx.config if init_ctx is not None else None
+        self.init_ctx = init_ctx
+
+    def choose_instance(self, instances: ServiceInstances) -> Instance:
+        svc_instances = instances.get_instances()
+        if len(svc_instances) == 0:
+            raise SDKError(ErrorCode.ErrCodeAPIInstanceNotFound, "instances of %s:%s not found for load balance"
+                           % (instances.get_namespace(), instances.get_service()))
+        total_weight = 0
+        curr_sum = 0
+        ret_instance = None
+        for i in range(len(svc_instances)):
+            total_weight += svc_instances[i].get_weight()
+        if total_weight == 0:
+            return None
+        ra = random.randint(1, total_weight)
+        for i in range(len(svc_instances)):
+            curr_sum += svc_instances[i].get_weight()
+            if ra <= curr_sum:
+                ret_instance = svc_instances[i]
+                break
+        return ret_instance
+
+
+__all__ = ["WeightedRandomLoadBalancer"]