InternetGatewayConfiguration.cs

using System;
using System.Collections.Generic;
using System.Threading.Tasks;
using Waher.Content;
using Waher.Events;
using Waher.IoTGateway;
using Waher.IoTGateway.Setup;
using Waher.Networking.HTTP;
using Waher.Networking.PeerToPeer;
using Waher.Persistence;
using Waher.Persistence.Attributes;
using Waher.Runtime.Language;
 
namespace Waher.Service.IoTBroker.Setup
{
    public class InternetGatewayConfiguration : SystemConfiguration, IDisposableAsync
    {
        private static InternetGatewayConfiguration instance = null;
 
        private HttpResource setRegistration = null;
        private InternetGatewayRegistrator registrator = null;
 
        private bool registerInGateway = false;
 
        public static InternetGatewayConfiguration Instance => instance;
 
        public override string Resource => "/Settings/InternetGateway.md";
 
        public override int Priority => 190;
 
        [DefaultValue(false)]
        public bool RegisterInGateway
        {
            get => this.registerInGateway;
            set => this.registerInGateway = value;
        }
 
        public override Task<string> Title(Language Language)
        {
            return Language.GetStringAsync(typeof(XmppServerModule), 30, "Internet Gateway Registration");
        }
 
        public override async Task ConfigureSystem()
        {
            if (this.registerInGateway && (this.registrator is null))
            {
                List<InternetGatewayRegistration> Ports = new List<InternetGatewayRegistration>();
 
                foreach (string Protocol in Gateway.GetProtocols())
                {
                    foreach (int Port in Gateway.GetConfigPorts(Protocol))
                    {
                        if (Port >= 0 && Port <= ushort.MaxValue)
                        {
                            Ports.Add(new InternetGatewayRegistration()
                            {
                                ApplicationName = "TAG Neuron " + Protocol + "-" + Port.ToString(),
                                ExternalPort = (ushort)Port,
                                LocalPort = (ushort)Port,
                                Tcp = true,
                                Udp = false
                            });
                        }
                    }
                }
 
                if (Ports.Count > 0)
                {
                    //ISniffer Sniffer = new XmlFileSniffer(Gateway.AppDataFolder + "UPnP" + Path.DirectorySeparatorChar +
                    //  "XMPP Log %YEAR%-%MONTH%-%DAY%T%HOUR%.xml",
                    //  Gateway.AppDataFolder + "Transforms" + Path.DirectorySeparatorChar + "SnifferXmlToHtml.xslt",
                    //  7, BinaryPresentationMethod.ByteCount);
 
                    this.registrator = new InternetGatewayRegistrator(Ports.ToArray()); //, Sniffer);
                    await this.registrator.Start();
                }
            }
        }
 
        public override void SetStaticInstance(ISystemConfiguration Configuration)
        {
            instance = Configuration as InternetGatewayConfiguration;
        }
 
        public override Task InitSetup(HttpServer WebServer)
        {
            this.setRegistration = WebServer.Register("/Settings/SetRegistration", null, this.SetRegistration, true, false, true);
 
            return base.InitSetup(WebServer);
        }
 
        protected override string ConfigPrivilege => "Admin.Communication.InternetGateway";
 
        private async Task SetRegistration(HttpRequest Request, HttpResponse Response)
        {
            Gateway.AssertUserAuthenticated(Request, this.ConfigPrivilege);
 
            if (!Request.HasData)
            {
                await Response.SendResponse(new BadRequestException());
                return;
            }
 
            ContentResponse Content = await Request.DecodeDataAsync();
            if (Content.HasError || !(Content.Decoded is Dictionary<string, object> Parameters))
            {
                await Response.SendResponse(new BadRequestException());
                return;
            }
 
            if (!Parameters.TryGetValue("clicked", out object Obj) || !(Obj is bool Clicked))
            {
                await Response.SendResponse(new BadRequestException());
                return;
            }
 
            this.registerInGateway = Clicked;
 
            Response.StatusCode = 200;
            Response.StatusMessage = "OK";
 
            await Database.Update(this);
        }
 
        public override Task UnregisterSetup(HttpServer WebServer)
        {
            WebServer.Unregister(this.setRegistration);
 
            return base.UnregisterSetup(WebServer);
        }
 
        public override Task<bool> SimplifiedConfiguration()
        {
            this.registerInGateway = false;
            return Task.FromResult(true);
        }
 
        [Obsolete("Use DisposeAsync() instead.")]
        public void Dispose()
        {
            try
            {
                this.DisposeAsync().Wait();
            }
            catch (Exception ex)
            {
                Log.Exception(ex);
            }
        }
 
        public async Task DisposeAsync()
        {
            if (!(this.registrator is null))
            {
                await this.registrator.DisposeAsync();
                this.registrator = null;
            }
        }
 
        public const string BROKER_INET_GATEWAY_REG = nameof(BROKER_INET_GATEWAY_REG);
 
        public override Task<bool> EnvironmentConfiguration()
        {
            if(!this.TryGetEnvironmentVariable(BROKER_INET_GATEWAY_REG, false, out this.registerInGateway))
                return Task.FromResult(false);
 
            return Task.FromResult(true);
        }
 
    }
}