SignalR

.gitignore

@@ -123,4 +123,4 @@ yarn-error.log*
 *.csproj.user
 
 # Go bin files 
-__debug_bin
+__debug_bin

cppseminar/docker-compose.yml

@@ -38,6 +38,10 @@ services:
             - ./presentation/Model:/src/Model
             - ./presentation/Pages:/src/Pages
             - ./presentation/Services:/src/Services
+            - ./presentation/wwwroot:/src/wwwroot
+            - ./presentation/Hubs:/src/Hubs
+            - ./presentation/Filters:/src/Filters
+            - ./presentation/appsettings.json:/src/appsettings.json
         networks:
             - sharednet
         ports:
@@ -57,6 +61,7 @@ services:
         restart: always
         depends_on:
             - rabbitmq.local
+            - monitoringservice.local
 
     userservice.local:
         build:
@@ -261,7 +266,46 @@ services:
             - ./envoy/envoy.yaml:/etc/envoy/envoy.yaml
         networks:
             - sharednet
+
+    redis.local:
+        image: redis:7.2.0
+        build:
+            target: dev
+        networks:
+            - sharednet
+        ports:
+            - 6379:6379
+        restart: always
 
+    monitoringservice.local:
+        build:
+            context: ./monitoringservice
+            target: dev
+        volumes:
+            - ./monitoringservice/Program.cs:/src/Program.cs
+            - ./monitoringservice/Startup.cs:/src/Startup.cs
+            - ./monitoringservice/Model:/src/Model
+            - ./monitoringservice/Services:/src/Services
+            - ./monitoringservice/Controllers:/src/Controllers
+            - ./monitoringservice/monitoringservice.csproj:/src/monitoringservice.csproj
+            - ./monitoringservice/appsettings.json:/src/appsettings.json
+        networks:
+            - sharednet
+        ports:
+            - 8085:80
+        environment:
+            DOTNET_USE_POLLING_FILE_WATCHER: 1
+            DOTNET_WATCH_SUPPRESS_MSBUILD_INCREMENTALISM: 1
+            DOTNET_WATCH_SUPPRESS_LAUNCH_BROWSER: 1
+            DOTNET_WATCH_SUPPRESS_BROWSER_REFRESH: 1
+            ASPNETCORE_ENVIRONMENT: Development
+            API_GATEWAY: http://gateway.local:5000/
+            LOG_PRETTY: 1
+        restart: always
+        depends_on:
+            redis.local:
+                condition: service_started
+
 
 networks:
     sharednet:

cppseminar/envoy/envoy.yaml

@@ -45,6 +45,10 @@ static_resources:
                             path_separated_prefix: /test
                           route:
                             cluster: test-service
+                        - match:
+                            path_separated_prefix: /monitoring
+                          route:
+                            cluster: monitoring-service
                 http_filters:
                   - name: envoy.filters.http.router
                     typed_config:
@@ -88,4 +92,15 @@ static_resources:
                   address:
                     socket_address:
                       address: submissions.local
-                      port_value: 80
+                      port_value: 80
+    - name: monitoring-service
+      type: strict_dns
+      load_assignment:
+        cluster_name: monitoring-service
+        endpoints:
+          - lb_endpoints:
+              - endpoint:
+                  address:
+                    socket_address:
+                      address: monitoringservice.local
+                      port_value: 80

cppseminar/monitoringservice/Controllers/MonitoringController.cs

@@ -0,0 +1,61 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Threading.Tasks;
+using Microsoft.AspNetCore.Mvc;
+using Microsoft.Extensions.Logging;
+using System.Text.Json;
+using monitoringservice.Model;
+using monitoringservice.Services;
+
+namespace monitoringservice.Controllers;
+
+[Route("monitoring")]
+[ApiController]
+public class MonitoringController : ControllerBase
+{
+    private readonly ILogger<MonitoringController> _logger;
+    private readonly StorageService _service;
+
+    public MonitoringController(ILogger<MonitoringController> logger, StorageService service)
+    {
+        _logger = logger;
+        _service = service;
+    }
+
+    [HttpGet("get/recents")]
+    public async Task<ActionResult<List<ConnectionLog>>> OnGetAsync()
+    {
+        try
+        {
+            return await _service.getConnectionLogsAsync();
+        }
+        catch (Exception e)
+        {
+            _logger.LogError("Exception occured while retrieving all ConnectionLog records. " + e);
+            return StatusCode(500);
+        }
+    }
+
+    [HttpPost("post/log")]
+    public async Task<ActionResult> LogConnection([FromBody] ConnectionLog connectionLog)
+    {
+        if (connectionLog.UserEmail == null || connectionLog.Timestamp == null)
+        {
+            return BadRequest();
+        }
+        else
+        {
+            try
+            {
+                await _service.setConnectionlogAsync(connectionLog);
+                return Ok();
+            }
+            catch (Exception e)
+            {
+                _logger.LogError("Exception occured while logging user connection. " + e);
+                return StatusCode(500);
+            }
+        }
+    }
+}

cppseminar/monitoringservice/Dockerfile

@@ -0,0 +1,21 @@
+FROM mcr.microsoft.com/dotnet/aspnet:6.0 AS base
+WORKDIR /app
+EXPOSE 80
+
+FROM mcr.microsoft.com/dotnet/sdk:6.0 AS build
+WORKDIR /src
+COPY ["monitoringservice.csproj", "./monitoringservice.csproj"]
+RUN dotnet restore "monitoringservice.csproj"
+COPY . .
+RUN dotnet build "monitoringservice.csproj" -c Release -o /app/build
+
+FROM build as dev
+CMD dotnet watch run --urls=http://0.0.0.0:80
+
+FROM build AS publish
+RUN dotnet publish "monitoringservice.csproj" -c Release -o /app/publish
+
+FROM base AS final
+WORKDIR /app
+COPY --from=publish /app/publish .
+ENTRYPOINT ["dotnet", "monitoringservice.dll"]

cppseminar/monitoringservice/Model/ConnectionLog.cs

@@ -0,0 +1,19 @@
+using System;
+using System.Collections.Generic;
+using System.ComponentModel.DataAnnotations;
+
+
+namespace monitoringservice.Model
+{
+    public class ConnectionLog
+    {
+        public ConnectionLog(string email, DateTime timestamp){
+            UserEmail = email;
+            Timestamp = timestamp;
+        }
+        public ConnectionLog(){
+        }
+        public string UserEmail { get; set; }
+        public DateTime Timestamp { get; set; }
+    }
+}

cppseminar/monitoringservice/Program.cs

@@ -0,0 +1,56 @@
+using System;
+using Microsoft.AspNetCore.Hosting;
+using Microsoft.Extensions.Hosting;
+using Serilog;
+using Serilog.Events;
+using Serilog.Formatting.Compact;
+using monitoringservice.Model;
+using monitoringservice.Services;
+
+namespace monitoringservice;
+
+public class Program
+{
+    public static void Main(string[] args)
+    {        
+        Log.Logger = new LoggerConfiguration()
+            .MinimumLevel.Verbose()
+            .MinimumLevel.Override("Microsoft", LogEventLevel.Warning)
+            .Enrich.FromLogContext()
+            .WriteTo.Console(new RenderedCompactJsonFormatter())
+            .CreateLogger();
+
+        try
+        {
+            Log.Information("Starting web host");
+            CreateHostBuilder(args).Build().Run();
+        }
+        catch (Exception e)
+        {
+            Log.Fatal("Host terminated unexpectedly. {e}", e);
+        }
+        finally
+        {
+            Log.CloseAndFlush();
+        }
+    }
+
+    public static IHostBuilder CreateHostBuilder(string[] args)
+    {
+        if (Environment.GetEnvironmentVariable("LOG_PRETTY") == "1")
+        {
+            return Host.CreateDefaultBuilder(args)
+                .ConfigureWebHostDefaults(webBuilder =>
+                {
+                    webBuilder.UseStartup<Startup>();
+                });
+        }
+        return Host.CreateDefaultBuilder(args)
+            .UseSerilog()
+            .ConfigureWebHostDefaults(webBuilder =>
+            {
+                webBuilder.UseStartup<Startup>();
+            });
+    }
+}
+

cppseminar/monitoringservice/Properties/launchSettings.json

@@ -0,0 +1,37 @@
+{
+  "iisSettings": {
+    "windowsAuthentication": false,
+    "anonymousAuthentication": true,
+    "iisExpress": {
+      "applicationUrl": "http://localhost:9271",
+      "sslPort": 44364
+    }
+  },
+  "profiles": {
+    "http": {
+      "commandName": "Project",
+      "dotnetRunMessages": true,
+      "launchBrowser": true,
+      "applicationUrl": "http://localhost:5224",
+      "environmentVariables": {
+        "ASPNETCORE_ENVIRONMENT": "Development"
+      }
+    },
+    "https": {
+      "commandName": "Project",
+      "dotnetRunMessages": true,
+      "launchBrowser": true,
+      "applicationUrl": "https://localhost:7026;http://localhost:5224",
+      "environmentVariables": {
+        "ASPNETCORE_ENVIRONMENT": "Development"
+      }
+    },
+    "IIS Express": {
+      "commandName": "IISExpress",
+      "launchBrowser": true,
+      "environmentVariables": {
+        "ASPNETCORE_ENVIRONMENT": "Development"
+      }
+    }
+  }
+}

cppseminar/monitoringservice/Services/StorageService.cs

@@ -0,0 +1,47 @@
+using StackExchange.Redis;
+using System.Text.Json;
+using System.Threading.Tasks;
+using Microsoft.Extensions.Logging;
+using monitoringservice.Model;
+
+namespace monitoringservice.Services;
+public class StorageService
+{
+    private readonly IDatabase _db;
+    private readonly IServer _server;
+    private readonly ILogger<StorageService> _logger;
+
+    public StorageService(ILogger<StorageService> logger)
+    {
+        ConnectionMultiplexer redis = ConnectionMultiplexer.Connect("redis.local");
+        _db = redis.GetDatabase();
+        _server = redis.GetServer("redis.local", 6379);
+        _logger = logger;
+    }
+
+    public async Task setConnectionlogAsync(ConnectionLog connectionLog)
+    {
+        await _db.StringSetAsync(connectionLog.UserEmail, connectionLog.Timestamp.ToString());
+    }
+
+    public async Task<string?> getValueAsync(string Key)
+    {
+        string value = await _db.StringGetAsync(Key);
+        return value;
+    }
+
+/* This works only when key-value pairs of string-string are in redis */
+
+    public async Task<List<ConnectionLog>> getConnectionLogsAsync()
+    {
+        List<ConnectionLog> connectionLogsList = new List<ConnectionLog>();
+
+        var emails = _server.Keys();
+        foreach (var email in emails)
+        {
+            var timestamp = await _db.StringGetAsync(email);
+            connectionLogsList.Add(new ConnectionLog(email, DateTime.Parse(timestamp)));
+        }
+        return connectionLogsList;
+    }
+}

cppseminar/monitoringservice/Startup.cs

@@ -0,0 +1,48 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Threading.Tasks;
+using Microsoft.AspNetCore.Builder;
+using Microsoft.AspNetCore.Hosting;
+using Microsoft.AspNetCore.Mvc;
+using Microsoft.Extensions.Configuration;
+using Microsoft.Extensions.DependencyInjection;
+using Microsoft.Extensions.Hosting;
+using Microsoft.Extensions.Logging;
+
+using monitoringservice.Services;
+using monitoringservice.Model;
+
+namespace monitoringservice;
+
+public class Startup
+{
+    public Startup(IConfiguration configuration)
+    {
+        Configuration = configuration;
+    }
+
+    public IConfiguration Configuration { get; }
+
+    // This method gets called by the runtime. Use this method to add services to the container.
+    public void ConfigureServices(IServiceCollection services)
+    {
+        services.AddControllers();
+        services.AddSingleton<StorageService>();
+    }
+
+    // This method gets called by the runtime. Use this method to configure the HTTP request pipeline.
+    public void Configure(IApplicationBuilder app, IWebHostEnvironment env)
+    {
+        if (env.IsDevelopment())
+        {
+            app.UseDeveloperExceptionPage();
+        }
+
+        app.UseRouting();
+        app.UseEndpoints(endpoints =>
+        {
+            endpoints.MapControllers();
+        });
+    }
+}