Hsm.OperationalContextService.ServiceBusClient 1.0.0-alpha.0

Hsm.OperationalContextService.ServiceBusClient

A .NET client library for communicating with the Hsm Operational Context Service over Azure Service Bus, providing request-response and pub-sub messaging patterns for activation and deactivation operations.

Overview

This package provides implementations for sending requests and processing responses from the Operational Context Service using Azure Service Bus. It includes strongly-typed clients for:

• Activation Requests: Request activation of a device with specific properties
• Deactivation Requests: Request deactivation of a device

Use

using System.Text.Json;
using Microsoft.Extensions.DependencyInjection;
using Hsm.OperationalContextService.ServiceBusClient.Configuration;
using Hsm.OperationalContextService.ServiceBusClient.Extensions;
using Hsm.OperationalContextService.ServiceBusClient.Abstractions.Client;
using Hsm.OperationalContextService.ServiceBusClient.Abstractions.Messages.V1.Models;
using Hsm.OperationalContextService.ServiceBusClient.Abstractions.Messages.Enums;
using Hsm.OperationalContextService.ServiceBusClient.Abstractions.Subscriber;
using Microsoft.Extensions.Configuration;
using Microsoft.Extensions.Logging;

var serviceCollection = new ServiceCollection();
serviceCollection.AddLogging(builder => { builder.AddConsole(); });

var configuration = new ConfigurationBuilder()
    .AddUserSecrets<Program>()
    .Build();

var serviceBusConfig = new OperationalContextServiceServiceBusConfiguration();
configuration.GetRequiredSection(nameof(OperationalContextServiceServiceBusConfiguration)).Bind(serviceBusConfig);

serviceCollection.AddOperationalContextClient(serviceBusConfig, new());
var serviceProvider = serviceCollection.BuildServiceProvider();

var activationClient = serviceProvider.GetRequiredService<IActivationRequestClientV1>();
// deactivationClient is handled exactly the same as activationClient so skipped in this example
var deactivationClient = serviceProvider.GetRequiredService<IDeactivationRequestClientV1>();

var messageProcessor = serviceProvider.GetRequiredService<IServiceBusMessageProcessor>();
var logger = serviceProvider.GetRequiredService<ILogger<Program>>();

//1) register handlers in Client
activationClient.AcceptedEventHandler += (_, args) => LogResponseAsync(args);
activationClient.RejectedEventHandler += (_, args) => LogResponseAsync(args);
activationClient.SucceededEventHandler += (_, args) => LogResponseAsync(args);
activationClient.FailedEventHandler += (_, args) => LogResponseAsync(args);

//2) start processing of messages.
//  Any clients not yet setup will have their messages discarded (eg in this example all DeactivationMessages would be discarded)
//  this is needed because those deactivation messages may block ActivationMessages from execution
await messageProcessor.StartProcessingMessagesAsync();

try
{
    //Requests are processed serverside one by one to maintain ordering.
    //  if you run in timeouts decrease request-volume or increase the timeout in the configuration
    var response = await activationClient.SendRequestAsync(
        new ActivationRequestMessageV1(
            CorrelationId: Guid.NewGuid(),
            DeviceId: Guid.NewGuid(),
            CountryCode: "AT",
            TimeZone: "America/New_York",
            Label: "ServiceBusClient.Example - auto-created",
            DeviceRole: DeviceRole.Stable
        ));

    if (!response.IsSuccess)
    {
        logger.LogInformation("Activation request was rejected: {Serialized}",
            JsonSerializer.Serialize(response.RejectedMessage));
    }
    else
    {
        logger.LogInformation("Activation request was accepted: {Serialized}",
            JsonSerializer.Serialize(response.AcceptedMessage));
    }
    
    // So we can see further messages in the logs
    await Task.Delay(TimeSpan.FromMinutes(1));
}
catch (TimeoutException ex)
{
    logger.LogInformation("No response received within timeout: {ExMessage}", ex.Message);
}
catch (Exception ex)
{
    logger.LogInformation("An error occurred: {ExMessage}", ex.Message);
}

Task LogResponseAsync<T>(CorrelatedMessageEventArgs<T> correlatedMessageEventArgs)
    where T : ICorrelatedMessage
{
    logger.LogInformation("{Name}: {Serialized}", typeof(T).Name,
        JsonSerializer.Serialize(correlatedMessageEventArgs.Message));
    return Task.CompletedTask;
}