DEV Community: dejandjenic

Testing with JWT in .NET APIs

dejandjenic — Tue, 14 Jan 2025 12:50:31 +0000

Learn how to create and test a .NET Minimal API with JWT authentication and authorization, including secure endpoints, configuration, and integration testing using the TestJWTLibrary.
https://www.dejandjenic.com/blogs/testing-with-jwt.html

Creating a .NET Tool and Publishing it from GitHub

dejandjenic — Sun, 29 Dec 2024 17:59:35 +0000

https://www.dejandjenic.com/blogs/creating-dotnet-tool-and-publishing-it-from-github.html

Functional testing with testcontainers

dejandjenic — Thu, 21 Dec 2023 08:18:29 +0000

Introduction

Functional testing is a crucial aspect of software development, ensuring that your application functions as expected in real-world scenarios. However, testing components with external dependencies, such as databases and message brokers, can be challenging. In this article, we explore how the TestContainers library simplifies functional testing by managing these dependencies effectively. We'll focus on using TestContainers with Google Cloud Platform's (GCP) Firestore and PubSub services in a .NET environment.

Setting Up the API Project

I recently contributed to the TestContainers open-source library, with two of my pull requests included in the 3.6.0 release. In this guide, we'll delve into the usage of GCP Firestore and PubSub features with TestContainers.

Let's assume we have a simple API for managing a to-do list. Our API uses Firestore as the operational database, storing only active to-dos, while PubSub is employed to publish messages for every API action. This allows us to build a reporting system without relying on the operational database.

Start by creating a .NET 8 API project and adding the necessary references:

Google.Cloud.Firestore
Google.Cloud.Firestore.V1
Google.Cloud.PubSub.V1
Microsoft.AspNetCore.OpenApi
Swashbuckle.AspNetCore

Next, add the required classes for your API:

[FirestoreData]
public class Todo
{
    [FirestoreDocumentId]
    public string Id { get; set; }
    [FirestoreProperty]
    public string Text { get; set; }
}

Creating the Firestore and PubSub Services


public interface ITodoRepository
{
    Task<List<Todo>> List();
    Task Add(Todo item);
    Task Delete(string id);
}

public class TodoRepository(FirestoreDb db) : ITodoRepository
{
    public const string TodoCollectionName = "Todo";
    public async Task<List<Todo>> List()
    {
        return (await db.Collection(TodoCollectionName).GetSnapshotAsync()).
        Documents.
        Select(x => 
            x.ConvertTo<Todo>()).
        ToList();
    }

    public async Task Add(Todo item)
    {
        await db.
            Collection(TodoCollectionName)
            .Document().
            CreateAsync(item);
    } 

    public async Task Delete(string id)
    {
        await db.
            Collection(TodoCollectionName)
            .Document(id).
            DeleteAsync();
    } 
}

public class BaseEvent
{
    public DateTime Date { get; set; } = DateTime.UtcNow;

    public string? Type => this.GetType().FullName;
}

public class TodoCreated : BaseEvent
{

}

public class TodoDeleted : BaseEvent
{

}

public interface IEventPublisher
{
    Task Publish(BaseEvent eventData);
}

public class EventPublisher(PublisherClientImpl client) : IEventPublisher
{
    public async Task Publish(BaseEvent eventData)
    {
        await client.PublishAsync(System.Text.Json.JsonSerializer.Serialize(eventData));
    }
}

public interface ITodoService
{
    Task<List<Todo>> List();
    Task Add(Todo item);
    Task Delete(string id);
}

public class TodoService(ITodoRepository repository,IEventPublisher eventPublisher) : ITodoService
{
    public Task<List<Todo>> List()
    {
        return repository.List();
    }

    public async Task Add(Todo item)
    {
        await eventPublisher.Publish(new TodoCreated());
        await repository.Add(item);
    } 

    public async Task Delete(string id)
    {
        await eventPublisher.Publish(new TodoDeleted());
        await repository.Delete(id);
    } 
}

For abbreviation purposes, our Todo class serves both as a model for requests and an entity for the database, though it's not considered good practice.

public class AppSettings
{
    public string ProjectId { get; set; }
    public string TopicName { get; set; }
}

Additionally, include an app configuration class and the main program file:

var builder = WebApplication.CreateBuilder(args);

builder.Services.AddEndpointsApiExplorer();
builder.Services.AddSwaggerGen();

var appSettings = builder.Configuration.GetSection("AppSettings").Get<AppSettings>();
builder.Services.AddSingleton(appSettings);

builder.Services.AddSingleton(FirestoreDb.Create(appSettings.ProjectId));
builder.Services.AddSingleton((PublisherClientImpl)PublisherClientImpl.Create(new TopicName(appSettings.ProjectId,appSettings.TopicName)));
builder.Services.AddScoped<ITodoRepository,TodoRepository>();
builder.Services.AddScoped<ITodoService,TodoService>();
builder.Services.AddScoped<IEventPublisher,EventPublisher>();

var app = builder.Build();

if (app.Environment.IsDevelopment())
{
    app.UseSwagger();
    app.UseSwaggerUI();
}

app.UseHttpsRedirection();


app.MapGet("/todo", (ITodoService service) =>  service.List())
    .WithName("GetTodos")
    .WithOpenApi();

app.MapPost("/todo", (ITodoService service,[FromBody]Todo model) =>  service.Add(model))
    .WithName("CreateTodo")
    .WithOpenApi();

app.MapDelete("/todo/{id}", (ITodoService service,[FromRoute]string id) =>  service.Delete(id))
    .WithName("DeleteTodo")
    .WithOpenApi();

app.Run();

public partial class Program{}

after starting our api and checking swagger we would see something like this

we have 3 endpoints

list todos
create todo
delete todo

we store and retrieve this information from firestore database and we publish pubsub message after creating and deleting todo.

Writing Functional Tests

Now, let's add a test project to our solution and include the necessary references:

FluentAssertions
Microsoft.AspNetCore.Mvc.Testing
Testcontainers.Firestore
Testcontainers.PubSub
Microsoft.NET.Test.Sdk

Reference your API project from the test project and add the following classes:


public class CustomWebApplicationFactory<TProgram>
    : WebApplicationFactory<TProgram> where TProgram : class
{
    public Func<IServiceCollection,Task> OverideServices { get; set; }

    protected override void ConfigureWebHost(IWebHostBuilder builder)
    {
        builder.ConfigureServices(svc =>
        {
            if (OverideServices != null)
            {
                OverideServices(svc).GetAwaiter().GetResult();
            }
        });
    }
}


public class TestBase 
    : IClassFixture<CustomWebApplicationFactory<Program>>
{

    private readonly CustomWebApplicationFactory<Program> _factory;
    protected HttpClient client;
    private static FirestoreDb firestoreDb;
    private static PublisherServiceApiClient publisher;
    private static SubscriberServiceApiClient subscriber;
    private static SubscriptionName subscriptionName;

    private static  Func<IServiceCollection,Task> OverideServices = async (svc) =>
    {
        var appSettings = svc.BuildServiceProvider().GetRequiredService<AppSettings>();
        await SetupFirestore(svc,appSettings);

        await SetupPubSub(svc,appSettings);
    };

    private static async Task SetupFirestore(IServiceCollection svc, AppSettings appSettings)
    {
        FirestoreContainer _firestoreContainer = new FirestoreBuilder().Build();
        await _firestoreContainer.StartAsync();


        var firestoreDbBuilder = new FirestoreDbBuilder();
        firestoreDbBuilder.ProjectId = appSettings.ProjectId;
        firestoreDbBuilder.Endpoint = _firestoreContainer.GetEmulatorEndpoint();
        firestoreDbBuilder.ChannelCredentials = ChannelCredentials.Insecure;

        firestoreDb = await firestoreDbBuilder.BuildAsync();

        svc.AddSingleton(firestoreDb);
    }

    private static async Task SetupPubSub(IServiceCollection svc, AppSettings appSettings)
    {
        PubSubContainer _pubSubContainer = new PubSubBuilder().Build();
        await _pubSubContainer.StartAsync();


        var projectId = appSettings.ProjectId;
        var topicId = appSettings.TopicName;
        var subscriptionId = $"{appSettings.TopicName}-sub";

        var topicName = new TopicName(projectId, topicId);
        subscriptionName = new SubscriptionName(projectId, subscriptionId);

        var publisherClientBuilder = new PublisherServiceApiClientBuilder();
        publisherClientBuilder.Endpoint = _pubSubContainer.GetEmulatorEndpoint();
        publisherClientBuilder.ChannelCredentials = ChannelCredentials.Insecure;

        var subscriberClientBuilder = new SubscriberServiceApiClientBuilder();
        subscriberClientBuilder.Endpoint = _pubSubContainer.GetEmulatorEndpoint();
        subscriberClientBuilder.ChannelCredentials = ChannelCredentials.Insecure;


        publisher = await publisherClientBuilder.BuildAsync();
        subscriber = await subscriberClientBuilder.BuildAsync();

        publisher.CreateTopic(topicName);
        await subscriber.CreateSubscriptionAsync(subscriptionName, topicName, null, 60);

        svc.AddSingleton(
            new PublisherClientImpl(
                topicName, 
                new List<PublisherServiceApiClient>() { publisher },
                new PublisherClient.Settings(), 
                async () => { }));
    }

    public TestBase(CustomWebApplicationFactory<Program> factory)
    {
        _factory = factory;
        _factory.OverideServices = OverideServices;
        client = _factory.CreateClient();
    }

    public async Task ClearTodoCollection()
    {
        var collection = firestoreDb.Collection(TodoRepository.TodoCollectionName);
        foreach (var item in (await collection.GetSnapshotAsync()).Documents.Select(x=> x.ConvertTo<Todo>()))
        {
            await collection.Document(item.Id).DeleteAsync();
        }
    }

    public async Task<int> CheckSubscription()
    {
        var messages = await subscriber.PullAsync(subscriptionName, 5);
        await subscriber.AcknowledgeAsync(subscriptionName,messages.ReceivedMessages.Select(x=>x.AckId));
        return messages.ReceivedMessages.Count;
    }

}

the code above is used as a test base class, when invoked it starts docker container for pubsub and firestore (by using TestContainers library) and sets up environment for it.

now we have to add some tests


public class TodoTests : TestBase
{

    async Task<List<Todo>> GetTodos()
    {
        return (await client.GetFromJsonAsync<List<Todo>>("/todo"))!;
    }

    private async Task<string> AddTodo()
    {
        var todoText = Guid.NewGuid().ToString();
        await client.PostAsJsonAsync("/todo", new Todo()
        {
            Text = todoText
        });
        return todoText;
    }

    private async Task DeleteTodo(string id)
    {
        await client.DeleteAsync($"/todo/{id}");
    }

    [Fact]
    public async Task Should_Return_Empty_List()
    {
        var response = await GetTodos();
        response.Count.Should().Be(0);
    }

    [Fact]
    public async Task Should_Add_Todo()
    {
        var todos = await GetTodos();
        todos.Count.Should().Be(0);

        var todoText = await AddTodo();

        todos = await GetTodos();
        todos.Count.Should().Be(1);
        todos.FirstOrDefault()!.Text.Should().Be(todoText);

        await ClearTodoCollection();
        (await CheckSubscription()).Should().Be(1);
    }



    [Fact]
    public async Task Should_Delete_Todo()
    {
        var todos = await GetTodos();
        todos.Count.Should().Be(0);

        var todoText = await AddTodo();

        todos = await GetTodos();
        todos.Count.Should().Be(1);
        todos.FirstOrDefault()!.Text.Should().Be(todoText);

        await DeleteTodo(todos.FirstOrDefault()!.Id);

        todos = await GetTodos();
        todos.Count.Should().Be(0);

        await ClearTodoCollection();
        (await CheckSubscription()).Should().Be(2);
    }



    public TodoTests(CustomWebApplicationFactory<Program> factory) : base(factory)
    {

    }
}

Running the Tests and Analyzing Results

test server will be started and will execute api project, we did setup and registered with api project DI a special version for our services that we want to use with emulator, no code is changed in api project to achieve this.

we created test for our api, we ensured that when we create a todo it will appear in the list of all todos, we ensured that when we delete a todo it will not be shown on the list. We tested that api produces pubsub messages.

if we run tests now we see similar output

all tests have passed and out code coverage is 98%.

Conclusion

In conclusion, using TestContainers simplifies functional testing by managing external dependencies effectively. In this guide, we explored its integration with GCP Firestore and PubSub, demonstrating how to set up an API project, write functional tests, and analyze the results. By following these practices, developers can ensure their applications are robust and reliable in real-world scenarios.

code used in this article can be found here

Originally published at https://www.dejandjenic.com/blogs/functional-testing-with-testcontainers.html

Caching exploration in .NET

dejandjenic — Fri, 01 Dec 2023 08:17:36 +0000

Multi-Layered Caching in .NET Microservices

Caching plays a crucial role in optimizing the performance and scalability of .NET microservices. It allows frequently accessed data to be stored in memory or fast storage mediums, reducing the need to repeatedly retrieve data from original sources. In this blog post, we will explore the concept of multi-layered caching in .NET microservices and its significance in building highly performant and scalable applications.

Introduction

Caching offers several benefits in modern .NET applications:

Reduced Latency: Caching minimizes the latency associated with fetching data from databases or external services, resulting in faster response times and improved user experience.
Enhanced Scalability: By reducing the computational and network resources required to serve requests, caching improves the scalability of microservices, enabling them to handle higher loads efficiently.
Improved Resilience: Caching mitigates the impact of external service failures or outages by providing access to previously cached data, ensuring that the application remains functional even when external dependencies are unavailable.

The Need for Caching in .NET Applications

To demonstrate the need for caching in .NET applications, let's create a sample .NET API project using the Minimal API approach. We will use the GenFu library for generating fake data.

First, let's define a data model that will be returned by the search endpoint:

public class DataEntity
{
    public string Name { get; set; }
    public string LastName { get; set; }
    public int Age { get; set; }
}

Next, we need to create repository and service classes to be used by the endpoint. Here's an example of the IDataRepository interface and its implementation, DataRepository:

public interface IDataRepository
{
    Task<IList<DataEntity>> SearchEntities(string name);
    Task Add(string name);
}

 public class DataRepository : IDataRepository
{
    public async Task Add(string name)
    {

    }

    public async Task<IList<DataEntity>> SearchEntities(string name)
    {
        await Task.Delay(1500);
        return GenFu.GenFu.ListOf<DataEntity>();
    }
}

Similarly, let's define the IDataService interface and its implementation, DataService:

 public interface IDataService
{
    Task<IList<DataEntity>> SearchEntities(string name);
    Task Add(string name);
}


 public class DataService : IDataService
{
    readonly IDataRepository repository;
    public DataService(IDataRepository repository)
    {
        this.repository = repository;
    }

    public async Task Add(string name)
    {
        await repository.Add(name);
    }

    public async Task<IList<DataEntity>> SearchEntities(string name)
    {
        return await repository.SearchEntities(name);
    }
}

In the above code, we simulate the database read operation by introducing a delay of 1.5 seconds. The implementation for adding data is left empty for now. This setup allows us to simulate the load and reading latency without actually implementing it.

To wire up the dependencies, modify your Program.cs file as follows:

using CachingDemo.Cache;
using CachingDemo.Repository;
using CachingDemo.Service;
using Microsoft.AspNetCore.Mvc;

var builder = WebApplication.CreateBuilder(args);


builder.Services.AddScoped<IDataRepository, DataRepository>();
builder.Services.AddScoped<IDataService, DataService>();


var app = builder.Build();

app.MapGet("/search", async ([FromQuery] string name, IDataService service) => await service.SearchEntities(name));
app.MapGet("/add", async ([FromQuery] string name, IDataService service) => await service.Add(name));

app.Run();

By running the application, you will have two endpoints: /search for searching entities and /add for adding entities. Note that the /add endpoint should ideally be a POST request, but for simplicity, we are using a GET request in this example.

To test the search endpoint, you can use a URL like the following:

https://localhost:7220/search?name=test

This will return a JSON array of fake data similar to the following:

[
  {
    "name": "John",
    "lastName": "Doe",
    "age": 25
  },
  {
    "name": "Jane",
    "lastName": "Smith",
    "age": 30
  },
  ...
]

Please note that the data is randomly generated and may not match exactly.

In a real-world scenario, the application would be hosted behind a load balancer with multiple instances running simultaneously. In a Kubernetes environment, these instances would be represented as pods within a deployment. To simulate this environment on your local machine, you can use Docker Compose.

Let's add some additional components to our project.

Adding YARP for Load Balancing and Docker Compose

We can enhance our project by adding the YARP (Yet Another Reverse Proxy) project for load balancing. Additionally, we'll use Docker Compose to spin up multiple instances of our API.

Create a new project and configure it as follows:

var builder = WebApplication.CreateBuilder(args);
builder.Services.AddReverseProxy()
    .LoadFromConfig(builder.Configuration.GetSection("ReverseProxy"));
var app = builder.Build();
app.MapReverseProxy();
app.Run();

Add the following configuration to your appsettings.json file:

{
  "Logging": {
    "LogLevel": {
      "Default": "Information",
      "Microsoft.AspNetCore": "Warning"
    }
  },
  "AllowedHosts": "*",


  "ReverseProxy": {
    "Routes": {
      "minimumroute": {
        "ClusterId": "minimumcluster",
        "Match": {
          "Path": "{**catch-all}"
        }
      }
    },
    "Clusters": {
      "minimumcluster": {
        "Destinations": {
          "api1": {
            "Address": "http://api/"
          },
          "api2": {
            "Address": "http://api2/"
          }
        }
      }
    }
  }
}

we added routing of content to any of 2 instances of our app that are going to be used in our docker compose.

lets create some Dockerfile

first for our app, name this file Dockerfile

FROM mcr.microsoft.com/dotnet/aspnet:7.0 AS base
WORKDIR /app
EXPOSE 80
EXPOSE 443

FROM mcr.microsoft.com/dotnet/sdk:7.0 AS build
WORKDIR /src
COPY ["CachingDemo/CachingDemoApi.csproj", "CachingDemo/"]
RUN dotnet restore "CachingDemo/CachingDemoApi.csproj"
COPY . .
WORKDIR "/src/CachingDemo"
RUN dotnet build "CachingDemoApi.csproj" -c Release -o /app/build

FROM build AS publish
RUN dotnet publish "CachingDemoApi.csproj" -c Release -o /app/publish /p:UseAppHost=false

FROM base AS final
WORKDIR /app
COPY --from=publish /app/publish .
ENTRYPOINT ["dotnet", "CachingDemoApi.dll"]

then for YARP project, name this file Dockerfile.YARP

FROM mcr.microsoft.com/dotnet/aspnet:7.0 AS base
WORKDIR /app
EXPOSE 80
EXPOSE 443

FROM mcr.microsoft.com/dotnet/sdk:7.0 AS build
WORKDIR /src
COPY ["YARP/YARP.csproj", "YARP/"]
RUN dotnet restore "YARP/YARP.csproj"
COPY . .
WORKDIR "/src/YARP"
RUN dotnet build "YARP.csproj" -c Release -o /app/build

FROM build AS publish
RUN dotnet publish "YARP.csproj" -c Release -o /app/publish /p:UseAppHost=false

FROM base AS final
WORKDIR /app
COPY --from=publish /app/publish .
ENTRYPOINT ["dotnet", "YARP.dll"]

Build the Docker images for the API project and YARP project:

docker build . -t api
docker build . -f .\Dockerfile.YARP -t yarp

Create a docker-compose.yml file with the following contents:

version: '2.1'
services:
  api:
    image: api
  api2:
    image: api
  yarp:
    image: yarp
    ports:
      - "8002:80"

Run Docker Compose to start the instances:

docker compose up

With this setup, Docker Compose will spin up two instances of your API project and one instance of the YARP project, which will forward requests to the API instances.

Now, let's move on to load testing using NBomber.

Load Testing with NBomber

To perform load testing, we'll use the NBomber library. Make sure to add the required NuGet packages for NBomber, GenFu, and any other dependencies.

Create a new load testing project and add references to YARP and GenFu.

Configure NBomber in your load testing project as shown below:


using NBomber.CSharp;

var httpClient=new HttpClient();


var users = GenFu.GenFu.ListOf<User>();

var scenario = Scenario.Create("test_api_scenario", async context =>
{
    var name = users[GenFu.GenFu.Random.Next(25)].Name;
    await httpClient.GetAsync($"http://localhost:8002/search?name={name}");

    if(GenFu.GenFu.Random.Next(30) % 29 == 0)
        await httpClient.GetAsync($"http://localhost:8002/add?name={name}");

    return Response.Ok();
})
.WithLoadSimulations(
    Simulation.Inject(rate: 10,
                      interval: TimeSpan.FromSeconds(1),
                      during: TimeSpan.FromSeconds(30)),
    Simulation.Pause(during: TimeSpan.FromSeconds(5))
)

;

NBomberRunner
    .RegisterScenarios(scenario)    
    .Run();

class User
{
    public string Name { get; set; }
}

In the above code, we define a scenario named "test_api_scenario" that sends HTTP requests to the search endpoint with random names. We also include a conditional request to the add endpoint for every 30th request. The scenario is configured to have an injection rate of 10 requests per second for 30 seconds, followed by a 5-second pause.

Running this load testing project will generate load on your API instances and test their performance.

our load test creates 10 request per second and usual duration is slightly over 1.5 seconds.

Implementing Caching

Now, let's add caching to our project using Redis and in-memory caching.

Create the following interfaces and classes for caching:

public interface IGenericCache
{
    public Task<T> GetOrSet<T>(string key, Func<Task<T>> getData);
    public Task RemoveItem(string key);
}

public class RedisGenericCache : IGenericCache
{
    readonly IDatabase db;

    public RedisGenericCache(ConnectionMultiplexer redis)
    {            
        db = redis.GetDatabase();
    }

    public async Task<T> GetOrSet<T>(string key, Func<Task<T>> getData)
    {
        var cacheData = await db.StringGetAsync(key);

        if (!cacheData.HasValue)
        {
            var data = await getData();
            var cacheString = System.Text.Json.JsonSerializer.Serialize(data);
            await db.StringSetAsync(key, cacheString);
            cacheData = cacheString;
        }
        return System.Text.Json.JsonSerializer.Deserialize<T>(cacheData);
    }

    public async Task RemoveItem(string key)
    {
        await db.StringGetDeleteAsync(key);
    }
}

Create the RedisDataRepository and InMemoryDataRepository implementations:

public class RedisDataRepository : RedisGenericCache, IDataRepository
{
    readonly IDataRepository repository;
    public RedisDataRepository(IDataRepository repository, ConnectionMultiplexer redis) : base(redis)
    {
        this.repository = repository;
    }
    public async Task<IList<DataEntity>> SearchEntities(string name)
    {
        return await GetOrSet($"SearchEntities_{name}", () => repository.SearchEntities(name));
    }

    public async Task Add(string name)
    {
        await RemoveItem($"SearchEntities_{name}");
        await repository.Add(name);
    }
}

Modify your Program.cs to incorporate the Redis caching:

using CachingDemo.Cache;
using CachingDemo.Repository;
using CachingDemo.Service;
using Microsoft.AspNetCore.Mvc;
using Microsoft.Extensions.Caching.Memory;
using StackExchange.Redis;

var builder = WebApplication.CreateBuilder(args);


builder.Services.AddScoped<IDataRepository, DataRepository>();
builder.Services.AddScoped<IDataService, DataService>();



builder.Services.AddSingleton(sp => ConnectionMultiplexer.Connect("redis"));
builder.Services.AddSingleton<RedisGenericCache>();
builder.Services.Decorate<IDataRepository, RedisDataRepository>();

var app = builder.Build();

app.MapGet("/search", async ([FromQuery] string name, IDataService service) => await service.SearchEntities(name));
app.MapGet("/add", async ([FromQuery] string name, IDataService service) => await service.Add(name));

app.Run();

In the above code, we register the RedisGenericCache and RedisDataRepository classes as singleton services. We then decorate the IDataRepository service with RedisDataRepository , which provide caching capabilities.

lets shutdown docker compose and build enw version of our api.

docker compose down
docker build . -t api

create file called redis.conf with content (it will be used later) and in file Dockerfile.redis add

notify-keyspace-events AKE

FROM redis
COPY redis.conf /usr/local/etc/redis/redis.conf
CMD [ "redis-server", "/usr/local/etc/redis/redis.conf" ]

build redis docker file and lets add redis container to our docker compose file

docker build . -f .\Dockerfile.redis -t myredis

version: '2.1'
services:
  redis:
    image: myredis
  api:
    image: api
    depends_on:
      - redis
  api2:
    image: api
    depends_on:
      - redis
  yarp:
    image: yarp
    ports:
      - "8002:80"

start our instances and restart the test

wow, but really nobody is surprised that adding caching improves performance greatly.

However using redis (or any other distributed caching mechanism) in real world scenario would add some network latency and some delay. Can we improve this? Can we add some in memory caching to this existing model?

Adding in memory caching

add file InMemoryGenericCache.cs

public class InMemoryGenericCache : IGenericCache
{
    readonly IMemoryCache cache;
    public InMemoryGenericCache(IMemoryCache cache)
    {
        this.cache = cache;
    }

    public async Task<T> GetOrSet<T>(string key, Func<Task<T>> getData)
    {
        return await cache.GetOrCreateAsync(key, async (e) => await getData());
    }

    public async Task RemoveItem(string key)
    {
        cache.Remove(key);
    }
}

and file InMemoryDataRepository.cs

public class InMemoryDataRepository : InMemoryGenericCache, IDataRepository
{
    readonly IDataRepository repository;
    public InMemoryDataRepository(IDataRepository repository, IMemoryCache cache) : base(cache)
    {
        this.repository = repository;
    }

    public async Task Add(string name)
    {
        await RemoveItem($"SearchEntities_{name}");
        await repository.Add(name);
    }

    public async Task<IList<DataEntity>> SearchEntities(string name)
    {
        return await GetOrSet($"SearchEntities_{name}", () => repository.SearchEntities(name));
    }
}

but wait, what will happen if data in redis cache is invalidated and in memory data is not cleared (on second pod or instance)?

lets use redis subscription to notify subscribers about deleting keys from redis.

add

public interface IRedisSubscriber
{
    Task OnItemRemoved(string key);
}


public class RedisSubscriber : IRedisSubscriber
{
    readonly InMemoryGenericCache inMemoryGenericCache;
    readonly ILogger<RedisSubscriber> logger;
    public RedisSubscriber(InMemoryGenericCache inMemoryGenericCache,ILogger<RedisSubscriber> logger)
    {
        this.logger = logger;
        this.inMemoryGenericCache = inMemoryGenericCache;
    }
    public async Task OnItemRemoved(string key)
    {
        logger.LogInformation($"redis key deleted {key}");
        await inMemoryGenericCache.RemoveItem(key);
    }
}

public class RedisSubscriberNotificationService : BackgroundService
{
    readonly IEnumerable<IRedisSubscriber> subscribers;
    readonly ConnectionMultiplexer redis;
    public RedisSubscriberNotificationService(IEnumerable<IRedisSubscriber> subscribers, ConnectionMultiplexer redis)
    {
        this.redis = redis;
        this.subscribers = subscribers;
    }

    protected async override Task ExecuteAsync(CancellationToken stoppingToken)
    {

        if (subscribers.Any())
        {
            var sub = redis.GetSubscriber();
            sub.Subscribe("__keyevent@0__:del", async (c, m) =>
            {
                await Task.WhenAll(subscribers.Select(async subscriber => await subscriber.OnItemRemoved(m)));
            });
        }
    }
}

by doing this we will be notified when redis key is removed and we can use this moment to clear same value from in memory cache.

modify Program.cs to incorporate new in memory caching

using CachingDemo.Cache;
using CachingDemo.Repository;
using CachingDemo.Service;
using Microsoft.AspNetCore.Mvc;
using Microsoft.Extensions.Caching.Memory;
using StackExchange.Redis;

var builder = WebApplication.CreateBuilder(args);


builder.Services.AddScoped<IDataRepository, DataRepository>();
builder.Services.AddScoped<IDataService, DataService>();



builder.Services.AddSingleton(sp => ConnectionMultiplexer.Connect("redis"));
builder.Services.AddSingleton<RedisGenericCache>();
builder.Services.Decorate<IDataRepository, RedisDataRepository>();




builder.Services.AddSingleton<IMemoryCache, MemoryCache>();
builder.Services.AddSingleton<InMemoryGenericCache>();
builder.Services.Decorate<IDataRepository, InMemoryDataRepository>();

builder.Services.AddHostedService<RedisSubscriberNotificationService>();
builder.Services.AddSingleton<IRedisSubscriber, RedisSubscriber>();


var app = builder.Build();

app.MapGet("/search", async ([FromQuery] string name, IDataService service) => await service.SearchEntities(name));
app.MapGet("/add", async ([FromQuery] string name, IDataService service) => await service.Add(name));

app.Run();

lets build our api image again and run the tests

docker compose down
docker build . -t api
docker compose up

lets review results

wow, we have great results , using both of caching mechanisms, in memory for speed, redis for durability and distribution and we are still able to return correct results.

entire code shown here can be found https://github.com/dejandjenic/CachingDemo

originally published at https://www.dejandjenic.com/blogs/caching-exploration-in-dotnet.html

Building Responsive Apps, A Guide to SignalR Integration with Azure

dejandjenic — Fri, 01 Dec 2023 08:14:00 +0000

Introduction

SignalR is an impressive library and service from Microsoft designed for real-time applications.

In this example, we'll explore how the SignalR library can be integrated with Azure's hosted SignalR service. To begin, create a .NET 8 Web API project using the .NET 8 SDK.

When using Azure-hosted SignalR, the workflow should follow these steps:

The client connects to the server application to obtain the SignalR endpoint (hosted on Azure) and an access token.
The SignalR library connects to the Azure Negotiate endpoint using the provided access token.
Once connected, communication between the client and server is enabled.

Code

Let's dive into the coding process.

First, create a configuration class named AppSettings to hold our configuration details:

public class AppSettings
{
    public string AzureSignalREndpoint { get; set; }
}

Next, define an interface for IHubContextStore:

public interface IHubContextStore
{
    public ServiceHubContext ChatHubContext { get; }
}

Now, implement the SignalRService class:

using AzureSignalR;
using Microsoft.Azure.SignalR.Management;

public class SignalRService(AppSettings configuration, ILoggerFactory loggerFactory) : IHostedService, IHubContextStore
{
    private const string ChatHub = "Chat";
    public ServiceHubContext ChatHubContext { get; private set; }

    async Task IHostedService.StartAsync(CancellationToken cancellationToken)
    {
        using var serviceManager = new ServiceManagerBuilder()
            .WithOptions(o=>o.ConnectionString = configuration.AzureSignalREndpoint)
            .WithLoggerFactory(loggerFactory)
            .BuildServiceManager();
        ChatHubContext = await serviceManager.CreateHubContextAsync(ChatHub, cancellationToken);
    }

    Task IHostedService.StopAsync(CancellationToken cancellationToken)
    {
        return Task.WhenAll(Dispose(ChatHubContext));
    }

    private static Task Dispose(ServiceHubContext hubContext)
    {
        if (hubContext == null)
        {
            return Task.CompletedTask;
        }
        return hubContext.DisposeAsync();
    }
}

and finally our Program.cs


using AzureSignalR;
using Microsoft.AspNetCore.Mvc;

var builder = WebApplication.CreateBuilder(args);

var config = builder.Configuration.GetSection("AppSettings").Get<AppSettings>();
builder.Services.AddSingleton(config);

builder.Services.AddEndpointsApiExplorer();
builder.Services.AddSwaggerGen();

builder.Services.AddCors(x => 
    x.AddDefaultPolicy(p=>
        p.AllowAnyHeader().AllowAnyMethod().AllowAnyOrigin()
    )
);

builder.Services.AddSignalR().AddAzureSignalR(options =>
{
    options.ConnectionString = config.AzureSignalREndpoint;
});

builder.Services
    .AddSingleton<SignalRService>()
    .AddHostedService(sp => sp.GetService<SignalRService>())
    .AddSingleton<IHubContextStore>(sp => sp.GetService<SignalRService>());

var app = builder.Build();

app.UseCors();

if (app.Environment.IsDevelopment())
{
    app.UseSwagger();
    app.UseSwaggerUI();
}

app.UseHttpsRedirection();

app.MapGet("/login", async ([FromServices]IHubContextStore store) =>
{
    var negotiateResponse = await store.ChatHubContext.NegotiateAsync();
    return negotiateResponse;
});

app.UseAzureSignalR(routes =>
{
    routes.MapHub<Chat>("/chat");
});

app.Run();

This Program.cs file performs the following key tasks:

Configuration Setup: Retrieves the configuration settings from the AppSettings class.
Swagger Support: Adds support for Swagger to document and test the API endpoints.
CORS Configuration: Enables Cross-Origin Resource Sharing (CORS) to allow communication between different origins.
SignalR Registration: Registers SignalR services and configures them to use the Azure SignalR endpoint.
SignalR Service Registration: Registers the SignalRService class as a singleton and hosted service, making it available for the application's lifetime.
Azure SignalR Usage: Configures the application to use Azure SignalR with specified hub routes.
/login Endpoint: Defines an endpoint to negotiate and obtain the SignalR configuration (URL and access token) for the client.
Application Run: Starts the application.

This Program.cs file acts as the entry point for the application, orchestrating the setup and configuration of various services, including SignalR integration with Azure.

For the client side, create an HTML file with the following content:

<html>
<head>
    <style>
        #messages {
            list-style: none
        }

        #messages li {
            margin-top: 10px;
        }

        #messages .user {
            background-color: #e1fce8;
            border-radius: 10px;
            padding: 10px;
        }

        #messages .system {
            text-align: right;
            background-color: #e1f0fc;
            border-radius: 10px;
            padding: 10px;
        }
    </style>
    <script src="https://cdnjs.cloudflare.com/ajax/libs/microsoft-signalr/6.0.1/signalr.js"></script>
    <script src="./index.js"></script>
</head>
<body>
    <ul id="messages"></ul>
    <textarea id="text" rows="10" cols="50"></textarea>
    <br>
    <button id="btn">
        Send
    </button>

    <script>
        init();
    </script>
</body>
</html>

Create a JavaScript file named index.js with the following content:

function ajax(method, url, cb) {
  var xmlhttp = new XMLHttpRequest();

  xmlhttp.onreadystatechange = function () {
    if (xmlhttp.readyState == XMLHttpRequest.DONE) {
      if (xmlhttp.status == 200) {
        return cb(null, JSON.parse(xmlhttp.responseText));
      }
      cb(xmlhttp.status + " error");
    }
  };

  xmlhttp.open(method, url, true);
  xmlhttp.send();
}

function addtext(message, cls) {
  var li = document.createElement("li");
  var text = document.createTextNode(message);
  li.appendChild(text);
  li.classList = [cls];
  document.getElementById("messages").appendChild(li);
}

function bindConnectionMessage(connection) {
  var messageCallback = function (name, message) {
    if (!message) return;
    addtext(message, "system");
  };  
  connection.on("echo", messageCallback);
}


var connection;


function connect(url, token) {
  connection = new signalR.HubConnectionBuilder()
    .withUrl(url, { accessTokenFactory: () => token })
    .build();

  bindConnectionMessage(connection);
  connection
    .start()
    .catch(function (error) {
      console.error(error.message);
    });
}

ajax("GET", "http://localhost:5065/login", function (err, data) {
  connect(data.url, data.accessToken);
});

function init() {
  document.getElementById("btn").addEventListener("click", async (e) => {
    try {
      var message = document.getElementById("text").value;
      addtext(message, "user");
      document.getElementById("text").value = "";
      await connection.invoke("echo", "user", message);
    } catch (err) {
      console.error(err);
    }
  });
}

This simple client is sufficient for testing our Azure SignalR instance. When both the server and client are running, the result should resemble the image below:

Conclusion:

In conclusion, leveraging SignalR in conjunction with Azure's hosted SignalR service empowers developers to create dynamic, real-time applications with ease. The seamless integration of SignalR into the Azure environment streamlines the process of building responsive and interactive applications that can handle communication between clients and servers in real-time.

Throughout this article, we've covered the essential steps, from project setup and configuration to the implementation of SignalR services. The code examples provided demonstrate how to connect clients to the Azure SignalR service, facilitating instant communication and collaboration.

By adopting this approach, developers can harness the power of SignalR to enhance user experiences, making applications more engaging and responsive. Whether you're building a chat application, live updates for a dashboard, or any other real-time feature, SignalR on Azure proves to be a robust solution.

As you embark on your real-time application development journey, keep in mind the flexibility and scalability that Azure SignalR brings to the table. Consider exploring additional Azure services to complement your real-time solutions and meet the specific needs of your application.

In summary, SignalR on Azure opens up a realm of possibilities for developers looking to create modern, responsive applications that thrive in the world of real-time communication.

sample code can be found here: https://github.com/dejandjenic/AzureSignalR

originally published at https://www.dejandjenic.com/blogs/azure-signalr.html

Simplifying Workflow Management with the XWorkflows Library

dejandjenic — Sun, 19 Nov 2023 17:20:10 +0000

Simplifying Workflow Management with the XWorkflows Library

Introduction

Managing complex workflows within software applications can quickly become a challenge, especially when dealing with multiple states, actions, and entities. Navigating the intricacies of transitioning between these states while ensuring data integrity can lead to spaghetti code and maintenance headaches. Fortunately, the XWorkflows library emerges as a powerful tool to address these concerns, offering an elegant and efficient solution for managing workflow behavior.

Installation

Before we dive into the details, let's get started with the installation process. The XWorkflows library is conveniently available on NuGet, making it effortless to integrate into your projects. To install the library, follow these simple steps:

Open your NuGet Package Manager Console.

Run the following command:

Install-Package XWorkflows

The library and its dependencies will be fetched and installed into your project.

With the XWorkflows library in your toolkit, you're ready to explore how it simplifies and enhances workflow management within your software applications.

Basic Concepts

At the heart of the XWorkflows library lie several fundamental concepts that form the building blocks of effective workflow management. Let's briefly explore these concepts before diving into practical implementation:

Workflow Entities: These are the subjects of your workflows, entities that undergo state transitions based on actions. The library provides a framework to manage the state changes of these entities gracefully.

Workflow Actions: Actions encapsulate specific tasks that can be executed on entities. They define the logic associated with each transition and can lead to changes in the entity's state.

Workflow Events: Events are triggered upon successful action execution. They allow for additional tasks such as logging, notifications, and post-action execution logic.

Workflow States: States represent the various stages an entity can go through. Each state defines the actions that can be performed from it, encapsulating the logic for transitioning.

Workflow: A workflow brings all these pieces together, organizing and orchestrating the execution of actions and managing the state transitions of entities.

With these core concepts in mind, let's delve into how to implement and utilize the XWorkflows library to achieve effective workflow management in your applications.

In the following sections, we'll guide you through the process of setting up workflows, defining actions and states, handling errors, and exploring advanced features that allow for tailored customization and efficient workflow management. Let's get started!

Getting Started

Now that we have a foundational understanding of the core concepts of the XWorkflows library, let's dive into getting started with practical implementation.

Defining Entities

Entities are at the center of your workflow management. They represent the objects that undergo state transitions as actions are executed. To define an entity that can be managed by XWorkflows, you'll need to create a class that implements the IWorkflowStateEntity interface. This interface provides the necessary methods to retrieve and update the entity's state.

public class OrderEntity : IWorkflowStateEntity<State>
{
    public string Identifier { get; set; }
    public State State { get; set; }

    public async Task<string> GetIdentifier()
    {
        return Identifier;
    }

    public async Task<State> GetState()
    {
        return State;
    }

    public async Task SetState(State state, string identifier)
    {
        State = state;
    }
}

Creating Actions

Actions define the specific tasks that can be executed within a workflow. They encapsulate the logic associated with state transitions and can be triggered by external events or triggers. To create a custom action, you'll need to inherit from the WorkflowAction class provided by the library.

public class SubmitOrderAction : WorkflowAction<OrderWorkflow, SubmitOrderEvent, CreatedState, OrderEntity, State, SubmitOrderActionRequest, SubmitOrderActionRequest, bool>
{
    public SubmitOrderAction(CreatedState state, SubmitOrderEvent e) : base(state, e)
    {
    }

    public override async Task<(WorkflowActionResult<bool>, SubmitOrderActionRequest)> Execute(OrderEntity data, SubmitOrderActionRequest p, CancellationToken cancellationToken)
    {
        // Custom logic for submitting an order
        // Transition the entity's state and perform necessary tasks

        return (WorkflowActionResult<bool>.Succeeded(true), p);
    }
}

Creating Events

Events provide the opportunity to perform tasks after an action is successfully executed. They can include tasks such as logging, sending notifications, or updating related data. To create an event, implement the IWorkflowEvent interface or derive from the WorkflowEvent class.

public class SubmitOrderEvent : WorkflowEvent<OrderWorkflow, CreatedState, OrderEntity, State>
{
    public override async Task Execute(OrderEntity data, CancellationToken cancellationToken)
    {
        // Perform post-action tasks like logging or notifications
    }
}

In the next sections of this article, we will cover more advanced topics such as error handling, managing multiple workflows, and customizing action/event execution. We will also provide practical examples showcasing how the XWorkflows library can be applied to real-world scenarios to simplify workflow management.

Part 2: Advanced Features and Practical Examples

Welcome to Part 2 of our article on simplifying workflow management with the XWorkflows library. In this section, we will explore more advanced features and delve into practical examples to demonstrate the versatility and power of the library.

Error Handling

As any software system grows, handling errors becomes crucial. In the XWorkflows library, error handling is well-integrated to ensure smooth workflow execution even in the face of unexpected situations. The library provides mechanisms to handle invalid state transitions and exceptions during action execution.

try
{
    // Execute an action within a workflow
    var actionRequest = new CustomActionRequest { /* Request data */ };
    var (result, response) = await workflow.ExecuteAction(entity, actionRequest);
}
catch (WorkflowException ex)
{
    // Handle the exception
    Console.WriteLine($"Workflow Error: {ex.Message}");
}

Managing Multiple Workflows

In real-world applications, managing workflows for different entities is common. The XWorkflows library excels in this area, allowing you to define and manage separate workflows with their own states and actions.

var orderWorkflow = new OrderWorkflow(actionsForOrder);
var taskWorkflow = new TaskWorkflow(actionsForTask);

// Execute actions within respective workflows
await orderWorkflow.ExecuteAction(orderEntity, submitOrderRequest);
await taskWorkflow.ExecuteAction(taskEntity, updateStatusRequest);

Customizing Action and Event Execution

The flexibility of the XWorkflows library extends to customizing the execution of actions and events. You can override methods within action and event classes to inject custom logic before and after execution.

public class CustomAction : WorkflowAction<MyWorkflow, MyEvent, MyState, MyEntity, State, CustomRequest, CustomRequest, bool>
{
    protected CustomAction(MyState state, MyEvent e) : base(state, e)
    {
    }

    public override async Task<(WorkflowActionResult<bool>, CustomRequest)> Execute(MyEntity data, CustomRequest p, CancellationToken cancellationToken)
    {
        // Custom pre-execution logic
        Log("Executing CustomAction...");

        var result = await base.Execute(data, p, cancellationToken);

        // Custom post-execution logic
        Log("CustomAction executed successfully!");

        return result;
    }
}

Practical Examples

In this part of the article, we'll provide practical examples showcasing the XWorkflows library in action:

Order Processing Workflow: We'll demonstrate how to implement a complete order processing workflow using XWorkflows. This example will cover the submission, cancellation, and delivery of orders, each with their respective actions and events.

Task Management Workflow: We'll dive into creating a workflow for managing tasks. This example will guide you through the definition of states, actions, and events to handle task status updates, completions, and cancellations.

Approval Workflow: This example will showcase an approval workflow for managing document approval processes. We'll cover submitting documents for approval, approving/rejecting them, and leveraging events for notifications.

Conclusion

In this section, we've explored advanced features of the XWorkflows library that empower developers to handle error scenarios, manage multiple workflows, and customize action/event execution. We've also introduced practical examples that highlight the versatility and practicality of the library in real-world scenarios.

By harnessing the power of the XWorkflows library, developers can simplify and streamline complex workflow management, leading to more maintainable, organized, and efficient software applications.

Part 3: Practical Examples

Welcome to Part 3 of our article on simplifying workflow management with the XWorkflows library. In this section, we will dive into practical examples that demonstrate the library's capabilities in real-world scenarios.

Example 1: Order Processing Workflow

In this example, we'll walk you through the implementation of an order processing workflow using the XWorkflows library.

Scenario
Consider an e-commerce platform where orders transition through different states: "Created," "Submitted," "Delivered," and "Canceled." We will create actions for submitting, canceling, and delivering orders, along with events for logging and notifications.

Implementation
Define the Order Entity:

Create a class OrderEntity that implements IWorkflowStateEntity. This class will hold the order's identifier and state.

// Define the OrderEntity class
// https://github.com/dejandjenic/XWorkflows.Examples

Create Actions and Events:

Define actions for submitting, canceling, and delivering orders. Create corresponding events for each action to handle post-action tasks.

// Define actions and events
// https://github.com/dejandjenic/XWorkflows.Examples

Define States:

Create classes for each order state, inheriting from WorkflowStateBase. Define the allowed transitions for each state.

// Define states
// https://github.com/dejandjenic/XWorkflows.Examples

Create the OrderWorkflow:

Define the OrderWorkflow class, registering the actions and states.

// Create the OrderWorkflow class
// https://github.com/dejandjenic/XWorkflows.Examples

Execute Workflow Actions:

Instantiate the OrderEntity and execute actions within the workflow.

// Instantiate OrderEntity
var order = new OrderEntity { /* Initialize properties */ };

// Execute actions within the workflow
var submitRequest = new SubmitOrderActionRequest { /* Request data */ };
var (submitResult, submitResponse) = await orderWorkflow.ExecuteAction(order, submitRequest);

Example 2: Task Management Workflow

In this example, we'll guide you through the implementation of a task management workflow using the XWorkflows library.

Scenario
Imagine a task management application where tasks transition through states: "Open," "In Progress," "Completed," and "Canceled." We'll define actions for updating task status, marking tasks as completed, and canceling tasks.

Implementation
Define the Task Entity:

Create a class TaskEntity that implements IWorkflowStateEntity. This class will store the task's identifier and state.

// Define the TaskEntity class
// https://github.com/dejandjenic/XWorkflows.Examples

Create Actions and Events:

Define actions for updating task status, completing tasks, and canceling tasks. Implement corresponding events for post-action tasks.

// Define actions and events
// https://github.com/dejandjenic/XWorkflows.Examples

Define States:

Create classes for each task state, inheriting from WorkflowStateBase. Specify allowed transitions for each state.

// Define states
// https://github.com/dejandjenic/XWorkflows.Examples

Create the TaskWorkflow:

Define the TaskWorkflow class, registering actions and states.

// Create the TaskWorkflow class
// https://github.com/dejandjenic/XWorkflows.Examples

Execute Workflow Actions:

Instantiate the TaskEntity and execute actions within the workflow.

// Instantiate TaskEntity
var task = new TaskEntity { /* Initialize properties */ };

// Execute actions within the workflow
var updateStatusRequest = new UpdateTaskStatusActionRequest { /* Request data */ };
var (updateStatusResult, updateStatusResponse) = await taskWorkflow.ExecuteAction(task, updateStatusRequest);

Example 3: Approval Workflow

In our final example, we'll showcase the XWorkflows library's application in an approval workflow scenario.

Scenario
Consider a document approval process with states: "Draft," "Pending Approval," "Approved," and "Rejected." We'll create actions for submitting documents, approving/rejecting them, and events for notifications.

Implementation
Define the Document Entity:

Create a class DocumentEntity implementing IWorkflowStateEntity. This class will hold the document's identifier and state.

// Define the DocumentEntity class
// https://github.com/dejandjenic/XWorkflows.Examples

Create Actions and Events:

Define actions for submitting documents, approving them, and rejecting them. Create corresponding events for notifications.

// Define actions and events
// https://github.com/dejandjenic/XWorkflows.Examples

Define States:

Create classes for each document state, inheriting from WorkflowStateBase. Specify allowed transitions.

// Define states
// https://github.com/dejandjenic/XWorkflows.Examples

Create the ApprovalWorkflow:

Define the ApprovalWorkflow class, registering actions and states.

// Create the ApprovalWorkflow class
// https://github.com/dejandjenic/XWorkflows.Examples

Execute Workflow Actions:

Instantiate the DocumentEntity and execute actions within the workflow.

// Instantiate DocumentEntity
var document = new DocumentEntity { /* Initialize properties */ };

// Execute actions within the workflow
var submitRequest = new SubmitForApprovalActionRequest { /* Request data */ };
var (submitResult, submitResponse) = await approvalWorkflow.ExecuteAction(document, submitRequest);

Conclusion

In this section, we've explored practical examples that demonstrate how the XWorkflows library can be applied to real-world scenarios. Through the order processing, task management, and approval workflow examples, we've showcased the library's versatility and power in simplifying workflow management within software applications.

By following these examples and harnessing the capabilities of the XWorkflows library, developers can efficiently manage complex workflows, ensure data integrity, and achieve organized and maintainable software systems.

References and Resources

XWorkflows Examples GitHub Repository: https://github.com/dejandjenic/XWorkflows.Examples

NuGet Package: XWorkflows

Originally published at https://www.dejandjenic.com/blogs/workflow-management.html