XmppBrokerNode.cs

using System;
using System.Collections;
using System.Collections.Generic;
using System.Threading.Tasks;
using Waher.Networking;
using Waher.Networking.Sniffers;
using Waher.Networking.XMPP;
using Waher.Persistence;
using Waher.Persistence.Attributes;
using Waher.Runtime.Language;
using Waher.Things.Attributes;
using Waher.Things.DisplayableParameters;
using Waher.Things.Ip;
using Waher.Things.Xmpp.Commands;
using Waher.Things.Xmpp.Model;
 
namespace Waher.Things.Xmpp
{
    public class XmppBrokerNode : IpHostPort, ICommunicationLayer, IEncryptedProperties
    {
        private readonly Dictionary<CaseInsensitiveString, RosterItemNode> roster = new Dictionary<CaseInsensitiveString, RosterItemNode>();
        private string userName = string.Empty;
        private string password = string.Empty;
        private string passwordMechanism = string.Empty;
        private string brokerKey = null;
        private bool trustServer = false;
        private bool allowInsecureMechanisms = false;
 
        public XmppBrokerNode()
            : base()
        {
            this.Port = 5222;
            this.Tls = true;
        }
 
        [Page(2, "XMPP")]
        [Header(13, "User Name:")]
        [ToolTip(14, "User name used during authentication process.")]
        [DefaultValueStringEmpty]
        public string UserName
        {
            get => this.userName;
            set => this.userName = value;
        }
 
        [Page(2, "XMPP")]
        [Header(15, "Password:")]
        [ToolTip(16, "Password used during authentication process.")]
        [Masked]
        [Encrypted(32)]
        public string Password
        {
            get => this.password;
            set => this.password = value;
        }
 
        public string[] EncryptedProperties => new string[] { nameof(this.Password) };
 
        [Page(2, "XMPP")]
        [Header(17, "Password Hash Mechanism:")]
        [ToolTip(18, "Mechanism used for password hash.")]
        [DefaultValueStringEmpty]
        public string PasswordMechanism
        {
            get => this.passwordMechanism;
            set => this.passwordMechanism = value;
        }
 
        [Page(2, "XMPP")]
        [Header(19, "Trust Server Certificate")]
        [ToolTip(20, "If the server certificate should be trusted, even if it does not validate.")]
        [DefaultValue(false)]
        public bool TrustServer
        {
            get => this.trustServer;
            set => this.trustServer = value;
        }
 
        [Page(2, "XMPP")]
        [Header(21, "Allow Insecure Mechanisms")]
        [ToolTip(22, "If insecure mechanisms are permitted during authentication.")]
        [DefaultValue(false)]
        public bool AllowInsecureMechanisms
        {
            get => this.allowInsecureMechanisms;
            set => this.allowInsecureMechanisms = value;
        }
 
        [Page(28, "Roster", 110)]
        [Header(32, "Auto-accept Pattern:")]
        [ToolTip(33, "If a presence subscription comes from a JID that matches this regular expression, it will be automatically accepted.")]
        public string AutoAcceptPattern { get; set; }
 
        public override Task<string> GetTypeNameAsync(Language Language)
        {
            return Language.GetStringAsync(typeof(XmppBrokerNode), 23, "XMPP Broker");
        }
 
        public override Task<bool> AcceptsChildAsync(INode Child)
        {
            return Task.FromResult(
                Child is ConcentratorNode || 
                Child is ConcentratorSourceNode || 
                Child is ConcentratorPartitionNode ||
                Child is ConcentratorDevice || 
                Child is RosterItemNode || 
                Child is XmppExtensionNode);
        }
 
        public override Task DestroyAsync()
        {
            if (!string.IsNullOrEmpty(this.brokerKey))
                XmppBrokers.DestroyBroker(this.brokerKey);
 
            return base.DestroyAsync();
        }
 
        [IgnoreMember]
        public string Key
        {
            get
            {
                string PrevKey = this.brokerKey;
                this.brokerKey = XmppBrokers.GetKey(this.Host, this.Port, this.Tls, this.userName, this.password, this.passwordMechanism);
 
                if (PrevKey != this.brokerKey && !string.IsNullOrEmpty(PrevKey))
                    XmppBrokers.DestroyBroker(PrevKey);
 
                return this.brokerKey;
            }
        }
 
        protected override Task NodeUpdated()
        {
            this.GetBroker();
 
            return base.NodeUpdated();
        }
 
        internal XmppBroker GetCachedBroker()
        {
            return XmppBrokers.GetCachedBroker(this.Key);
        }
 
        internal Task<XmppBroker> GetBroker()
        {
            return XmppBrokers.GetBroker(this, this.Key, this.Host, this.Port, this.Tls, this.userName, this.password,
                this.passwordMechanism, this.trustServer, this.allowInsecureMechanisms);
        }
 
        #region ICommunicationLayer
 
        public bool DecoupledEvents => true;
 
        public void Add(ISniffer Sniffer)
        {
            this.GetBroker().Result?.Client?.Add(Sniffer);
        }
 
        public void AddRange(IEnumerable<ISniffer> Sniffers)
        {
            this.GetBroker().Result?.Client?.AddRange(Sniffers);
        }
 
        public bool Remove(ISniffer Sniffer)
        {
            return this.GetBroker().Result?.Client?.Remove(Sniffer) ?? false;
        }
 
        public ISniffer[] Sniffers
        {
            get { return this.GetBroker().Result?.Client?.Sniffers ?? Array.Empty<ISniffer>(); }
        }
 
        public bool HasSniffers
        {
            get { return this.GetBroker().Result?.Client?.HasSniffers ?? false; }
        }
 
        public IEnumerator<ISniffer> GetEnumerator()
        {
            return new SnifferEnumerator(this.Sniffers);
        }
 
        IEnumerator IEnumerable.GetEnumerator()
        {
            return this.GetBroker().Result?.Client?.GetEnumerator() ?? Array.Empty<ISniffer>().GetEnumerator();
        }
 
        public void ReceiveBinary(int Count) => this.GetCachedBroker()?.Client?.ReceiveBinary(Count);
 
        public void ReceiveBinary(bool ConstantBuffer, byte[] Data) => this.GetCachedBroker()?.Client?.ReceiveBinary(ConstantBuffer, Data);
 
        public void ReceiveBinary(bool ConstantBuffer, byte[] Data, int Offset, int Count) => this.GetCachedBroker()?.Client?.ReceiveBinary(ConstantBuffer, Data, Offset, Count);
 
        public void TransmitBinary(int Count) => this.GetCachedBroker()?.Client?.TransmitBinary(Count);
 
        public void TransmitBinary(bool ConstantBuffer, byte[] Data) => this.GetCachedBroker()?.Client?.TransmitBinary(ConstantBuffer, Data);
 
        public void TransmitBinary(bool ConstantBuffer, byte[] Data, int Offset, int Count) => this.GetCachedBroker()?.Client?.TransmitBinary(ConstantBuffer, Data, Offset, Count);
 
        public void ReceiveText(string Text) => this.GetCachedBroker()?.Client?.ReceiveText(Text);
 
        public void TransmitText(string Text) => this.GetCachedBroker()?.Client?.TransmitText(Text);
 
        public void Information(string Comment) => this.GetCachedBroker()?.Client?.Information(Comment);
 
        public void Warning(string Warning) => this.GetCachedBroker()?.Client?.Warning(Warning);
 
        public void Error(string Error) => this.GetCachedBroker()?.Client?.Error(Error);
 
        public void Exception(Exception Exception) => this.GetCachedBroker()?.Client?.Exception(Exception);
 
        public void Exception(string Exception) => this.GetCachedBroker()?.Client?.Exception(Exception);
 
        public void ReceiveBinary(DateTime Timestamp, int Count) => this.GetCachedBroker()?.Client?.ReceiveBinary(Timestamp, Count);
 
        public void ReceiveBinary(DateTime Timestamp, bool ConstantBuffer, byte[] Data) => this.GetCachedBroker()?.Client?.ReceiveBinary(Timestamp, ConstantBuffer, Data);
 
        public void ReceiveBinary(DateTime Timestamp, bool ConstantBuffer, byte[] Data, int Offset, int Count) => this.GetCachedBroker()?.Client?.ReceiveBinary(Timestamp, ConstantBuffer, Data, Offset, Count);
 
        public void TransmitBinary(DateTime Timestamp, int Count) => this.GetCachedBroker()?.Client?.TransmitBinary(Timestamp, Count);
 
        public void TransmitBinary(DateTime Timestamp, bool ConstantBuffer, byte[] Data) => this.GetCachedBroker()?.Client?.TransmitBinary(Timestamp, ConstantBuffer, Data);
 
        public void TransmitBinary(DateTime Timestamp, bool ConstantBuffer, byte[] Data, int Offset, int Count) => this.GetCachedBroker()?.Client?.TransmitBinary(Timestamp, ConstantBuffer, Data, Offset, Count);
 
        public void ReceiveText(DateTime Timestamp, string Text) => this.GetCachedBroker()?.Client?.ReceiveText(Timestamp, Text);
 
        public void TransmitText(DateTime Timestamp, string Text) => this.GetCachedBroker()?.Client?.TransmitText(Timestamp, Text);
 
        public void Information(DateTime Timestamp, string Comment) => this.GetCachedBroker()?.Client?.Information(Timestamp, Comment);
 
        public void Warning(DateTime Timestamp, string Warning) => this.GetCachedBroker()?.Client?.Warning(Timestamp, Warning);
 
        public void Error(DateTime Timestamp, string Error) => this.GetCachedBroker()?.Client?.Error(Timestamp, Error);
 
        public void Exception(DateTime Timestamp, string Exception) => this.GetCachedBroker()?.Client?.Exception(Timestamp, Exception);
 
        public void Exception(DateTime Timestamp, Exception Exception) => this.GetCachedBroker()?.Client?.Exception(Timestamp, Exception);
 
        #endregion
 
        public override Task<IEnumerable<ICommand>> Commands => this.GetCommands();
 
        public async Task<IEnumerable<ICommand>> GetCommands()
        {
            List<ICommand> Result = new List<ICommand>();
 
            Result.AddRange(await base.Commands);
            Result.Add(new ReconnectCommand((await this.GetBroker()).Client));
 
            return Result;
        }
 
        public async override Task<IEnumerable<Parameter>> GetDisplayableParametersAsync(Language Language, RequestOrigin Caller)
        {
            LinkedList<Parameter> Result = await base.GetDisplayableParametersAsync(Language, Caller) as LinkedList<Parameter>;
            XmppBroker Broker = await this.GetBroker();
 
            Result.AddLast(new StringParameter("State", await Language.GetStringAsync(typeof(XmppBrokerNode), 27, "State"),
                Broker.Client.State.ToString() ?? string.Empty));
 
            return Result;
        }
 
        #region Roster
 
        public async Task<RosterItemNode> GetRosterItem(string BareJID, bool CreateIfNotExists)
        {
            RosterItemNode Result;
            bool Load;
 
            lock (this.roster)
            {
                if (this.roster.TryGetValue(BareJID, out Result))
                    return Result;
 
                Load = this.roster.Count == 0;
            }
 
            if (Load)
            {
                IEnumerable<INode> Children = await this.ChildNodes;
 
                lock (this.roster)
                {
                    foreach (INode Node in Children)
                    {
                        if (Node is RosterItemNode RosterItem)
                            this.roster[RosterItem.BareJID] = RosterItem;
                    }
 
                    if (this.roster.TryGetValue(BareJID, out Result))
                        return Result;
                }
            }
 
            if (CreateIfNotExists)
            {
                Result = new RosterItemNode()
                {
                    NodeId = await GetUniqueNodeId(this.NodeId + ", " + BareJID),
                    BareJID = BareJID
                };
 
                await this.AddAsync(Result);
 
                return Result;
            }
            else
                return null;
        }
 
        public override async Task AddAsync(INode Child)
        {
            await base.AddAsync(Child);
 
            if (Child is RosterItemNode Item)
            {
                lock (this.roster)
                {
                    this.roster[Item.BareJID] = Item;
                }
            }
 
            if (Child is XmppExtensionNode Extension)
            {
                try
                {
                    XmppBroker Broker = await this.GetBroker();
                    XmppClient Client = Broker.Client;
 
                    if (!Extension.IsRegisteredExtension(Client))
                        await Extension.RegisterExtension(Client);
                }
                catch (Exception ex)
                {
                    await this.LogErrorAsync(ex.Message);
                }
            }
        }
 
        public override async Task<bool> RemoveAsync(INode Child)
        {
            if (!await base.RemoveAsync(Child))
                return false;
 
            if (Child is RosterItemNode Item)
            {
                lock (this.roster)
                {
                    this.roster.Remove(Item.BareJID);
                }
            }
 
            if (Child is XmppExtensionNode Extension)
            {
                try
                {
                    XmppBroker Broker = await this.GetBroker();
                    XmppClient Client = Broker.Client;
 
                    if (Extension.IsRegisteredExtension(Client))
                        await Extension.UnregisterExtension(Client);
                }
                catch (Exception ex)
                {
                    await this.LogErrorAsync(ex.Message);
                }
            }
 
            return true;
        }
 
        #endregion
 
    }
}