ModbusGatewayNode.cs

using System;
using System.Collections;
using System.Collections.Generic;
using System.Linq;
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)
        {
            if (!this.sniffers.Contains(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 void ReceiveBinary(int Count) => this.sniffers.ReceiveBinary(Count);
 
        public void ReceiveBinary(bool ConstantBuffer, byte[] Data) => this.sniffers.ReceiveBinary(ConstantBuffer, Data);
 
        public void ReceiveBinary(bool ConstantBuffer, byte[] Data, int Offset, int Count) => this.sniffers.ReceiveBinary(ConstantBuffer, Data, Offset, Count);
 
        public void TransmitBinary(int Count) => this.sniffers.TransmitBinary(Count);
 
        public void TransmitBinary(bool ConstantBuffer, byte[] Data) => this.sniffers.TransmitBinary(ConstantBuffer, Data);
 
        public void TransmitBinary(bool ConstantBuffer, byte[] Data, int Offset, int Count) => this.sniffers.TransmitBinary(ConstantBuffer, Data, Offset, Count);
 
        public void ReceiveText(string Text) => this.sniffers.ReceiveText(Text);
 
        public void TransmitText(string Text) => this.sniffers.TransmitText(Text);
 
        public void Information(string Comment) => this.sniffers.Information(Comment);
 
        public void Warning(string Warning) => this.sniffers.Warning(Warning);
 
        public void Error(string Error) => this.sniffers.Error(Error);
 
        public void Exception(Exception Exception) => this.sniffers.Exception(Exception);
 
        public void Exception(string Exception) => this.sniffers.Exception(Exception);
 
        public void ReceiveBinary(DateTime Timestamp, int Count) => this.sniffers.ReceiveBinary(Timestamp, Count);
 
        public void ReceiveBinary(DateTime Timestamp, bool ConstantBuffer, byte[] Data) => this.sniffers.ReceiveBinary(Timestamp, ConstantBuffer, Data);
 
        public void ReceiveBinary(DateTime Timestamp, bool ConstantBuffer, byte[] Data, int Offset, int Count) => this.sniffers.ReceiveBinary(Timestamp, ConstantBuffer, Data, Offset, Count);
 
        public void TransmitBinary(DateTime Timestamp, int Count) => this.sniffers.TransmitBinary(Timestamp, Count);
 
 
        public void TransmitBinary(DateTime Timestamp, bool ConstantBuffer, byte[] Data) => this.sniffers.TransmitBinary(Timestamp, ConstantBuffer, Data);
 
        public void TransmitBinary(DateTime Timestamp, bool ConstantBuffer, byte[] Data, int Offset, int Count) => this.sniffers.TransmitBinary(Timestamp, ConstantBuffer, Data, Offset, Count);
 
        public void ReceiveText(DateTime Timestamp, string Text) => this.sniffers.ReceiveText(Timestamp, Text);
 
        public void TransmitText(DateTime Timestamp, string Text) => this.sniffers.TransmitText(Timestamp, Text);
 
        public void Information(DateTime Timestamp, string Comment) => this.sniffers.Information(Timestamp, Comment);
 
        public void Warning(DateTime Timestamp, string Warning) => this.sniffers.Warning(Timestamp, Warning);
 
        public void Error(DateTime Timestamp, string Error) => this.sniffers.Error(Timestamp, Error);
 
        public void Exception(DateTime Timestamp, string Exception) => this.sniffers.Exception(Timestamp, Exception);
 
        public void 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
 
        #region Commands
 
        public override Task<IEnumerable<ICommand>> Commands => this.GetCommands();
 
        private async Task<IEnumerable<ICommand>> GetCommands()
        {
            List<ICommand> Commands = new List<ICommand>();
            Commands.AddRange(await base.Commands);
            return Commands.ToArray();
        }
 
        #endregion
    }
}