Merge pull request #14015 from abpframework/dapr-improvements

Dapr improvements & documentation
abpframework · Sep 15, 2022 · c1e6883 · c1e6883
2 parents cd0bb3c + ea17fbf
commit c1e6883
Show file tree

Hide file tree

Showing 17 changed files with 752 additions and 46 deletions.
diff --git a/docs/en/Dapr/Index.md b/docs/en/Dapr/Index.md
diff --git a/docs/en/docs-nav.json b/docs/en/docs-nav.json
@@ -1283,6 +1283,10 @@
         }
       ]
     },
+    {
+      "text": "Dapr Integration",
+      "path": "Dapr/Index.md"
+    },
     {
       "text": "Testing",
       "path": "Testing.md"

diff --git a/...Volo/Abp/AspNetCore/Mvc/Dapr/EventBus/Controllers/AbpAspNetCoreMvcDaprPubSubController.cs b/...Volo/Abp/AspNetCore/Mvc/Dapr/EventBus/Controllers/AbpAspNetCoreMvcDaprPubSubController.cs
@@ -21,6 +21,8 @@ public virtual async Task<List<AbpAspNetCoreMvcDaprSubscriptionDefinition>> Subs
     [HttpPost(AbpAspNetCoreMvcDaprPubSubConsts.DaprEventCallbackUrl)]
     public virtual async Task<IActionResult> EventsAsync()
     {
+        this.HttpContext.ValidateDaprAppApiToken();
+
         var bodyJsonDocument = await JsonDocument.ParseAsync(HttpContext.Request.Body);
         var request = JsonSerializer.Deserialize<AbpAspNetCoreMvcDaprSubscriptionRequest>(bodyJsonDocument.RootElement.GetRawText(),
             HttpContext.RequestServices.GetRequiredService<IOptions<JsonOptions>>().Value.JsonSerializerOptions);

diff --git a/...e/Mvc/Dapr/EventBus/SystemTextJson/AbpAspNetCoreMvcDaprSubscriptionDefinitionConverter.cs b/...e/Mvc/Dapr/EventBus/SystemTextJson/AbpAspNetCoreMvcDaprSubscriptionDefinitionConverter.cs
@@ -6,7 +6,7 @@ namespace Volo.Abp.AspNetCore.Mvc.Dapr.EventBus.SystemTextJson;
 
 public class AbpAspNetCoreMvcDaprSubscriptionDefinitionConverter : JsonConverter<AbpAspNetCoreMvcDaprSubscriptionDefinition>
 {
-    private JsonSerializerOptions _writeJsonSerializerOptions;
+    private JsonSerializerOptions? _writeJsonSerializerOptions;
 
     public override AbpAspNetCoreMvcDaprSubscriptionDefinition Read(ref Utf8JsonReader reader, Type typeToConvert, JsonSerializerOptions options)
     {

diff --git a/...src/Volo.Abp.AspNetCore.Mvc.Dapr/Volo/Abp/AspNetCore/Mvc/Dapr/DaprAppApiTokenValidator.cs b/...src/Volo.Abp.AspNetCore.Mvc.Dapr/Volo/Abp/AspNetCore/Mvc/Dapr/DaprAppApiTokenValidator.cs
@@ -0,0 +1,75 @@
+using Microsoft.AspNetCore.Http;
+using Microsoft.AspNetCore.SignalR;
+using Microsoft.Extensions.DependencyInjection;
+using Volo.Abp.Authorization;
+using Volo.Abp.Dapr;
+using Volo.Abp.DependencyInjection;
+
+namespace Volo.Abp.AspNetCore.Mvc.Dapr;
+
+public class DaprAppApiTokenValidator : IDaprAppApiTokenValidator, ISingletonDependency
+{
+    protected IHttpContextAccessor HttpContextAccessor { get; }
+    protected HttpContext HttpContext => GetHttpContext(); 
+
+    public DaprAppApiTokenValidator(IHttpContextAccessor httpContextAccessor)
+    {
+        HttpContextAccessor = httpContextAccessor;
+    }
+
+    public virtual void CheckDaprAppApiToken()
+    {
+        var expectedAppApiToken = GetConfiguredAppApiTokenOrNull();
+        if (expectedAppApiToken.IsNullOrWhiteSpace())
+        {
+            return;
+        }
+
+        var headerAppApiToken = GetDaprAppApiTokenOrNull();
+        if (headerAppApiToken.IsNullOrWhiteSpace())
+        {
+            throw new AbpAuthorizationException("Expected Dapr App API Token is not provided! Dapr should set the 'dapr-api-token' HTTP header.");
+        }
+
+        if (expectedAppApiToken != headerAppApiToken)
+        {
+            throw new AbpAuthorizationException("The Dapr App API Token (provided in the 'dapr-api-token' HTTP header) doesn't match the expected value!");
+        }
+    }
+
+    public virtual bool IsValidDaprAppApiToken()
+    {
+        var expectedAppApiToken = GetConfiguredAppApiTokenOrNull();
+        if (expectedAppApiToken.IsNullOrWhiteSpace())
+        {
+            return true;
+        }
+
+        var headerAppApiToken = GetDaprAppApiTokenOrNull();
+        return expectedAppApiToken == headerAppApiToken;
+    }
+
+    public virtual string? GetDaprAppApiTokenOrNull()
+    {
+        string apiTokenHeader = HttpContext.Request.Headers["dapr-api-token"];
+        if (string.IsNullOrEmpty(apiTokenHeader) || apiTokenHeader.Length < 1)
+        {
+            return null;
+        }
+
+        return apiTokenHeader;
+    }
+
+    protected virtual string? GetConfiguredAppApiTokenOrNull()
+    {
+        return HttpContext
+            .RequestServices
+            .GetRequiredService<IDaprApiTokenProvider>()
+            .GetAppApiToken();
+    }
+
+    protected virtual HttpContext GetHttpContext()
+    {
+        return HttpContextAccessor.HttpContext ?? throw new AbpException("HttpContext is not available!");
+    }
+}
diff --git a/...rc/Volo.Abp.AspNetCore.Mvc.Dapr/Volo/Abp/AspNetCore/Mvc/Dapr/DaprHttpContextExtensions.cs b/...rc/Volo.Abp.AspNetCore.Mvc.Dapr/Volo/Abp/AspNetCore/Mvc/Dapr/DaprHttpContextExtensions.cs
@@ -0,0 +1,31 @@
+using Microsoft.AspNetCore.Http;
+using Microsoft.Extensions.DependencyInjection;
+
+namespace Volo.Abp.AspNetCore.Mvc.Dapr;
+
+public static class DaprHttpContextExtensions
+{
+    public static void ValidateDaprAppApiToken(this HttpContext httpContext)
+    {
+        httpContext
+            .RequestServices
+            .GetRequiredService<IDaprAppApiTokenValidator>()
+            .CheckDaprAppApiToken();
+    }
+
+    public static bool IsValidDaprAppApiToken(this HttpContext httpContext)
+    {
+        return httpContext
+            .RequestServices
+            .GetRequiredService<IDaprAppApiTokenValidator>()
+            .IsValidDaprAppApiToken();
+    }
+
+    public static string? GetDaprAppApiTokenOrNull(HttpContext httpContext)
+    {
+        return httpContext
+            .RequestServices
+            .GetRequiredService<IDaprAppApiTokenValidator>()
+            .GetDaprAppApiTokenOrNull();
+    }
+}
diff --git a/...rc/Volo.Abp.AspNetCore.Mvc.Dapr/Volo/Abp/AspNetCore/Mvc/Dapr/IDaprAppApiTokenValidator.cs b/...rc/Volo.Abp.AspNetCore.Mvc.Dapr/Volo/Abp/AspNetCore/Mvc/Dapr/IDaprAppApiTokenValidator.cs
@@ -0,0 +1,8 @@
+namespace Volo.Abp.AspNetCore.Mvc.Dapr;
+
+public interface IDaprAppApiTokenValidator
+{
+    void CheckDaprAppApiToken();
+    bool IsValidDaprAppApiToken();
+    string? GetDaprAppApiTokenOrNull();
+}
diff --git a/framework/src/Volo.Abp.Dapr/Volo/Abp/Dapr/AbpDaprClientFactory.cs b/framework/src/Volo.Abp.Dapr/Volo/Abp/Dapr/AbpDaprClientFactory.cs
@@ -1,48 +1,73 @@
-using System.Collections.Concurrent;
-using System.Text.Json;
+using System.Text.Json;
 using Dapr.Client;
 using Microsoft.Extensions.Options;
 using Volo.Abp.DependencyInjection;
 using Volo.Abp.Json.SystemTextJson;
 
 namespace Volo.Abp.Dapr;
 
-public class AbpDaprClientFactory : ITransientDependency
+public class AbpDaprClientFactory : IAbpDaprClientFactory, ISingletonDependency
 {
-    protected AbpDaprOptions Options { get; }
-    protected AbpSystemTextJsonSerializerOptions SystemTextJsonSerializerOptions { get; }
+    protected AbpDaprOptions DaprOptions { get; }
+    protected JsonSerializerOptions JsonSerializerOptions { get; }
+    protected IDaprApiTokenProvider DaprApiTokenProvider { get; }
 
     public AbpDaprClientFactory(
         IOptions<AbpDaprOptions> options,
-        IOptions<AbpSystemTextJsonSerializerOptions> systemTextJsonSerializerOptions)
+        IOptions<AbpSystemTextJsonSerializerOptions> systemTextJsonSerializerOptions,
+        IDaprApiTokenProvider daprApiTokenProvider)
     {
-        Options = options.Value;
-        SystemTextJsonSerializerOptions = systemTextJsonSerializerOptions.Value;
+        DaprApiTokenProvider = daprApiTokenProvider;
+        DaprOptions = options.Value;
+        JsonSerializerOptions = CreateJsonSerializerOptions(systemTextJsonSerializerOptions.Value);
     }
 
-    public virtual async Task<DaprClient> CreateAsync()
+    public virtual DaprClient Create(Action<DaprClientBuilder>? builderAction = null)
     {
         var builder = new DaprClientBuilder()
-            .UseJsonSerializationOptions(await CreateJsonSerializerOptions());
+            .UseJsonSerializationOptions(JsonSerializerOptions);
 
-        if (!Options.HttpEndpoint.IsNullOrWhiteSpace())
+        if (!DaprOptions.HttpEndpoint.IsNullOrWhiteSpace())
         {
-            builder.UseHttpEndpoint(Options.HttpEndpoint);
+            builder.UseHttpEndpoint(DaprOptions.HttpEndpoint);
         }
 
-        if (!Options.GrpcEndpoint.IsNullOrWhiteSpace())
+        if (!DaprOptions.GrpcEndpoint.IsNullOrWhiteSpace())
         {
-            builder.UseGrpcEndpoint(Options.GrpcEndpoint);
+            builder.UseGrpcEndpoint(DaprOptions.GrpcEndpoint);
         }
 
+        var apiToken = DaprApiTokenProvider.GetDaprApiToken();
+        if (!apiToken.IsNullOrWhiteSpace())
+        {
+            builder.UseDaprApiToken(apiToken);
+        }
+
+        builderAction?.Invoke(builder);
+
         return builder.Build();
     }
 
-    private readonly static ConcurrentDictionary<string, JsonSerializerOptions> JsonSerializerOptionsCache = new ConcurrentDictionary<string, JsonSerializerOptions>();
+    public virtual HttpClient CreateHttpClient(
+        string? appId = null,
+        string? daprEndpoint = null,
+        string? daprApiToken = null)
+    {
+        if(daprEndpoint.IsNullOrWhiteSpace() &&
+           !DaprOptions.HttpEndpoint.IsNullOrWhiteSpace())
+        {
+            daprEndpoint = DaprOptions.HttpEndpoint;
+        }
 
-    protected virtual Task<JsonSerializerOptions> CreateJsonSerializerOptions()
+        return DaprClient.CreateInvokeHttpClient(
+            appId,
+            daprEndpoint,
+            daprApiToken ?? DaprApiTokenProvider.GetDaprApiToken()
+        );
+    }
+
+    protected virtual JsonSerializerOptions CreateJsonSerializerOptions(AbpSystemTextJsonSerializerOptions systemTextJsonSerializerOptions)
     {
-        return Task.FromResult(JsonSerializerOptionsCache.GetOrAdd(nameof(AbpDaprClientFactory),
-            _ => new JsonSerializerOptions(SystemTextJsonSerializerOptions.JsonSerializerOptions)));
+        return new JsonSerializerOptions(systemTextJsonSerializerOptions.JsonSerializerOptions);
     }
-}
+}
diff --git a/framework/src/Volo.Abp.Dapr/Volo/Abp/Dapr/AbpDaprModule.cs b/framework/src/Volo.Abp.Dapr/Volo/Abp/Dapr/AbpDaprModule.cs
@@ -1,4 +1,6 @@
-using Microsoft.Extensions.DependencyInjection;
+using Microsoft.Extensions.Configuration;
+using Microsoft.Extensions.DependencyInjection;
+using Microsoft.Extensions.DependencyInjection.Extensions;
 using Volo.Abp.Json;
 using Volo.Abp.Modularity;
 
@@ -10,6 +12,54 @@ public class AbpDaprModule : AbpModule
     public override void ConfigureServices(ServiceConfigurationContext context)
     {
         var configuration = context.Services.GetConfiguration();
+
+        ConfigureDaprOptions(configuration);
+
+        context.Services.TryAddSingleton(
+            serviceProvider => serviceProvider
+                .GetRequiredService<IAbpDaprClientFactory>()
+                .Create()
+        );
+    }
+
+    private void ConfigureDaprOptions(IConfiguration configuration)
+    {
         Configure<AbpDaprOptions>(configuration.GetSection("Dapr"));
+        Configure<AbpDaprOptions>(options =>
+        {
+            if (options.DaprApiToken.IsNullOrWhiteSpace())
+            {
+                var confEnv = configuration["DAPR_API_TOKEN"];
+                if (!confEnv.IsNullOrWhiteSpace())
+                {
+                    options.DaprApiToken = confEnv;
+                }
+                else
+                {
+                    var env = Environment.GetEnvironmentVariable("DAPR_API_TOKEN");
+                    if (!env.IsNullOrWhiteSpace())
+                    {
+                        options.DaprApiToken = env;
+                    }
+                }
+            }
+
+            if (options.AppApiToken.IsNullOrWhiteSpace())
+            {
+                var confEnv = configuration["APP_API_TOKEN"];
+                if (!confEnv.IsNullOrWhiteSpace())
+                {
+                    options.AppApiToken = confEnv;
+                }
+                else
+                {
+                    var env = Environment.GetEnvironmentVariable("APP_API_TOKEN");
+                    if (!env.IsNullOrWhiteSpace())
+                    {
+                        options.AppApiToken = env;
+                    }
+                }
+            }
+        });
     }
 }
diff --git a/framework/src/Volo.Abp.Dapr/Volo/Abp/Dapr/AbpDaprOptions.cs b/framework/src/Volo.Abp.Dapr/Volo/Abp/Dapr/AbpDaprOptions.cs
@@ -2,9 +2,11 @@
 
 public class AbpDaprOptions
 {
-    public string AppId { get; set; }
-
     public string HttpEndpoint { get; set; }
 
     public string GrpcEndpoint { get; set; }
-}
+
+    public string DaprApiToken { get; set; }
+
+    public string AppApiToken { get; set; }
+}
diff --git a/framework/src/Volo.Abp.Dapr/Volo/Abp/Dapr/DaprApiTokenProvider.cs b/framework/src/Volo.Abp.Dapr/Volo/Abp/Dapr/DaprApiTokenProvider.cs
@@ -0,0 +1,24 @@
+using Microsoft.Extensions.Options;
+using Volo.Abp.DependencyInjection;
+
+namespace Volo.Abp.Dapr;
+
+public class DaprApiTokenProvider : IDaprApiTokenProvider, ISingletonDependency
+{
+    protected AbpDaprOptions Options { get; }
+
+    public DaprApiTokenProvider(IOptions<AbpDaprOptions> options)
+    {
+        Options = options.Value;
+    }
+
+    public virtual string? GetDaprApiToken()
+    {
+        return Options.DaprApiToken;
+    }
+
+    public virtual string? GetAppApiToken()
+    {
+        return Options.AppApiToken;
+    }
+}
diff --git a/framework/src/Volo.Abp.Dapr/Volo/Abp/Dapr/IAbpDaprClientFactory.cs b/framework/src/Volo.Abp.Dapr/Volo/Abp/Dapr/IAbpDaprClientFactory.cs
@@ -0,0 +1,14 @@
+using Dapr.Client;
+
+namespace Volo.Abp.Dapr;
+
+public interface IAbpDaprClientFactory
+{
+    DaprClient Create(Action<DaprClientBuilder>? builderAction = null);
+
+    HttpClient CreateHttpClient(
+        string? appId = null,
+        string? daprEndpoint = null,
+        string? daprApiToken = null
+    );
+}
diff --git a/framework/src/Volo.Abp.Dapr/Volo/Abp/Dapr/IDaprApiTokenProvider.cs b/framework/src/Volo.Abp.Dapr/Volo/Abp/Dapr/IDaprApiTokenProvider.cs
@@ -0,0 +1,8 @@
+namespace Volo.Abp.Dapr;
+
+public interface IDaprApiTokenProvider
+{
+    string? GetDaprApiToken();
+
+    string? GetAppApiToken();
+}
diff --git a/...lo.Abp.DistributedLocking.Abstractions/Volo/Abp/DistributedLocking/IAbpDistributedLock.cs b/...lo.Abp.DistributedLocking.Abstractions/Volo/Abp/DistributedLocking/IAbpDistributedLock.cs
@@ -14,7 +14,7 @@ public interface IAbpDistributedLock
     /// Returns null if the lock could not be handled.
     /// </summary>
     /// <param name="name">The name of the lock</param>
-    /// <param name="timeout">Timeout value</param>
+    /// <param name="timeout">How long to wait before giving up on the acquisition attempt. Defaults to 0</param>
     /// <param name="cancellationToken">Cancellation token</param>
     [ItemCanBeNull]
     Task<IAbpDistributedLockHandle> TryAcquireAsync(

diff --git a/...DistributedLocking.Dapr/Volo/Abp/DistributedLocking/Dapr/AbpDistributedLockDaprOptions.cs b/...DistributedLocking.Dapr/Volo/Abp/DistributedLocking/Dapr/AbpDistributedLockDaprOptions.cs
@@ -4,10 +4,12 @@ public class AbpDistributedLockDaprOptions
 {
     public string StoreName { get; set; }
 
-    public TimeSpan DefaultTimeout { get; set; }
+    public string? Owner { get; set; }
+
+    public TimeSpan DefaultExpirationTimeout { get; set; }
 
     public AbpDistributedLockDaprOptions()
     {
-        DefaultTimeout = TimeSpan.FromSeconds(30);
+        DefaultExpirationTimeout = TimeSpan.FromMinutes(2);
     }
 }