ProxyResource.cs

using System.Collections.Generic;
using System.Text;
using System.Threading.Tasks;
using Waher.Networking.HTTP;
using Waher.Runtime.Language;
using Waher.Things;
using Waher.Things.Attributes;
using Waher.Things.DisplayableParameters;
 
namespace Waher.Service.IoTBroker.Sources.GatewayConfig
{
    public class ProxyResource : ConfigurationNode
    {
        public ProxyResource()
            : base(null, null)
        {
            this.LocalResource = string.Empty;
            this.RemoteDomain = string.Empty;
            this.RemoteFolder = string.Empty;
            this.RemotePort = 0;
            this.Encrypted = false;
            this.UseSession = false;
            this.TimeoutMs = 30000;
        }
 
        public ProxyResource(GatewayConfigSource Source, WebServer Parent, string LocalResource, string RemoteDomain, string RemoteFolder,
            int RemotePort, bool Encrypted, bool UseSession, int TimeoutMs)
            : base(Source, Parent)
        {
            this.LocalResource = LocalResource;
            this.RemoteDomain = RemoteDomain;
            this.RemoteFolder = RemoteFolder;
            this.RemotePort = RemotePort;
            this.Encrypted = Encrypted;
            this.UseSession = UseSession;
            this.TimeoutMs = TimeoutMs;
        }
 
        [Page(7, "Configuration")]
        [Header(85, "Local Resource:")]
        [ToolTip(86, "Local Resource that will act as a reverse proxy.")]
        [Required]
        public string LocalResource { 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; }
 
        public override string NodeId => this.LocalResource;
 
        public override Task<string> GetTypeNameAsync(Language Language) => Language.GetStringAsync(typeof(GatewayConfigSource), 99, "Reverse Proxy");
 
        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));
 
            return Parameters;
        }
    }
}