ProxyDomain.cs

using System;
using System.Collections.Generic;
using System.Text;
using System.Threading.Tasks;
using Waher.Networking;
using Waher.Networking.HTTP;
using Waher.Networking.Sniffers;
using Waher.Runtime.Language;
using Waher.Things;
using Waher.Things.Attributes;
using Waher.Things.DisplayableParameters;
 
namespace Waher.Service.IoTBroker.Sources.GatewayConfig
{
    public class ProxyDomain : ConfigurationNode, ICommunicationLayer
    {
        private readonly ICommunicationLayer comLayer;
 
        public ProxyDomain()
            : base(null, null)
        {
            this.LocalDomain = string.Empty;
            this.RemoteDomain = string.Empty;
            this.RemoteFolder = string.Empty;
            this.RemotePort = 0;
            this.Encrypted = false;
            this.UseSession = false;
            this.TimeoutMs = 30000;
            this.Privilege = string.Empty;
        }
 
        public ProxyDomain(GatewayConfigSource Source, WebServer Parent, string LocalDomain, string RemoteDomain, string RemoteFolder,
            int RemotePort, bool Encrypted, bool UseSession, int TimeoutMs, string Privilege, ICommunicationLayer CommunicationLayer)
            : base(Source, Parent)
        {
            this.LocalDomain = LocalDomain;
            this.RemoteDomain = RemoteDomain;
            this.RemoteFolder = RemoteFolder;
            this.RemotePort = RemotePort;
            this.Encrypted = Encrypted;
            this.UseSession = UseSession;
            this.TimeoutMs = TimeoutMs;
            this.Privilege = Privilege;
            this.comLayer = CommunicationLayer;
        }
 
        [Page(7, "Configuration")]
        [Header(139, "Local Domain:")]
        [ToolTip(140, "Local Domain that will act as a reverse proxy.")]
        [Required]
        public string LocalDomain { get; set; }
 
        [Page(7, "Configuration")]
        [Header(87, "Remote Domain:")]
        [ToolTip(88, "Domain of web server to forward requests to.")]
        [Required]
        public string RemoteDomain { get; set; }
 
        [Page(7, "Configuration")]
        [Header(89, "Remote Folder:")]
        [ToolTip(90, "Base folder on remote domain that requests will be forwarded to.")]
        public string RemoteFolder { get; set; }
 
        [Page(7, "Configuration")]
        [Header(91, "Remote Port:")]
        [ToolTip(92, "Port number of remote domain that requests will be forwarded to.")]
        [Range(1, 65535)]
        [Required]
        public int RemotePort { get; set; }
 
        [Page(7, "Configuration")]
        [Header(93, "Use encryption.")]
        [ToolTip(94, "If forwarded requests are encrypted (HTTPS) or not (HTTP).")]
        [Required]
        public bool Encrypted { get; set; }
 
        [Page(7, "Configuration")]
        [Header(95, "Use proxy-session.")]
        [ToolTip(96, "If the proxy uses a session itself.")]
        [Text(TextPosition.AfterField, 97, "Note: By making the proxy use a proxy-session itself, the broker can add SSO token information in forwarded requests, making underlying services aware of the currently logged in user identity.")]
        public bool UseSession { get; set; }
 
        [Page(7, "Configuration")]
        [Header(34, "Timeout (ms):")]
        [ToolTip(98, "Timeout afforded to forwarded requests, in milliseconds, before they are assumed to have failed.")]
        [Range(1, 120 * 1000)]
        [Text(TextPosition.AfterField, 63, "Note: Changes will take effect after broker has been restarted.")]
        public int TimeoutMs { get; set; }
 
        [Page(7, "Configuration")]
        [Header(247, "Required Privilege:")]
        [ToolTip(248, "Required privilege to access the resource. If not specified, the resource is public.")]
        public string Privilege { get; set; }
 
        public override string NodeId => this.LocalDomain;
 
        public override Task<string> GetTypeNameAsync(Language Language) => Language.GetStringAsync(typeof(GatewayConfigSource), 141, "Reverse Proxy Domain");
 
        public override Task<bool> AcceptsParentAsync(INode Parent)
        {
            return Task.FromResult(Parent is WebServer);
        }
 
        public override async Task<IEnumerable<Parameter>> GetDisplayableParametersAsync(Language Language, RequestOrigin Caller)
        {
            LinkedList<Parameter> Parameters = new LinkedList<Parameter>();
            Namespace Namespace = await Language.GetNamespaceAsync(typeof(GatewayConfigSource).Namespace);
 
            StringBuilder sb = new StringBuilder();
 
            sb.Append("http");
            if (this.Encrypted)
                sb.Append('s');
 
            sb.Append("://");
            sb.Append(this.RemoteDomain);
 
            if (this.RemotePort != (this.Encrypted ? HttpServer.DefaultHttpsPort : HttpServer.DefaultHttpPort))
            {
                sb.Append(':');
                sb.Append(this.RemotePort.ToString());
            }
 
            sb.Append(this.RemoteFolder);
 
            Parameters.AddLast(new StringParameter("Location", await Namespace.GetStringAsync(82, "Location"), sb.ToString()));
            Parameters.AddLast(new BooleanParameter("UseSession", await Namespace.GetStringAsync(53, "Session"), this.UseSession));
            Parameters.AddLast(new Int32Parameter("TimeoutMs", await Namespace.GetStringAsync(54, "Timeout (ms)"), this.TimeoutMs));
            Parameters.AddLast(new StringParameter("Privilege", await Namespace.GetStringAsync(249, "Privilege"), this.Privilege));
 
            return Parameters;
        }
 
        #region ICommunicationLayer
 
        public bool DecoupledEvents => this.comLayer?.DecoupledEvents ?? false;
 
        public void Add(ISniffer Sniffer)
        {
            this.comLayer?.Add(Sniffer);
        }
 
        public void AddRange(IEnumerable<ISniffer> Sniffers)
        {
            this.comLayer?.AddRange(Sniffers);
        }
 
        public bool Remove(ISniffer Sniffer) => this.comLayer?.Remove(Sniffer) ?? false;
 
        public ISniffer[] Sniffers => this.comLayer?.Sniffers;
 
        public bool HasSniffers => this.comLayer?.HasSniffers ?? false;
 
        public IEnumerator<ISniffer> GetEnumerator() => this.comLayer?.GetEnumerator();
 
        System.Collections.IEnumerator System.Collections.IEnumerable.GetEnumerator() => this.comLayer?.GetEnumerator();
 
        public void ReceiveBinary(int Count) => this.comLayer?.ReceiveBinary(Count);
 
        public void ReceiveBinary(bool ConstantBuffer, byte[] Data) => this.comLayer?.ReceiveBinary(ConstantBuffer, Data);
 
        public void ReceiveBinary(bool ConstantBuffer, byte[] Data, int Offset, int Count) => this.comLayer?.ReceiveBinary(ConstantBuffer, Data, Offset, Count);
 
        public void TransmitBinary(int Count) => this.comLayer?.TransmitBinary(Count);
 
        public void TransmitBinary(bool ConstantBuffer, byte[] Data) => this.comLayer?.TransmitBinary(ConstantBuffer, Data);
 
        public void TransmitBinary(bool ConstantBuffer, byte[] Data, int Offset, int Count) => this.comLayer?.TransmitBinary(ConstantBuffer, Data, Offset, Count);
 
        public void ReceiveText(string Text) => this.comLayer?.ReceiveText(Text);
 
        public void TransmitText(string Text) => this.comLayer?.TransmitText(Text);
 
        public void Information(string Comment) => this.comLayer?.Information(Comment);
 
        public void Warning(string Warning) => this.comLayer?.Warning(Warning);
 
        public void Error(string Error) => this.comLayer?.Error(Error);
 
        public void Exception(Exception Exception) => this.comLayer?.Exception(Exception);
 
        public void Exception(string Exception) => this.comLayer?.Exception(Exception);
 
        public void ReceiveBinary(DateTime Timestamp, int Count) => this.comLayer?.ReceiveBinary(Timestamp, Count);
 
        public void ReceiveBinary(DateTime Timestamp, bool ConstantBuffer, byte[] Data) => this.comLayer?.ReceiveBinary(Timestamp, ConstantBuffer, Data);
 
        public void ReceiveBinary(DateTime Timestamp, bool ConstantBuffer, byte[] Data, int Offset, int Count) => this.comLayer?.ReceiveBinary(Timestamp, ConstantBuffer, Data, Offset, Count);
 
        public void TransmitBinary(DateTime Timestamp, int Count) => this.comLayer?.TransmitBinary(Timestamp, Count);
 
        public void TransmitBinary(DateTime Timestamp, bool ConstantBuffer, byte[] Data) => this.comLayer?.TransmitBinary(Timestamp, ConstantBuffer, Data);
 
        public void TransmitBinary(DateTime Timestamp, bool ConstantBuffer, byte[] Data, int Offset, int Count) => this.comLayer?.TransmitBinary(Timestamp, ConstantBuffer, Data, Offset, Count);
 
        public void ReceiveText(DateTime Timestamp, string Text) => this.comLayer?.ReceiveText(Timestamp, Text);
 
        public void TransmitText(DateTime Timestamp, string Text) => this.comLayer?.TransmitText(Timestamp, Text);
 
        public void Information(DateTime Timestamp, string Comment) => this.comLayer?.Information(Timestamp, Comment);
 
        public void Warning(DateTime Timestamp, string Warning) => this.comLayer?.Warning(Timestamp, Warning);
 
        public void Error(DateTime Timestamp, string Error) => this.comLayer?.Error(Timestamp, Error);
 
        public void Exception(DateTime Timestamp, string Exception) => this.comLayer?.Exception(Timestamp, Exception);
 
        public void Exception(DateTime Timestamp, Exception Exception) => this.comLayer?.Exception(Timestamp, Exception);
 
        #endregion
 
    }
}