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

polaris/plugin/server_connector/grpc_connector/grpc_client.py

@@ -0,0 +1,384 @@
+# 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.
+
+"""Server connector plugin backed by the Polaris gRPC API."""
+
+from __future__ import annotations
+
+import asyncio
+from dataclasses import replace
+from collections.abc import AsyncIterator
+from contextlib import asynccontextmanager
+import time
+
+from polarismesh_specification.api.v1.service_manage import response_pb2
+
+from polaris.pkg.model.error import ErrorCode, SDKError, ServerCode, ensure_response
+from polaris.pkg.model.server import (
+    InstanceDeRegisterRequest,
+    InstanceDiscoverRequest,
+    InstanceHeartbeatRequest,
+    InstanceRegisterRequest,
+    InstanceRegisterResponse,
+    ReportClientRequest,
+    ReportClientResponse,
+)
+from polaris.pkg.model.service import GetOneInstanceRequest, InstancesResponse
+from ..base import BaseServerConnector
+from ..convert import (
+    contract_request_to_proto,
+    contract_response_from_proto,
+    deregister_request_to_proto,
+    discover_request_to_proto,
+    heartbeat_request_to_proto,
+    register_request_to_proto,
+    report_client_to_proto,
+)
+from polaris.plugin_manager import InitContext, PluginType, register_plugin
+
+from .connection import GrpcConnection, GrpcSettings
+from .tls import channel_credentials
+
+
+@register_plugin(PluginType.SERVER_CONNECTOR, "grpc")
+class GrpcConnector(BaseServerConnector):
+    """Adapt internal SDK request objects to specification gRPC calls."""
+
+    def __init__(self, init_ctx: InitContext) -> None:
+        self.init_ctx = init_ctx
+        self.config = init_ctx.config
+        connector_config = self.config.get_global().get_server_connector()
+        api_config = self.config.get_global().get_api()
+        cache_config = self.config.get_consumer().get_local_cache()
+        self.connection = GrpcConnection(
+            GrpcSettings(
+                addresses=connector_config.get_addresses(),
+                timeout_seconds=max(connector_config.get_message_timeout(), 1) / 1000,
+                token=connector_config.get_token(),
+                retry_attempts=api_config.get_max_retry_times(),
+                retry_backoff_seconds=max(api_config.get_retry_interval(), 0) / 1000,
+                refresh_interval_seconds=max(cache_config.get_service_refresh_interval(), 1) / 1000,
+                switch_interval_seconds=max(connector_config.get_server_switch_interval(), 1) / 1000,
+                idle_timeout_seconds=max(connector_config.get_connect_idle_timeout(), 1) / 1000,
+                credentials=channel_credentials(connector_config),
+            ),
+            context_logger=init_ctx.logger,
+        )
+        self._streams: dict[str, AsyncIterator[response_pb2.DiscoverResponse]] = {}
+        self._stream_locks: dict[str, asyncio.Lock] = {}
+        self._closed = False
+        self.engine = None
+        self._cluster_connections = {}
+        self._stream_connections = {}
+        self._stream_last_activity = {}
+        self._idle_task = None
+        self._request_slots = asyncio.Semaphore(connector_config.get_request_queue_size() + 1)
+        self.logger = init_ctx.logger.get_logger("network") if init_ctx.logger is not None else None
+        self.base_logger = init_ctx.logger.get_logger("base") if init_ctx.logger is not None else None
+
+    @asynccontextmanager
+    async def _request_slot(self):
+        """Bound concurrent requests; extra callers wait like Go's buffered task channel."""
+        await self._request_slots.acquire()
+        try:
+            yield
+        finally:
+            self._request_slots.release()
+
+    def start_address_switching(self):
+        """Start periodic address rotation and idle stream cleanup."""
+        self._start_address_switching(self.connection, self.engine.loop if self.engine is not None else None)
+        self._start_idle_cleanup(self.engine.loop if self.engine is not None else None)
+
+    def _start_address_switching(self, connection, loop=None):
+        connection.on_switch = lambda: self._on_address_switched(connection)
+        connection.start_switching(loop)
+
+    def _start_idle_cleanup(self, loop=None):
+        if self._closed or self._idle_task is not None:
+            return
+        loop = loop or asyncio.get_running_loop()
+        self._idle_task = loop.create_task(self._idle_cleanup_loop(), name="polaris-idle-stream-cleanup")
+
+    async def _idle_cleanup_loop(self):
+        interval = self.connection.settings.idle_timeout_seconds
+        while not self._closed:
+            await asyncio.sleep(interval)
+            if self._closed:
+                return
+            await self.close_idle_streams()
+
+    async def close_idle_streams(self):
+        """Close idle Discover streams while retaining shared gRPC channels."""
+        timeout = self.connection.settings.idle_timeout_seconds
+        now = time.monotonic()
+        for key, last_activity in list(self._stream_last_activity.items()):
+            if now - last_activity < timeout:
+                continue
+            lock = self._stream_locks.get(key)
+            if lock is None or lock.locked():
+                continue
+            async with lock:
+                current_activity = self._stream_last_activity.get(key)
+                if current_activity != last_activity or now - current_activity < timeout:
+                    continue
+                stream = self._streams.pop(key, None)
+                self._stream_connections.pop(key, None)
+                self._stream_last_activity.pop(key, None)
+                self._stream_locks.pop(key, None)
+                if stream is not None:
+                    await stream.aclose()
+                if self.logger is not None:
+                    self.logger.debug("closed idle Discover stream %s", key)
+
+    async def _stop_idle_cleanup(self):
+        if self._idle_task is not None:
+            self._idle_task.cancel()
+            await asyncio.gather(self._idle_task, return_exceptions=True)
+            self._idle_task = None
+
+    async def _on_address_switched(self, connection):
+        """Close streams pinned to the old endpoint so the next read reconnects."""
+        keys = [key for key, owner in self._stream_connections.items() if owner is connection]
+        for key in keys:
+            stream = self._streams.get(key)
+            if stream is None:
+                self._stream_connections.pop(key, None)
+                continue
+            lock = self._stream_locks.get(key)
+            if lock is not None and not lock.locked():
+                async with lock:
+                    if self._streams.get(key) is stream:
+                        self._streams.pop(key, None)
+                        self._stream_connections.pop(key, None)
+                        self._stream_last_activity.pop(key, None)
+                    await stream.aclose()
+            else:
+                await stream.aclose()
+                self._streams.pop(key, None)
+                self._stream_connections.pop(key, None)
+                self._stream_last_activity.pop(key, None)
+
+    async def _connection(self, heartbeat=False):
+        system = self.config.get_global().get_system()
+        cluster = system.get_health_check_cluster() if heartbeat else system.get_discover_cluster()
+        if not cluster.namespace or not cluster.service or self.engine is None:
+            return self.connection
+        key = (cluster.namespace, cluster.service)
+        from polaris.pkg.model.service import GetInstancesRequest
+        snapshot = await self.engine._query_instances(GetInstancesRequest(
+            namespace=cluster.namespace, service=cluster.service), "healthy")
+        if snapshot is None or not snapshot.instances:
+            raise SDKError(ErrorCode.ErrCodeAPIInstanceNotFound, f"No system service instance for {key}")
+        addresses = []
+        for node in snapshot.instances:
+            host = node.get_host()
+            addresses.append(f"[{host}]:{node.get_port()}" if ":" in host else f"{host}:{node.get_port()}")
+        if key not in self._cluster_connections:
+            connection = GrpcConnection(replace(self.connection.settings, addresses=addresses),
+                                        context_logger=self.init_ctx.logger)
+            connection.target_service = key
+            connection.stat_reporter = self.connection.stat_reporter
+            connection.address_resolver = lambda: self._connection(heartbeat=heartbeat)
+            self._cluster_connections[key] = connection
+        connection = self._cluster_connections[key]
+        self._start_address_switching(connection)
+        connection._addresses = addresses
+        return connection
+
+    async def register_instance(self, request: InstanceRegisterRequest) -> InstanceRegisterResponse:
+        connection = await self._connection()
+        async with self._request_slot():
+            response = await connection.register_instance(
+                register_request_to_proto(request), auto_heartbeat=request.auto_heartbeat,
+            )
+        ensure_response(response, (ServerCode.ExecuteSuccess, ServerCode.ExistedResource))
+        instance_id = response.instance.id.value if response.HasField("instance") else ""
+        if self.logger is not None:
+            self.logger.info(
+                "instance registered namespace=%s service=%s host=%s port=%s instanceId=%s autoHeartbeat=%s",
+                request.namespace, request.service, request.host, request.port, instance_id,
+                request.auto_heartbeat,
+            )
+        if self.base_logger is not None:
+            metadata = dict(getattr(request, "metadata", {}) or {})
+            self.base_logger.info(
+                "registerInstance success namespace=%s service=%s host=%s port=%s "
+                "instanceId=%s metadataSize=%d metadataKeys=%s",
+                request.namespace, request.service, request.host, request.port, instance_id,
+                len(metadata), sorted(metadata),
+            )
+        return InstanceRegisterResponse(instance_id)
+
+    async def deregister_instance(self, request: InstanceDeRegisterRequest) -> None:
+        connection = await self._connection()
+        async with self._request_slot():
+            response = await connection.deregister_instance(deregister_request_to_proto(request))
+        ensure_response(response, (ServerCode.ExecuteSuccess, ServerCode.NotFoundResource))
+        if self.logger is not None:
+            self.logger.info(
+                "instance deregistered namespace=%s service=%s host=%s port=%s instanceId=%s",
+                request.namespace, request.service, request.host, request.port, request.instance_id,
+            )
+        if self.base_logger is not None:
+            self.base_logger.info(
+                "deregisterInstance success namespace=%s service=%s host=%s port=%s instanceId=%s",
+                request.namespace, request.service, request.host, request.port, request.instance_id,
+            )
+
+    @staticmethod
+    def _stream_key(request: InstanceDiscoverRequest) -> str:
+        return f"{request.namespace}\\x00{request.name}\\x00{request.type}"
+
+    async def discover(
+        self,
+        request: InstanceDiscoverRequest,
+        use_discover_cache: bool = True,
+    ) -> response_pb2.DiscoverResponse:
+        del use_discover_cache
+        if self._closed:
+            raise SDKError(ErrorCode.ErrCodeInvalidStateError, "gRPC connector has been closed")
+        key = self._stream_key(request)
+        lock = self._stream_locks.setdefault(key, asyncio.Lock())
+        async with lock:
+            stream = self._streams.get(key)
+            if stream is None:
+                system = self.config.get_global().get_system()
+                system_keys = {(system.get_discover_cluster().namespace, system.get_discover_cluster().service),
+                               (system.get_health_check_cluster().namespace, system.get_health_check_cluster().service)}
+                connection = (self.connection if (request.namespace, request.name) in system_keys
+                              else await self._connection())
+                stream = connection.discover(discover_request_to_proto(request))
+                self._streams[key] = stream
+                self._stream_connections[key] = connection
+                self._stream_last_activity[key] = time.monotonic()
+                if self.logger is not None:
+                    self.logger.info(
+                        "Discover stream opened namespace=%s service=%s type=%s revision=%s",
+                        request.namespace, request.name, request.type, request.revision,
+                    )
+            try:
+                async with self._request_slot():
+                    response = await anext(stream)
+                self._stream_last_activity[key] = time.monotonic()
+            except StopAsyncIteration:
+                self._streams.pop(key, None)
+                self._stream_connections.pop(key, None)
+                self._stream_last_activity.pop(key, None)
+                if self.logger is not None:
+                    self.logger.warning(
+                        "Discover stream closed namespace=%s service=%s type=%s",
+                        request.namespace, request.name, request.type,
+                    )
+                raise SDKError(ErrorCode.ErrCodeNetworkError, f"Discover stream closed for {request.name}")
+            except (asyncio.CancelledError, Exception):
+                self._streams.pop(key, None)
+                self._stream_connections.pop(key, None)
+                self._stream_last_activity.pop(key, None)
+                await stream.aclose()
+                raise
+        ensure_response(response)
+        if self.logger is not None:
+            self.logger.debug(
+                "Discover response namespace=%s service=%s type=%s revision=%s instances=%s",
+                request.namespace, request.name, request.type, response.service.revision.value,
+                len(response.instances),
+            )
+        return response
+
+    async def stop_discover(self, request: InstanceDiscoverRequest) -> None:
+        """Close one idle resource stream without closing shared gRPC channels."""
+        key = self._stream_key(request)
+        lock = self._stream_locks.get(key)
+        if lock is None:
+            return
+        async with lock:
+            stream = self._streams.pop(key, None)
+            self._stream_connections.pop(key, None)
+            self._stream_last_activity.pop(key, None)
+            try:
+                if stream is not None:
+                    await stream.aclose()
+            finally:
+                self._stream_locks.pop(key, None)
+                if self.logger is not None:
+                    self.logger.info(
+                        "Discover stream stopped namespace=%s service=%s type=%s",
+                        request.namespace, request.name, request.type,
+                    )
+
+    async def heartbeat(self, request: InstanceHeartbeatRequest) -> None:
+        connection = await self._connection(heartbeat=True)
+        async with self._request_slot():
+            response = await connection.heartbeat(heartbeat_request_to_proto(request))
+        ensure_response(response)
+
+    async def report_client(self, request: ReportClientRequest) -> ReportClientResponse:
+        connection = await self._connection()
+        async with self._request_slot():
+            response = await connection.report_client(report_client_to_proto(request))
+        ensure_response(response)
+        if not response.HasField("client") or not response.client.HasField("location"):
+            return ReportClientResponse("", "", "")
+        location = response.client.location
+        return ReportClientResponse(location.region.value, location.zone.value, location.campus.value)
+
+    async def report_service_contract(self, request):
+        """Report the contract over the discovery connection's channel."""
+        connection = await self._connection()
+        async with self._request_slot():
+            response = await connection._unary(
+                "ReportServiceContract", contract_request_to_proto(request),
+                timeout_seconds=request.timeout / 1000 if request.timeout else None,
+            )
+        ensure_response(response)
+
+    async def get_service_contract(self, request):
+        """Retrieve a contract without adding another discovery cache type."""
+        connection = await self._connection()
+        async with self._request_slot():
+            response = await connection._unary(
+                "GetServiceContract", contract_request_to_proto(request),
+                timeout_seconds=request.timeout / 1000 if request.timeout else None,
+            )
+        ensure_response(response)
+        if not response.HasField("serviceContract"):
+            raise SDKError(ErrorCode.ErrCodeInvalidResponse, "missing service contract response")
+        return contract_response_from_proto(response.serviceContract)
+
+    def get_one_instance(self, request: GetOneInstanceRequest) -> InstancesResponse:
+        del request
+        raise SDKError(ErrorCode.ErrCodePluginError, "single-instance server RPC is not implemented")
+
+    async def close(self) -> None:
+        """Close discovery streams and their gRPC channels."""
+        if self._closed:
+            return
+        self._closed = True
+        await self._stop_idle_cleanup()
+        streams = list(self._streams.values())
+        self._streams.clear()
+        self._stream_locks.clear()
+        self._stream_connections.clear()
+        self._stream_last_activity.clear()
+        for stream in streams:
+            try:
+                await stream.aclose()
+            except RuntimeError:
+                pass
+        await self.connection.close()
+        for connection in self._cluster_connections.values():
+            await connection.close()
+        self._cluster_connections.clear()

polaris/plugin/server_connector/grpc_connector/tls.py

@@ -0,0 +1,45 @@
+# 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.
+
+"""Load configured TLS material once, refusing incomplete or invalid credentials."""
+
+from pathlib import Path
+import ssl
+
+import grpc
+
+from polaris.pkg.model.error import ErrorCode, SDKError
+
+
+def channel_credentials(config):
+    """Build validated gRPC credentials, or None only when no TLS files are configured."""
+    ca, cert, key = config.trusted_ca_file, config.cert_file, config.key_file
+    if not any((ca, cert, key)):
+        return None
+    if bool(cert) != bool(key):
+        raise SDKError(ErrorCode.ErrCodeAPIInvalidConfig, "TLS certFile and keyFile must be configured together")
+    try:
+        roots = Path(ca).read_bytes() if ca else None
+        chain = Path(cert).read_bytes() if cert else None
+        private_key = Path(key).read_bytes() if key else None
+        validator = ssl.create_default_context()
+        if roots is not None:
+            validator.load_verify_locations(cadata=roots.decode("ascii"))
+        if cert:
+            validator.load_cert_chain(cert, key, password=lambda: "")
+        return grpc.ssl_channel_credentials(roots, private_key, chain)
+    except (OSError, ValueError, UnicodeError, grpc.RpcError) as error:
+        raise SDKError(ErrorCode.ErrCodeAPIInvalidConfig,
+                       f"Invalid TLS certificate configuration: {error}") from error

polaris/plugin/service_router/__init__.py

@@ -0,0 +1,28 @@
+# 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 BaseServiceRouter, RouteInfo, RouteResult
+from .isolated import IsolatedRouter
+from .metadata import MetadataRouter
+from .recover import RecoverRouter
+
+__all__ = [
+    "BaseServiceRouter",
+    "IsolatedRouter",
+    "MetadataRouter",
+    "RecoverRouter",
+    "RouteInfo",
+    "RouteResult",
+]

polaris/plugin/service_router/base.py

@@ -0,0 +1,105 @@
+# 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 import service
+from polaris.pkg.model.rule import ServiceRule
+from polaris.pkg.model.service import ServiceInfo
+
+__all__ = [
+    "BaseServiceRouter",
+    "CanaryMetaKey",
+    "CanaryMetadataEnable",
+    "MetadataFailoverKey",
+    "NearbyKeyAreaWithCampus",
+    "NearbyKeyAreaWithRegion",
+    "NearbyKeyAreaWithZone",
+    "NearbyMetadataEnable",
+    "RouteInfo",
+    "RouteResult",
+    "SetEnableKey",
+    "SetEnableValue",
+    "SetNameKey",
+]
+
+# 保存客户端地域信息 idc key
+NearbyKeyAreaWithCampus = "client_area_campus"
+# 保存客户端地域信息 zone key
+NearbyKeyAreaWithZone = "client_area_zone"
+# 保存客户端地域信息 region key
+NearbyKeyAreaWithRegion = "client_area_region"
+
+NearbyMetadataEnable = "internal-enable-nearby"
+CanaryMetadataEnable = "internal-canary"
+CanaryMetaKey = "canary"
+
+SetEnableKey = "internal-enable-set"
+SetEnableValue = "Y"
+SetNameKey = "internal-set-name"
+MetadataFailoverKey = "internal-metadata-failover-type"
+
+
+class RouteInfo:
+    def __init__(self, source_service: ServiceInfo = None, source_routerule: ServiceRule = None,
+                 dest_service: ServiceInfo = None, dest_routerule: ServiceRule = None,
+                 include_unhealthy_instances: bool = False, include_circuitbreak_instances: bool = False,
+                 canary: str = "", metadata: Dict[str, str] = None,
+                 metadata_failover_type: str = None):
+        # 源服务信息
+        self.source_service = source_service
+        # 源路由规则
+        self.source_routerule = source_routerule
+        # 目标服务信息
+        self.dest_service = dest_service
+        # 目标路由规则
+        self.dest_routerule = dest_routerule
+        # 是否包含不健康的服务实例，默认false
+        self.include_unhealthy_instances = include_unhealthy_instances
+        # 是否包含被熔断的服务实例，默认false
+        self.include_circuitbreak_instances = include_circuitbreak_instances
+        # 标识是否不需要执行全死全活兜底
+        # 对于全死全活插件，以及就近路由插件等，已经做了最小实例数检查，则可以设置该属性为true
+        # 需要插件内部进行设置
+        self.ignore_filter_only_on_end_chain = False
+        # 可动态调整路由插件是否启用，不存在或者为true代表启用
+        # key为路由插件的id
+        self.chain_enables = {}
+        # 金丝雀
+        self.canary = canary
+        # 请求 metadata，用于 metadataRouter
+        self.metadata = {} if metadata is None else metadata
+        # none / all / others；None 表示使用服务或插件配置
+        self.metadata_failover_type = metadata_failover_type
+
+
+class RouteResult:
+    def __init__(self, instances: List[service.Instance]):
+        # 根据路由规则过滤后的目标服务实例列表，假如重定向则列表为空
+        self.instances = instances
+
+
+class BaseServiceRouter(ABC):
+    """
+    获取规则过滤后的服务实例列表
+    """
+
+    @abstractmethod
+    def get_filtered_instances(self, route_info: RouteInfo, instances: service.ServiceInstances) -> RouteResult:
+        pass
+
+    def enable(self, route_info: RouteInfo, instances: service.ServiceInstances) -> bool:
+        return True

polaris/plugin/service_router/isolated.py

@@ -0,0 +1,35 @@
+# 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
+from polaris.pkg.model import service
+from polaris.plugin.service_router.base import BaseServiceRouter, RouteInfo, RouteResult
+from polaris.plugin_manager import InitContext, PluginType, register_plugin
+
+
+@register_plugin(PluginType.SERVICE_ROUTER, DefaultConf.DefaultServiceRouterIsolated)
+class IsolatedRouter(BaseServiceRouter):
+    """Drop isolated instances and instances whose weight is zero."""
+
+    def __init__(self, init_ctx: InitContext = None):
+        self.init_ctx = init_ctx
+
+    def enable(self, route_info: RouteInfo, instances: service.ServiceInstances) -> bool:
+        return route_info.chain_enables.get(DefaultConf.DefaultServiceRouterIsolated, True)
+
+    def get_filtered_instances(self, route_info: RouteInfo, instances: service.ServiceInstances) -> RouteResult:
+        selected = [instance for instance in instances.get_instances()
+                    if instance.get_weight() != 0 and not instance.is_isolated()]
+        return RouteResult(selected)