#1 Create Nacos service discovery provider

.github/workflows/main.yml

@@ -0,0 +1,28 @@
+# This workflow will build a .NET project
+# For more information see: https://docs.github.com/en/actions/automating-builds-and-tests/building-and-testing-net
+
+name: Main
+
+on:
+ push:
+   branches: [ "main" ]
+
+jobs:
+  build:
+    runs-on: ubuntu-latest
+    strategy:
+      matrix:
+        dotnet-version: [ '8.0', '9.0' ]
+
+    steps:
+    - uses: actions/checkout@v4
+    - name: Setup .NET ${{ matrix.dotnet-version }}
+      uses: actions/setup-dotnet@v3
+      with:
+        dotnet-version: ${{ matrix.dotnet-version }}.x
+    - name: Restore
+      run: dotnet restore ./Ocelot.Discovery.Nacos.sln -p:TargetFramework=net${{ matrix.dotnet-version }}
+    - name: Build
+      run: dotnet build --no-restore ./Ocelot.Discovery.Nacos.sln --framework net${{ matrix.dotnet-version }}
+    - name: Unit Tests
+      run: dotnet test --no-restore --no-build --verbosity minimal --framework net${{ matrix.dotnet-version }} ./unit/Ocelot.Discovery.Nacos.UnitTests.csproj

.github/workflows/pr.yml

@@ -0,0 +1,22 @@
+# This workflow will build a .NET project
+# For more information see: https://docs.github.com/en/actions/automating-builds-and-tests/building-and-testing-net
+
+name: PR
+
+on: pull_request
+
+jobs:
+  build:
+    runs-on: ubuntu-latest
+    steps:
+    - uses: actions/checkout@v4
+    - name: Setup .NET 9.0
+      uses: actions/setup-dotnet@v3
+      with:
+        dotnet-version: 9.0.x
+    - name: Restore
+      run: dotnet restore ./Ocelot.Discovery.Nacos.sln -p:TargetFramework=net9.0
+    - name: Build
+      run: dotnet build --no-restore ./Ocelot.Discovery.Nacos.sln --framework net9.0
+    - name: Unit Tests
+      run: dotnet test --no-restore --no-build --verbosity normal --framework net9.0 ./unit/Ocelot.Discovery.Nacos.UnitTests.csproj

.gitignore

@@ -398,3 +398,5 @@ FodyWeavers.xsd
 
 # JetBrains Rider
 *.sln.iml
+.idea/*
+/Ocelot.Discovery.Nacos/.idea

Ocelot.Discovery.Nacos.sln

@@ -0,0 +1,31 @@
+
+Microsoft Visual Studio Solution File, Format Version 12.00
+# Visual Studio Version 17
+VisualStudioVersion = 17.12.35527.113
+MinimumVisualStudioVersion = 10.0.40219.1
+Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "Ocelot.Discovery.Nacos", "src\Ocelot.Discovery.Nacos.csproj", "{CEF24699-3E41-D971-ACCA-FEF5CCB2011C}"
+EndProject
+Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "Ocelot.Discovery.Nacos.UnitTests", "unit\Ocelot.Discovery.Nacos.UnitTests.csproj", "{FAD17C0B-4F8F-99A6-1419-9665E4210346}"
+EndProject
+Global
+	GlobalSection(SolutionConfigurationPlatforms) = preSolution
+		Debug|Any CPU = Debug|Any CPU
+		Release|Any CPU = Release|Any CPU
+	EndGlobalSection
+	GlobalSection(ProjectConfigurationPlatforms) = postSolution
+		{CEF24699-3E41-D971-ACCA-FEF5CCB2011C}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
+		{CEF24699-3E41-D971-ACCA-FEF5CCB2011C}.Debug|Any CPU.Build.0 = Debug|Any CPU
+		{CEF24699-3E41-D971-ACCA-FEF5CCB2011C}.Release|Any CPU.ActiveCfg = Release|Any CPU
+		{CEF24699-3E41-D971-ACCA-FEF5CCB2011C}.Release|Any CPU.Build.0 = Release|Any CPU
+		{FAD17C0B-4F8F-99A6-1419-9665E4210346}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
+		{FAD17C0B-4F8F-99A6-1419-9665E4210346}.Debug|Any CPU.Build.0 = Debug|Any CPU
+		{FAD17C0B-4F8F-99A6-1419-9665E4210346}.Release|Any CPU.ActiveCfg = Release|Any CPU
+		{FAD17C0B-4F8F-99A6-1419-9665E4210346}.Release|Any CPU.Build.0 = Release|Any CPU
+	EndGlobalSection
+	GlobalSection(SolutionProperties) = preSolution
+		HideSolutionNode = FALSE
+	EndGlobalSection
+	GlobalSection(ExtensibilityGlobals) = postSolution
+		SolutionGuid = {0E583663-7152-4575-9AE5-FF3D78AEAA1C}
+	EndGlobalSection
+EndGlobal

src/Nacos.cs

@@ -0,0 +1,64 @@
+using Ocelot.Values;
+using Service = Ocelot.Values.Service;
+
+namespace Ocelot.Discovery.Nacos;
+
+public class Nacos : IServiceDiscoveryProvider
+{
+    private readonly INacosNamingService _client;
+    private readonly string _serviceName;
+
+    public Nacos(string serviceName,INacosNamingService client)
+    {
+        _client = client;
+        _serviceName = serviceName;
+    }
+
+    public async Task<List<Service>> GetAsync()
+    {
+        try
+        {
+            var instances = await _client.GetAllInstances(_serviceName)
+                .ConfigureAwait(false);
+
+            return instances?
+                .Where(i => i.Healthy && i.Enabled && i.Weight > 0) // 健康检查过滤
+                .Select(TransformInstance)
+                .ToList() ?? new List<Service>();
+        }
+        catch (NacosException ex)
+        {
+            throw ex;
+        }
+    }
+
+    private Service TransformInstance(Instance instance)
+    {
+        var metadata = instance.Metadata ?? new Dictionary<string, string>();
+
+        return new Service(
+            id: instance.InstanceId,
+            hostAndPort: new ServiceHostAndPort(instance.Ip, instance.Port),
+            name: instance.ServiceName,
+            version: metadata.GetValueOrDefault("version", "default"),
+            tags: ProcessMetadataTags(metadata)
+        );
+    }
+
+    private List<string> ProcessMetadataTags(IDictionary<string, string> metadata)
+    {
+        return metadata
+            .Where(kv => !_reservedKeys.Contains(kv.Key))
+            .Select(kv => FormatTag(kv))
+            .ToList();
+    }
+
+    private string FormatTag(KeyValuePair<string, string> kv)
+    {
+        var encodedKey = WebUtility.UrlEncode(kv.Key);
+        var encodedValue = WebUtility.UrlEncode(kv.Value);
+        return $"{encodedKey}={encodedValue}";
+    }
+
+    private static readonly string[] _reservedKeys = { "version", "group", "cluster", "namespace", "weight" };
+}

src/NacosMiddlewareConfigurationProvider.cs

@@ -0,0 +1,27 @@
+using Ocelot.Configuration.Repository;
+using Ocelot.Middleware;
+
+namespace Ocelot.Discovery.Nacos;
+
+public class NacosMiddlewareConfigurationProvider
+{
+    public static OcelotMiddlewareConfigurationDelegate Get { get; } = builder =>
+    {
+        var internalConfigRepo = builder.ApplicationServices.GetService<IInternalConfigurationRepository>();
+        var log =builder.ApplicationServices.GetService<ILogger<NacosMiddlewareConfigurationProvider>>();
+        var config = internalConfigRepo.Get();
+
+        if (UsingNacosServiceDiscoveryProvider(config.Data))
+        {
+            log.LogInformation("Using Nacos service discovery provider.");
+        }
+
+        return Task.CompletedTask;
+    };
+
+    private static bool UsingNacosServiceDiscoveryProvider(IInternalConfiguration configuration)
+    {
+        return configuration?.ServiceProviderConfiguration != null 
+               && configuration.ServiceProviderConfiguration.Type?.ToLower() == "nacos";
+    }
+}

src/NacosProviderFactory.cs

@@ -0,0 +1,26 @@
+using Ocelot.ServiceDiscovery;
+
+namespace Ocelot.Discovery.Nacos;
+
+public static class NacosProviderFactory
+{
+    /// <summary>
+    /// String constant used for provider type definition.
+    /// </summary>
+    public const string Nacos = nameof(Discovery.Nacos.Nacos);
+
+    public static ServiceDiscoveryFinderDelegate Get { get; } = CreateProvider;
+
+    private static IServiceDiscoveryProvider CreateProvider(IServiceProvider provider, ServiceProviderConfiguration config, DownstreamRoute route)
+    {
+        var client = provider.GetService<INacosNamingService>();
+        if (client == null)
+        {
+            throw new NullReferenceException($"Cannot get an {nameof(INacosNamingService)} service during {nameof(CreateProvider)} operation to instantiate the {nameof(Nacos)} provider!");
+        }
+
+        return Nacos.Equals(config.Type, StringComparison.OrdinalIgnoreCase)
+            ? new Nacos(route.ServiceName, client)
+            : null;
+    }
+}

src/Ocelot.Discovery.Nacos.csproj

@@ -0,0 +1,13 @@
+<Project Sdk="Microsoft.NET.Sdk">
+
+  <PropertyGroup>
+    <TargetFrameworks>net8.0;net9.0</TargetFrameworks>
+    <ImplicitUsings>enable</ImplicitUsings>
+    <Nullable>enable</Nullable>
+  </PropertyGroup>
+  <ItemGroup>
+    <PackageReference Include="nacos-sdk-csharp" Version="1.3.10" />
+    <PackageReference Include="nacos-sdk-csharp.AspNetCore" Version="1.3.10" />
+    <PackageReference Include="Ocelot" Version="23.4.3" />
+  </ItemGroup>
+</Project>

src/OcelotBuilderExtensions.cs

@@ -0,0 +1,16 @@
+using Ocelot.DependencyInjection;
+using Nacos.AspNetCore.V2;
+
+namespace Ocelot.Discovery.Nacos;
+
+public static class OcelotBuilderExtensions
+{
+    public static IOcelotBuilder AddNacos(this IOcelotBuilder builder, string section = "nacos")
+    {
+        builder.Services
+            .AddNacosAspNet(builder.Configuration,section)
+            .AddSingleton(NacosProviderFactory.Get)
+            .AddSingleton(NacosMiddlewareConfigurationProvider.Get);
+        return builder;
+    }
+}

src/Usings.cs

@@ -0,0 +1,11 @@
+global using Microsoft.Extensions.DependencyInjection;
+global using Microsoft.Extensions.Logging;
+global using Ocelot.Configuration;
+global using Ocelot.ServiceDiscovery.Providers;
+global using Nacos.V2;
+global using Nacos.V2.Exceptions;
+global using Nacos.V2.Naming.Dtos;
+global using System.Net;
+global using System.Collections.Generic;
+global using System.Linq;
+global using System.Threading.Tasks;

unit/MSTestSettings.cs

@@ -0,0 +1 @@
+[assembly: Parallelize(Scope = ExecutionScope.MethodLevel)]

unit/NacosProviderFactoryTests.cs

@@ -0,0 +1,141 @@
+using Microsoft.VisualStudio.TestTools.UnitTesting;
+using Moq;
+using Ocelot.Discovery.Nacos;
+using Ocelot.Configuration;
+using Nacos.V2;
+
+[TestClass]
+public class NacosProviderFactoryTests
+{
+    [TestMethod]
+    public void CreateProvider_ShouldReturnNacosProvider_WhenConfigTypeIsNacos()
+    {
+        // Arrange
+        var serviceProviderMock = new Mock<IServiceProvider>();
+        var nacosNamingServiceMock = new Mock<INacosNamingService>();
+        serviceProviderMock.Setup(sp => sp.GetService(typeof(INacosNamingService)))
+            .Returns(nacosNamingServiceMock.Object);
+
+        var config = new ServiceProviderConfiguration(
+            type: "nacos",
+            scheme: "http",
+            host: "localhost",
+            port: 8848,
+            token: null,
+            configurationKey: "nacos",
+            pollingInterval: 5000
+        );
+
+        var route = new DownstreamRoute(
+            key: "testKey",
+            upstreamPathTemplate: null,
+            upstreamHeadersFindAndReplace: null,
+            downstreamHeadersFindAndReplace: null,
+            downstreamAddresses: null,
+            serviceName: "testService",
+            serviceNamespace: null,
+            httpHandlerOptions: null,
+            useServiceDiscovery: false,
+            enableEndpointEndpointRateLimiting: false,
+            qosOptions: null,
+            downstreamScheme: null,
+            requestIdKey: null,
+            isCached: false,
+            cacheOptions: null,
+            loadBalancerOptions: null,
+            rateLimitOptions: null,
+            routeClaimsRequirement: null,
+            claimsToQueries: null,
+            claimsToHeaders: null,
+            claimsToClaims: null,
+            claimsToPath: null,
+            isAuthenticated: false,
+            isAuthorized: false,
+            authenticationOptions: null,
+            downstreamPathTemplate: null,
+            loadBalancerKey: null,
+            delegatingHandlers: null,
+            addHeadersToDownstream: null,
+            addHeadersToUpstream: null,
+            dangerousAcceptAnyServerCertificateValidator: false,
+            securityOptions: null,
+            downstreamHttpMethod: null,
+            downstreamHttpVersion: null,
+            downstreamHttpVersionPolicy: default,
+            upstreamHeaders: null,
+            metadataOptions: null
+        );
+
+        // Act
+        var provider = NacosProviderFactory.Get(serviceProviderMock.Object, config, route);
+
+        // Assert
+        Assert.IsNotNull(provider);
+        Assert.IsInstanceOfType(provider, typeof(Ocelot.Discovery.Nacos.Nacos));
+    }
+
+    [TestMethod]
+    [ExpectedException(typeof(NullReferenceException))]
+    public void CreateProvider_ShouldThrowException_WhenNacosNamingServiceIsNull()
+    {
+        // Arrange
+        var serviceProviderMock = new Mock<IServiceProvider>();
+        serviceProviderMock.Setup(sp => sp.GetService(typeof(INacosNamingService)))
+            .Returns(null);
+
+        var config = new ServiceProviderConfiguration(
+            type: "nacos",
+            scheme: "http",
+            host: "localhost",
+            port: 8848,
+            token: null,
+            configurationKey: "nacos",
+            pollingInterval: 5000
+        );
+
+        var route = new DownstreamRoute(
+            key: "testKey",
+            upstreamPathTemplate: null,
+            upstreamHeadersFindAndReplace: null,
+            downstreamHeadersFindAndReplace: null,
+            downstreamAddresses: null,
+            serviceName: "testService",
+            serviceNamespace: null,
+            httpHandlerOptions: null,
+            useServiceDiscovery: false,
+            enableEndpointEndpointRateLimiting: false,
+            qosOptions: null,
+            downstreamScheme: null,
+            requestIdKey: null,
+            isCached: false,
+            cacheOptions: null,
+            loadBalancerOptions: null,
+            rateLimitOptions: null,
+            routeClaimsRequirement: null,
+            claimsToQueries: null,
+            claimsToHeaders: null,
+            claimsToClaims: null,
+            claimsToPath: null,
+            isAuthenticated: false,
+            isAuthorized: false,
+            authenticationOptions: null,
+            downstreamPathTemplate: null,
+            loadBalancerKey: null,
+            delegatingHandlers: null,
+            addHeadersToDownstream: null,
+            addHeadersToUpstream: null,
+            dangerousAcceptAnyServerCertificateValidator: false,
+            securityOptions: null,
+            downstreamHttpMethod: null,
+            downstreamHttpVersion: null,
+            downstreamHttpVersionPolicy: default,
+            upstreamHeaders: null,
+            metadataOptions: null
+        );
+
+        // Act
+        var provider = NacosProviderFactory.Get(serviceProviderMock.Object, config, route);
+        // Assert
+        Assert.IsNull(provider);
+    }
+}