RpicHybridRelay 1.0.0

Hybrid Relay Contracts

Standardized processor classes for Azure Hybrid Relay using encrypted application settings files and a generic pattern for creating processor classes.

Worker startup for Windows Service:

using System.Diagnostics.CodeAnalysis;
using HybridRelaySettings = Rpic.Common.HybridRelay.HybridRelaySettings;

namespace Sample.HybridRelayListener
{
    public class Worker : BackgroundService
    {
        private readonly ILogger<Worker> _logger;

        public Worker(ILogger<Worker> logger)
        {
            _logger = logger;
        }

        protected override async Task ExecuteAsync(CancellationToken stoppingToken)
        {
            // Create action controller that will perform an action when called remotely
            var processor = new InventoryExportProcessor();

            // Encryption seed for protecting the configuration file
            const string encryption = "UPD_zPH -@kXd.Zg!xVi7@6XYZK.Z6R";

            // Load relay settings
            var settings = HybridRelaySettings.Load(encryption);

            // Create listener service
            var listener = new Rpic.Common.HybridRelay.HybridRelayListener(
                processor.Process, // The method that will be called when the listener receives data
                settings,
                encryption,
                _logger);

            // Start the service
            await listener.Start(); // Start the listener and register a channel to hybrid relay
            _logger.LogInformation("Worker started at: {time}", DateTimeOffset.Now);

            // Keep running until service stopped
            while (!stoppingToken.IsCancellationRequested)
            {
                await Task.Delay(1000, stoppingToken);
            }

            // Remove the channel listener registration 
            await listener.Stop();
            _logger.LogInformation("Worker stopped at: {time}", DateTimeOffset.Now);
        }
    }
}

Settings file:

{
  "Logging": {
    "LogLevel": {
      "Default": "Information",
      "Microsoft.Hosting.Lifetime": "Information"
    }
  },
  "HybridRelay": {
    "DisplayName": "RPIC Proxy Service",
    "Description": "Hybrid relay service listener for publishing data records to RPIC Integration Platform.",
    "Namespace": "relay-rpic-lekman-ts",
    "Connection": "hrc-template-rpic-ts",
    "Key": {
      "Value": "Add initial secret here",
      "Secret": "Value will be updated once service starts and encrypt to local machine key and entropy"
    },
    "KeyName": "RootManageSharedAccessKey"
  }
}

Implementation of service process:

using System.Diagnostics.CodeAnalysis;
using System.Runtime.CompilerServices;
using Microsoft.Azure.Relay;
using Newtonsoft.Json;
using Rpic.Common.HybridRelay;

namespace Rpic.InventoryLogistics.InventoryExport.HybridRelayListener
{
    internal class SampleProcessor : IHybridRelayListenerProcessor
    {
        internal string Process(Stream stream, ILogger logger)
        {
            // Add code to call private API
            var response = SomeService.Call();
         
            // Return as JSON
            return JsonConvert.SerializeObject(response);
        }
    }
}