PortMonitor.cs

using System;
using System.Collections.Generic;
using System.Security.Cryptography.X509Certificates;
using System.Text;
using System.Threading.Tasks;
using Waher.Content;
using Waher.Networking;
using Waher.Networking.Sniffers;
using Waher.Persistence.Attributes;
using Waher.Runtime.Inventory;
using Waher.Runtime.Language;
using Waher.Script.Functions.Runtime;
using Waher.Security;
using Waher.Things.Attributes;
using Waher.Things.DisplayableParameters;
using Waher.Things.Metering;
using Waher.Things.SensorData;
 
namespace Waher.Things.Ip
{
    public class PortMonitor : ProvisionedMeteringNode, ISensor
    {
        private string protocol = string.Empty;
        private int port = 0;
        private bool tls = false;
 
        public override Task<bool> AcceptsChildAsync(INode Child)
        {
            return Task.FromResult(false);
        }
 
        public override Task<bool> AcceptsParentAsync(INode Parent)
        {
            return Task.FromResult(Parent is IpHost);
        }
 
        public override Task<string> GetTypeNameAsync(Language Language)
        {
            return Language.GetStringAsync(typeof(PortMonitor), 40, "Port Monitor");
        }
 
        [Page(1, "IP")]
        [Header(4, "Port Number:", 60)]
        [ToolTip(5, "Port number to use when communicating with device.")]
        [DefaultValue(0)]
        [Range(0, 65535)]
        [Required]
        public int Port
        {
            get => this.port;
            set => this.port = value;
        }
 
        [Page(1, "IP")]
        [Header(11, "Encrypted (TLS)", 70)]
        [ToolTip(12, "Check if Transport Layer Encryption (TLS) should be used.")]
        public bool Tls
        {
            get => this.tls;
            set => this.tls = value;
        }
 
        [Page(1, "IP")]
        [Header(41, "Protocol:", 60)]
        [ToolTip(42, "Name of protocol or service on port number.")]
        [DefaultValueStringEmpty]
        [Required]
        public string Protocol
        {
            get => this.protocol;
            set => this.protocol = value;
        }
 
        [Obsolete]
        public string PortName
        {
            get => this.protocol;
            set => this.protocol = value;
        }
 
        public async Task<string> GetHostName()
        {
            if (await this.GetParent() is IpHost Parent)
                return Parent.Host;
            else
                throw new Exception("Parent node not an IP Host node.");
        }
 
        public async Task<BinaryTcpClient> ConnectTcp(bool DecoupledEvents, params ISniffer[] Sniffers)
        {
            X509Certificate Certificate = Types.TryGetModuleParameter<X509Certificate>("X509");
            BinaryTcpClient Client = new BinaryTcpClient(DecoupledEvents, Sniffers);
            string HostName = await this.GetHostName();
            await Client.ConnectAsync(HostName, this.port, this.tls);
 
            if (this.tls)
            {
                await Client.UpgradeToTlsAsClient(Certificate, Crypto.SecureTls);
                Client.Continue();
            }
 
            return Client;
        }
 
        public async Task<TextTcpClient> ConnectTcp(Encoding Encoding, bool DecoupledEvents, params ISniffer[] Sniffers)
        {
            X509Certificate Certificate = Types.TryGetModuleParameter<X509Certificate>("X509");
            TextTcpClient Client = new TextTcpClient(Encoding, DecoupledEvents, Sniffers);
            string HostName = await this.GetHostName();
            await Client.ConnectAsync(HostName, this.port, this.tls);
 
            if (this.tls)
            {
                await Client.UpgradeToTlsAsClient(Certificate, Crypto.SecureTls);
                Client.Continue();
            }
 
            return Client;
        }
 
        public async override Task<IEnumerable<Parameter>> GetDisplayableParametersAsync(Language Language, RequestOrigin Caller)
        {
            LinkedList<Parameter> Result = await base.GetDisplayableParametersAsync(Language, Caller) as LinkedList<Parameter>;
 
            Result.AddLast(new Int32Parameter("Port", await Language.GetStringAsync(typeof(IpHost), 10, "Port"), this.port));
 
            if (!string.IsNullOrEmpty(this.Protocol))
                Result.AddLast(new StringParameter("Protocol", await Language.GetStringAsync(typeof(IpHost), 43, "Protocol"), this.protocol));
 
            return Result;
        }
 
        public async virtual Task StartReadout(ISensorReadout Request)
        {
            try
            {
                DateTime Now = DateTime.UtcNow;
                string Module = typeof(IpHost).Namespace;
                
                using BinaryTcpClient Client = await this.ConnectTcp(false);
 
                List<Field> Fields = new List<Field>()
                    {
                        new QuantityField(this, Now, "Connect", (DateTime.UtcNow-Now).TotalMilliseconds, 0, "ms", FieldType.Momentary, FieldQoS.AutomaticReadout, Module, 13)
                    };
 
                if (Request.IsIncluded(FieldType.Identity) && this.Tls)
                {
                    IpHostPort.AddCertificateFields(Client.RemoteCertificate, 
                        Client.RemoteCertificateValid, this, Now, Fields);
                }
 
                await Request.ReportFields(true, Fields);
            }
            catch (Exception ex)
            {
                await Request.ReportErrors(true, new ThingError(this, ex.Message));
            }
        }
 
    }
}