ModbusGatewayNode.cs

using System;
using System.Collections;
using System.Collections.Generic;
using System.Text;
using System.Threading.Tasks;
using Waher.Events;
using Waher.Networking;
using Waher.Networking.Modbus;
using Waher.Networking.Sniffers;
using Waher.Runtime.Cache;
using Waher.Runtime.Language;
using Waher.Runtime.Threading;
using Waher.Things.Ip;
 
namespace Waher.Things.Modbus
{
    public class ModbusGatewayNode : IpHostPort, ICommunicationLayer
    {
        private readonly CommunicationLayer sniffers = new CommunicationLayer(false);
 
        public ModbusGatewayNode()
            : base()
        {
            this.Port = 502;
            this.Tls = false;
        }
 
        public override Task<string> GetTypeNameAsync(Language Language)
        {
            return Language.GetStringAsync(typeof(ModbusGatewayNode), 1, "Modbus Gateway");
        }
 
        public override Task<bool> AcceptsChildAsync(INode Child)
        {
            return Task.FromResult(Child is ModbusUnitNode);
        }
 
        #region ICommunicationLayer
 
        public bool DecoupledEvents => this.sniffers.DecoupledEvents;
 
        public ISniffer[] Sniffers => this.sniffers.Sniffers;
 
        public bool HasSniffers => this.sniffers.HasSniffers;
 
        public void Add(ISniffer Sniffer) => this.sniffers.Add(Sniffer);
 
        public void AddRange(IEnumerable<ISniffer> Sniffers) => this.sniffers.AddRange(Sniffers);
 
        public bool Remove(ISniffer Sniffer) => this.sniffers.Remove(Sniffer);
 
        public IEnumerator<ISniffer> GetEnumerator() => this.sniffers.GetEnumerator();
 
        IEnumerator IEnumerable.GetEnumerator() => this.sniffers.GetEnumerator();
 
        public Task ReceiveBinary(byte[] Data) => this.sniffers.ReceiveBinary(Data);
 
        public Task TransmitBinary(byte[] Data) => this.sniffers.TransmitBinary(Data);
 
        public Task ReceiveText(string Text) => this.sniffers.ReceiveText(Text);
 
        public Task TransmitText(string Text) => this.sniffers.TransmitText(Text);
 
        public Task Information(string Comment) => this.sniffers.Information(Comment);
 
        public Task Warning(string Warning) => this.sniffers.Warning(Warning);
 
        public Task Error(string Error) => this.sniffers.Error(Error);
 
        public Task Exception(Exception Exception) => this.sniffers.Exception(Exception);
 
        public Task Exception(string Exception) => this.sniffers.Exception(Exception);
 
        public Task ReceiveBinary(DateTime Timestamp, byte[] Data) => this.sniffers.ReceiveBinary(Timestamp, Data);
 
        public Task TransmitBinary(DateTime Timestamp, byte[] Data) => this.sniffers.TransmitBinary(Timestamp, Data);
 
        public Task ReceiveText(DateTime Timestamp, string Text) => this.sniffers.ReceiveText(Timestamp, Text);
 
        public Task TransmitText(DateTime Timestamp, string Text) => this.sniffers.TransmitText(Timestamp, Text);
 
        public Task Information(DateTime Timestamp, string Comment) => this.sniffers.Information(Timestamp, Comment);
 
        public Task Warning(DateTime Timestamp, string Warning) => this.sniffers.Warning(Timestamp, Warning);
 
        public Task Error(DateTime Timestamp, string Error) => this.sniffers.Error(Timestamp, Error);
 
        public Task Exception(DateTime Timestamp, string Exception) => this.sniffers.Exception(Timestamp, Exception);
 
        public Task Exception(DateTime Timestamp, Exception Exception) => this.sniffers.Exception(Timestamp, Exception);
 
        #endregion
 
        #region TCP/IP connections
 
        private readonly static Cache<string, ModbusTcpClient> clients = GetCache();
        private readonly static MultiReadSingleWriteObject clientsSynchObject = new MultiReadSingleWriteObject(typeof(ModbusGatewayNode));
 
        private static Cache<string, ModbusTcpClient> GetCache()
        {
            Cache<string, ModbusTcpClient> Result = new Cache<string, ModbusTcpClient>(int.MaxValue, TimeSpan.MaxValue, TimeSpan.FromMinutes(5));
 
            Result.Removed += Result_Removed;
 
            return Result;
        }
 
        private static Task Result_Removed(object Sender, CacheItemEventArgs<string, ModbusTcpClient> e)
        {
            try
            {
                e.Value.Dispose();
            }
            catch (Exception ex)
            {
                Log.Exception(ex);
            }
 
            return Task.CompletedTask;
        }
 
        public async Task<ModbusTcpClient> GetTcpIpConnection()
        {
            StringBuilder sb = new StringBuilder();
 
            sb.Append(this.Host);
            sb.Append(this.Port.ToString());
            sb.Append(this.Tls.ToString());
 
            string Key = sb.ToString();
 
            if (clients.TryGetValue(Key, out ModbusTcpClient Client))
            {
                if (Client.Connected)
                {
                    this.CheckSniffers(Client);
                    return Client;
                }
                else
                    clients.Remove(Key);
            }
 
            await clientsSynchObject.BeginWrite();
            try
            {
                if (clients.TryGetValue(Key, out Client))
                    return Client;
 
                Client = await ModbusTcpClient.Connect(this.Host, this.Port, this.Tls, this.sniffers.Sniffers);
 
                clients[Key] = Client;
            }
            finally
            {
                await clientsSynchObject.EndWrite();
            }
 
            return Client;
        }
 
        private void CheckSniffers(ModbusTcpClient Client)
        {
            if (!Client.HasSniffers && !this.sniffers.HasSniffers)
                return;
 
            foreach (ISniffer Sniffer in Client.Sniffers)
            {
                bool Found = false;
 
                foreach (ISniffer Sniffer2 in this.sniffers.Sniffers)
                {
                    if (Sniffer == Sniffer2)
                    {
                        Found = true;
                        break;
                    }
                }
 
                if (!Found)
                    Client.Remove(Sniffer);
            }
 
            foreach (ISniffer Sniffer in this.sniffers.Sniffers)
            {
                bool Found = false;
 
                foreach (ISniffer Sniffer2 in Client.Sniffers)
                {
                    if (Sniffer == Sniffer2)
                    {
                        Found = true;
                        break;
                    }
                }
 
                if (!Found)
                    Client.Add(Sniffer);
            }
        }
 
        #endregion
    }
}