WebServer.cs

using System.Collections.Generic;
using System.Threading.Tasks;
using Waher.Networking;
using Waher.Runtime.Language;
using Waher.Things;
using Waher.Things.Attributes;
using Waher.Things.DisplayableParameters;
 
namespace Waher.Service.IoTBroker.Sources.GatewayConfig
{
    public class WebServer : ConfigurationNode
    {
        internal const string Id = "WebServer";
 
        public WebServer(GatewayConfigSource Source)
            : base(Source, null)
        {
        }
 
        [Page(7, "Configuration")]
        [Header(14, "Client Certificates (mTLS):")]
        [ToolTip(15, "How to allow clients authenticate themselves using X.509 certificates.")]
        [Required]
        [Option(ClientCertificates.NotUsed, 16, "Client certificates are not used, and will not be requested.")]
        [Option(ClientCertificates.Optional, 17, "Client certificates are requested, but not required.")]
        [Option(ClientCertificates.Required, 18, "Client certificates are requested, and required.")]
        public ClientCertificates ClientCertificates { get; set; }
 
        [Page(7, "Configuration")]
        [Header(19, "Trust client certificates.")]
        [ToolTip(20, "If client certificates should be trusted, even if they don't validate.")]
        public bool TrustClientCertificates { get; set; }
 
        [Page(118, "HTTP/2")]
        [Header(119, "Enabled")]
        [ToolTip(120, "If HTTP/2 is enabled or not.")]
        public bool Http2Enabled { get; set; }
 
        [Page(118, "HTTP/2")]
        [Header(121, "Initial Stream Window Size:")]
        [ToolTip(122, "Initial Stream Window Size, in bytes.")]
        public int Http2InitialStreamWindowSize { get; set; }
 
        [Page(118, "HTTP/2")]
        [Header(137, "Initial Connection Window Size:")]
        [ToolTip(138, "Initial Connection Window Size, in bytes.")]
        public int Http2InitialConnectionWindowSize { get; set; }
 
        [Page(118, "HTTP/2")]
        [Header(123, "Maximum Frame Size:")]
        [ToolTip(124, "Maximum Frame Size, in bytes.")]
        public int Http2MaxFrameSize { get; set; }
 
        [Page(118, "HTTP/2")]
        [Header(125, "Maximum concurrent streams:")]
        [ToolTip(126, "Maximum number of concurrent streams.")]
        public int Http2MaxConcurrentStreams { get; set; }
 
        [Page(118, "HTTP/2")]
        [Header(127, "Dynamic Header Table Size:")]
        [ToolTip(128, "Dynamic Header Table Size, in bytes.")]
        public int Http2HeaderTableSize { get; set; }
 
        [Page(118, "HTTP/2")]
        [Header(129, "No RFC 7540 priorities.")]
        [ToolTip(130, "If stream priorities, as defined in HTTP/2 RFC 7540, should not be used, in favour of priorities, as defined in RFC 9218 (used in HTTP/3).")]
        public bool Http2NoRfc7540Priorities { get; set; }
 
        [Page(118, "HTTP/2")]
        [Header(131, "Connection profiling.")]
        [ToolTip(132, "Enables profiling of HTTP/2 performance over connections.")]
        public bool Http2Profiling { get; set; }
 
        [Page(118, "HTTP/2")]
        [Header(142, "Separate sniffers by remote endpoint.")]
        [ToolTip(143, "Separates sniffers into different subfolders, depending on the remote endpoint.")]
        public bool HttpSniffersPerEndpoint { get; set; }
 
        public override string NodeId => Id;
 
        public override Task<string> GetTypeNameAsync(Language Language) => Language.GetStringAsync(typeof(GatewayConfigSource), 64, "Web Server");
 
        public override Task<bool> AcceptsChildAsync(INode Child)
        {
            return Task.FromResult(
                Child is DefaultPage ||
                Child is FileFolder ||
                Child is VanityResource ||
                Child is ContentEncoding ||
                Child is Redirection ||
                Child is ProxyResource ||
                Child is ProxyDomain ||
                Child is MTlsPort ||
                Child is DefaultHttpResponseHeader);
        }
 
        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);
 
            Parameters.AddLast(new StringParameter("Protocol", await Namespace.GetStringAsync(108, "Certificates"), this.ClientCertificates.ToString()));
            Parameters.AddLast(new BooleanParameter("Trust", await Namespace.GetStringAsync(109, "Trust"), this.TrustClientCertificates));
 
            return Parameters;
        }
 
        public override Task<bool> CanDestroyAsync(RequestOrigin Caller)
        {
            return Task.FromResult(false);
        }
    }
}