ConnectionsSource.cs

using System;
using System.Collections.Generic;
using System.Threading.Tasks;
using Waher.Events;
using Waher.Networking;
using Waher.Networking.XMPP.Server;
using Waher.Networking.XMPP.Server.Statistics;
using Waher.Runtime.Language;
using Waher.Things;
using Waher.Things.SourceEvents;
 
namespace Waher.Service.IoTBroker.Sources.Connections
{
    public class ConnectionsSource : IDataSource
    {
        public const string SourceID = "Connections";
 
        private readonly Dictionary<Guid, string> jidByConnection = new Dictionary<Guid, string>();
        private readonly ClientConnections clientConnections;
        private readonly ServerConnections serverConnections;
        private readonly INode[] nodes;
 
        public ConnectionsSource()
        {
            this.nodes = new INode[]
            {
                this.clientConnections = new ClientConnections(),
                this.serverConnections = new ServerConnections()
            };
        }
 
        string IDataSource.SourceID => SourceID;
        public bool HasChildren => false;
        public DateTime LastChanged => DateTime.MinValue;
        public IEnumerable<IDataSource> ChildSources => null;
        public IEnumerable<INode> RootNodes => this.nodes;
        public event EventHandlerAsync<SourceEvent> OnEvent;
 
        public Task<bool> CanViewAsync(RequestOrigin Caller)
        {
            return Task.FromResult(Caller.HasPrivilege("Source." + SourceID + ".View"));
        }
 
        public Task<string> GetNameAsync(Language Language)
        {
            return Language.GetStringAsync(typeof(XmppServerModule), 9, "Connections");
        }
 
        public Task<INode> GetNodeAsync(IThingReference NodeRef)
        {
            switch (NodeRef.Partition)
            {
                case "C2S":
                    if (XmppServerModule.Server.TryGetClientConnection(NodeRef.NodeId, out IClientConnection C2sConnection))
                        return Task.FromResult<INode>(new ClientConnection(this.clientConnections, C2sConnection));
                    break;
 
                case "S2S":
                    if (XmppServerModule.Server.TryGetS2sStatistics(NodeRef.NodeId, out S2sEndpointStatistics Stat))
                    {
                        if (!XmppServerModule.Server.TryGetS2sEndpoint(NodeRef.NodeId, out IS2SEndpoint S2sConnection))
                            S2sConnection = null;
 
                        return Task.FromResult<INode>(new ServerConnection(this.serverConnections, Stat, S2sConnection));
                    }
                    break;
 
                default:
                    foreach (INode Node in this.nodes)
                    {
                        if (Node.NodeId == NodeRef.NodeId &&
                            Node.SourceId == NodeRef.SourceId &&
                            Node.Partition == NodeRef.Partition)
                        {
                            return Task.FromResult<INode>(Node);
                        }
                    }
                    break;
            }
 
 
            return Task.FromResult<INode>(null);
        }
 
        internal async Task ClientConnectionAdded(object Sender, ClientConnectionEventArgs e)
        {
            try
            {
                ClientConnection Node = new ClientConnection(this.clientConnections, e.Connection);
                NodeAdded Event = await NodeAdded.FromNode(Node, await Translator.GetDefaultLanguageAsync(), RequestOrigin.Empty, Node is ICommunicationLayer);
 
                lock (this.jidByConnection)
                {
                    this.jidByConnection[e.Connection.Id] = Event.NodeId;
                }
 
                await this.OnEvent.Raise(this, Event);
            }
            catch (Exception ex)
            {
                Log.Exception(ex);
            }
        }
 
        internal async Task ClientConnectionRemoved(object Sender, ClientConnectionEventArgs e)
        {
            lock (this.jidByConnection)
            {
                this.jidByConnection.Remove(e.Connection.Id);
            }
 
            ClientConnection Node = new ClientConnection(this.clientConnections, e.Connection);
            NodeRemoved Event = NodeRemoved.FromNode(Node);
 
            await this.OnEvent.Raise(this, Event);
        }
 
        internal async Task ClientConnectionUpdated(object Sender, ClientConnectionEventArgs e)
        {
            try
            {
                ClientConnection Node = new ClientConnection(this.clientConnections, e.Connection);
                string OldId;
 
                lock (this.jidByConnection)
                {
                    if (!this.jidByConnection.TryGetValue(e.Connection.Id, out OldId))
                        OldId = string.Empty;
                }
 
                NodeUpdated Event = await NodeUpdated.FromNode(Node, await Translator.GetDefaultLanguageAsync(), RequestOrigin.Empty, OldId);
 
                lock (this.jidByConnection)
                {
                    this.jidByConnection[e.Connection.Id] = Event.NodeId;
                }
 
                await this.OnEvent.Raise(this, Event);
            }
            catch (Exception ex)
            {
                Log.Exception(ex);
            }
        }
 
        internal async Task ServerConnectionAdded(object _, Networking.XMPP.Server.ServerConnectionEventArgs e)
        {
            S2sEndpointStatistics Stat = XmppServerModule.Server.GetS2sStatistics(e.Connection.RemoteDomain, e.Connection.Type);
            ServerConnection Node = new ServerConnection(this.serverConnections, Stat, e.Connection);
            await this.OnEvent.Raise(this, await NodeAdded.FromNode(Node, await Translator.GetDefaultLanguageAsync(), RequestOrigin.Empty, Node is ICommunicationLayer));
        }
 
        internal async Task ServerConnectionRemoved(object _, Networking.XMPP.Server.ServerConnectionEventArgs e)
        {
            S2sEndpointStatistics Stat = XmppServerModule.Server.GetS2sStatistics(e.Connection.RemoteDomain, e.Connection.Type);
            ServerConnection Node = new ServerConnection(this.serverConnections, Stat, e.Connection);
            await this.OnEvent.Raise(this, NodeRemoved.FromNode(Node));
        }
 
        internal async Task ServerConnectionUpdated(object _, Networking.XMPP.Server.ServerConnectionEventArgs e)
        {
            S2sEndpointStatistics Stat = XmppServerModule.Server.GetS2sStatistics(e.Connection.RemoteDomain, e.Connection.Type);
            ServerConnection Node = new ServerConnection(this.serverConnections, Stat, e.Connection);
            await this.OnEvent.Raise(this, await NodeUpdated.FromNode(Node, await Translator.GetDefaultLanguageAsync(), RequestOrigin.Empty));
        }
 
    }
}