Session.cs

using System;
using System.Collections.Generic;
using System.Threading.Tasks;
using Waher.Events;
using Waher.Networking.HTTP.JsonRpc;
using Waher.Networking.HTTP.Mcp.Model.Client;
using Waher.Networking.Sniffers;
 
namespace Waher.Networking.HTTP.Mcp.Model.Server
{
    public class Session : IDisposableAsync, IJsonRpcSession
    {
        private readonly HashSet<string> subscriptions = new HashSet<string>();
        private readonly ISnifferSet? snifferSet;
        private readonly bool hasSnifferSet;
        private InMemorySniffer? unauthenticatedSniffer;
        private string userName = "Not Authenticated";
        private bool isAuthenticated = false;
 
        public Session(string SessionId, string ClientProtocolVersion,
            ClientCapabilities? ClientCapabilities, Implementation? Implementation,
            string RemoteEndpoint, ISnifferSet? SnifferSet)
        {
            this.SessionId = SessionId;
            this.ClientProtocolVersion = ClientProtocolVersion;
            this.ClientCapabilities = ClientCapabilities;
            this.ClientInformation = Implementation;
            this.RemoteEndpoint = RemoteEndpoint;
            this.snifferSet = SnifferSet;
            this.hasSnifferSet = !(SnifferSet is null);
 
            this.unauthenticatedSniffer = new InMemorySniffer(200, SessionId);
        }
 
        public string SessionId { get; }
 
        public string ClientProtocolVersion { get; }
 
        public ClientCapabilities? ClientCapabilities { get; }
 
        public Implementation? ClientInformation { get; }
 
        public string RemoteEndpoint { get; }
 
        public string UserName => this.userName;
 
        public bool IsAuthenticated => this.isAuthenticated;
 
        [Obsolete("Use DisposeAsync instead.")]
        public void Dispose()
        {
            this.DisposeAsync().Wait();
        }
 
        public async Task DisposeAsync()
        {
            if (!(this.unauthenticatedSniffer is null))
            {
                await this.unauthenticatedSniffer.DisposeAsync();
                this.unauthenticatedSniffer = null;
            }
 
            lock (this.subscriptions)
            {
                this.subscriptions.Clear();
            }
        }
 
        internal async Task SetUserName(string UserName)
        {
            this.userName = UserName;
 
            if (!this.isAuthenticated)
            {
                this.isAuthenticated = true;
 
                if (this.hasSnifferSet)
                    this.unauthenticatedSniffer?.Replay(UserName, this.snifferSet);
 
                if (!(this.unauthenticatedSniffer is null))
                {
                    await this.unauthenticatedSniffer.DisposeAsync();
                    this.unauthenticatedSniffer = null;
                }
            }
        }
 
        internal void ReceiveText(string Text)
        {
            if (this.hasSnifferSet)
            {
                if (this.isAuthenticated)
                    this.snifferSet!.ReceiveText(this.userName, Text);
                else
                    this.unauthenticatedSniffer?.ReceiveText(Text);
            }
        }
 
        public void TransmitText(string Text)
        {
            if (this.hasSnifferSet)
            {
                if (this.isAuthenticated)
                    this.snifferSet!.TransmitText(this.userName, Text);
                else
                    this.unauthenticatedSniffer?.TransmitText(Text);
            }
        }
 
        internal void Information(string Text)
        {
            if (this.hasSnifferSet)
            {
                if (this.isAuthenticated)
                    this.snifferSet!.Information(this.userName, Text);
                else
                    this.unauthenticatedSniffer?.Information(Text);
            }
        }
 
        internal void Warning(string Text)
        {
            if (this.hasSnifferSet)
            {
                if (this.isAuthenticated)
                    this.snifferSet!.Warning(this.userName, Text);
                else
                    this.unauthenticatedSniffer?.Warning(Text);
            }
        }
 
        internal void Error(string Text)
        {
            if (this.hasSnifferSet)
            {
                if (this.isAuthenticated)
                    this.snifferSet!.Error(this.userName, Text);
                else
                    this.unauthenticatedSniffer?.Error(Text);
            }
        }
 
        internal void Exception(Exception Exception)
        {
            if (this.hasSnifferSet)
            {
                if (this.isAuthenticated)
                    this.snifferSet!.Exception(this.userName, Exception);
                else
                    this.unauthenticatedSniffer?.Exception(Exception);
            }
        }
 
        public bool IsSubscribed(string Uri)
        {
            lock (this.subscriptions)
            {
                return this.subscriptions.Contains(Uri);
            }
        }
 
        public bool Subscribe(string Uri)
        {
            lock (this.subscriptions)
            {
                return this.subscriptions.Add(Uri);
            }
        }
 
        public bool Unsubscribe(string Uri)
        {
            lock (this.subscriptions)
            {
                return this.subscriptions.Remove(Uri);
            }
        }
    }
}