HttpProtocol.cs

using System;
using System.Collections;
using System.Collections.Generic;
using System.Text;
using System.Threading.Tasks;
using Waher.IoTGateway;
using Waher.Networking;
using Waher.Networking.HTTP;
using Waher.Networking.Sniffers;
using Waher.Runtime.Language;
using Waher.Service.IoTBroker.Sources.Protocols.Commands;
using Waher.Things;
using Waher.Things.DisplayableParameters;
 
namespace Waher.Service.IoTBroker.Sources.Protocols
{
    public class HttpProtocol : INode, ICommunicationLayer
    {
        private readonly HttpServer server;
 
        public HttpProtocol(HttpServer Server)
        {
            this.server = Server;
        }
 
        #region INode
 
        public string LocalId => this.NodeId;
        public string LogId => this.NodeId;
        public string NodeId => "HTTP";
        public string SourceId => "Protocols";
        public string Partition => string.Empty;
        public bool HasChildren => false;
        public bool ChildrenOrdered => false;
        public bool IsReadable => false;
        public bool IsControllable => false;
        public INode Parent => null;
        public DateTime LastChanged => DateTime.MinValue;
        public Task<IEnumerable<INode>> ChildNodes => null;
 
        public NodeState State => NodeState.None;   // TODO: Check HTTP Server state.
 
        public Task<bool> AcceptsChildAsync(INode Child)
        {
            return Task.FromResult(false);
        }
 
        public Task<bool> AcceptsParentAsync(INode Parent)
        {
            return Task.FromResult(false);
        }
 
        public Task AddAsync(INode Child)
        {
            throw new NotSupportedException();
        }
 
        public Task<bool> CanAddAsync(RequestOrigin Caller)
        {
            return Task.FromResult(false);
        }
 
        public Task<bool> CanDestroyAsync(RequestOrigin Caller)
        {
            return Task.FromResult(false);
        }
 
        public Task<bool> CanEditAsync(RequestOrigin Caller)
        {
            return XmppServerModule.IsAdmin(Caller.From);
        }
 
        public Task<bool> CanViewAsync(RequestOrigin Caller)
        {
            return XmppServerModule.IsAdmin(Caller.From);
        }
 
        public Task DestroyAsync()
        {
            throw new NotSupportedException();
        }
 
        public async Task<IEnumerable<Parameter>> GetDisplayableParametersAsync(Language Language, RequestOrigin Caller)
        {
            LinkedList<Parameter> Parameters = new LinkedList<Parameter>();
 
            Parameters.AddLast(new StringParameter("HttpPorts", await Language.GetStringAsync(typeof(XmppServerModule), 3, "HTTP Ports"), PortsToString(this.server.OpenHttpPorts)));
            Parameters.AddLast(new StringParameter("HttpsPorts", await Language.GetStringAsync(typeof(XmppServerModule), 4, "HTTPS Ports"), PortsToString(this.server.OpenHttpsPorts)));
 
            return Parameters;
        }
 
        internal static string PortsToString(int[] Ports)
        {
            StringBuilder sb = new StringBuilder();
            bool First = true;
 
            foreach (int Port in Ports)
            {
                if (First)
                    First = false;
                else
                    sb.Append(", ");
 
                sb.Append(Port.ToString());
            }
 
            return sb.ToString();
        }
 
        public Task<IEnumerable<Message>> GetMessagesAsync(RequestOrigin Caller)
        {
            return Task.FromResult<IEnumerable<Message>>(null);
        }
 
        public Task<string> GetTypeNameAsync(Language Language)
        {
            return Language.GetStringAsync(typeof(XmppServerModule), 28, "HTTP Protocol");
        }
 
        public Task<bool> MoveDownAsync(RequestOrigin Caller)
        {
            return Task.FromResult(false);
        }
 
        public Task<bool> MoveUpAsync(RequestOrigin Caller)
        {
            return Task.FromResult(false);
        }
 
        public Task UpdateAsync()
        {
            return Task.CompletedTask;
        }
 
        public Task<bool> RemoveAsync(INode Child)
        {
            return Task.FromResult(false);
        }
 
        public bool HasCommands => true;
 
        public Task<IEnumerable<ICommand>> Commands
        {
            get
            {
                return Task.FromResult<IEnumerable<ICommand>>(new ICommand[]
                {
                    new HttpStatistics()
                });
            }
        }
 
        #endregion
 
        #region ICommunicationLayer
 
        public bool DecoupledEvents => Gateway.HttpServer?.DecoupledEvents ?? false;
 
        public void Add(ISniffer Sniffer)
        {
            Gateway.HttpServer?.Add(Sniffer);
            Gateway.ScheduleEvent((_) => this.Remove(Sniffer), DateTime.Now.AddHours(1), null);
        }
 
        public void AddRange(IEnumerable<ISniffer> Sniffers)
        {
            Gateway.HttpServer?.AddRange(Sniffers);
            Gateway.ScheduleEvent((_) =>
            {
                foreach (ISniffer Sniffer in Sniffers)
                    this.Remove(Sniffer);
            }, DateTime.Now.AddHours(1), null);
        }
 
        public bool Remove(ISniffer Sniffer) => Gateway.HttpServer?.Remove(Sniffer) ?? false;
 
        public ISniffer[] Sniffers => Gateway.HttpServer?.Sniffers ?? new ISniffer[0];
 
        public bool HasSniffers => Gateway.HttpServer?.HasSniffers ?? false;
        
        public IEnumerator<ISniffer> GetEnumerator() => Gateway.HttpServer?.GetEnumerator() ?? ((IEnumerable<ISniffer>)(new ISniffer[0])).GetEnumerator();
 
        IEnumerator IEnumerable.GetEnumerator() => Gateway.HttpServer?.GetEnumerator() ?? (new ISniffer[0]).GetEnumerator();
 
        public Task ReceiveBinary(byte[] Data) => Gateway.HttpServer?.ReceiveBinary(Data) ?? Task.CompletedTask;
 
        public Task TransmitBinary(byte[] Data) => Gateway.HttpServer?.TransmitBinary(Data) ?? Task.CompletedTask;
 
        public Task ReceiveText(string Text) => Gateway.HttpServer?.ReceiveText(Text) ?? Task.CompletedTask;
 
        public Task TransmitText(string Text) => Gateway.HttpServer?.TransmitText(Text) ?? Task.CompletedTask;
 
        public Task Information(string Comment) => Gateway.HttpServer?.Information(Comment) ?? Task.CompletedTask;
 
        public Task Warning(string Warning) => Gateway.HttpServer?.Warning(Warning) ?? Task.CompletedTask;
 
        public Task Error(string Error) => Gateway.HttpServer?.Error(Error) ?? Task.CompletedTask;
 
        public Task Exception(Exception Exception) => Gateway.HttpServer?.Exception(Exception) ?? Task.CompletedTask;
 
        public Task Exception(string Exception) => Gateway.HttpServer?.Exception(Exception) ?? Task.CompletedTask;
 
        public Task ReceiveBinary(DateTime Timestamp, byte[] Data) => Gateway.HttpServer?.ReceiveBinary(Timestamp, Data) ?? Task.CompletedTask;
 
        public Task TransmitBinary(DateTime Timestamp, byte[] Data) => Gateway.HttpServer?.TransmitBinary(Timestamp, Data) ?? Task.CompletedTask;
 
        public Task ReceiveText(DateTime Timestamp, string Text) => Gateway.HttpServer?.ReceiveText(Timestamp, Text) ?? Task.CompletedTask;
 
        public Task TransmitText(DateTime Timestamp, string Text) => Gateway.HttpServer?.TransmitText(Timestamp, Text) ?? Task.CompletedTask;
 
        public Task Information(DateTime Timestamp, string Comment) => Gateway.HttpServer?.Information(Timestamp, Comment) ?? Task.CompletedTask;
 
        public Task Warning(DateTime Timestamp, string Warning) => Gateway.HttpServer?.Warning(Timestamp, Warning) ?? Task.CompletedTask;
 
        public Task Error(DateTime Timestamp, string Error) => Gateway.HttpServer?.Error(Timestamp, Error) ?? Task.CompletedTask;
 
        public Task Exception(DateTime Timestamp, string Exception) => Gateway.HttpServer?.Exception(Timestamp, Exception) ?? Task.CompletedTask;
 
        public Task Exception(DateTime Timestamp, Exception Exception) => Gateway.HttpServer?.Exception(Timestamp, Exception) ?? Task.CompletedTask;
 
        #endregion
    }
}