XmppOverHttp.cs

using System;
using System.Collections.Generic;
using System.Runtime.ExceptionServices;
using System.Text;
using System.Threading.Tasks;
using Waher.Content;
using Waher.Events;
using Waher.IoTGateway;
using Waher.Networking.HTTP;
using Waher.Networking.XMPP.HTTPX;
using Waher.Runtime.Cache;
using Waher.Runtime.Temporary;
 
namespace Waher.Service.IoTBroker.WebServices
{
    public class XmppOverHttp : HttpAsynchronousResource, IHttpPostMethod, IPostResource
    {
        private Cache<string, KeyValuePair<EventHandlerAsync<PostBackEventArgs>, object>> queries = null;
        private readonly object synchObj = new object();
 
        public XmppOverHttp(string ResourceName)
            : base(ResourceName)
        {
        }
 
        public override bool HandlesSubPaths => true;
 
        public override bool UserSessions => false;
 
        public bool AllowsPOST => true;
 
        public Task<string> GetUrl(EventHandlerAsync<PostBackEventArgs> Callback, object State)
        {
            byte[] Bin = Gateway.NextBytes(32);
            string Key = Base64Url.Encode(Bin);
 
            lock (this.synchObj)
            {
                if (this.queries is null)
                {
                    this.queries = new Cache<string, KeyValuePair<EventHandlerAsync<PostBackEventArgs>, object>>(int.MaxValue, TimeSpan.FromMinutes(5), TimeSpan.FromMinutes(5), true);
                    this.queries.Removed += this.Queries_Removed;
                }
 
                this.queries[Key] = new KeyValuePair<EventHandlerAsync<PostBackEventArgs>, object>(Callback, State);
                this.queries[string.Empty] = new KeyValuePair<EventHandlerAsync<PostBackEventArgs>, object>(null, null);    // Keep cache active to avoid multiple recreation when a series of requests occur in sequence.
            }
 
            StringBuilder Url = new StringBuilder();
            int[] Ports = Gateway.HttpServer.OpenHttpsPorts;
 
            Url.Append("https://");
            Url.Append(Gateway.Domain);
 
            if (Array.IndexOf(Ports, HttpServer.DefaultHttpsPort) < 0 && Ports.Length > 0)
            {
                Url.Append(':');
                Url.Append(Ports[0]);
            }
 
            Url.Append(this.ResourceName);
            Url.Append("/");
            Url.Append(Key);
 
            return Task.FromResult(Url.ToString());
        }
 
        private Task Queries_Removed(object Sender, CacheItemEventArgs<string, KeyValuePair<EventHandlerAsync<PostBackEventArgs>, object>> e)
        {
            lock (this.synchObj)
            {
                if (!(this.queries is null) && this.queries.Count == 0)
                {
                    this.queries.Dispose();
                    this.queries = null;
                }
            }
 
            return Task.CompletedTask;
        }
 
        public async Task POST(HttpRequest Request, HttpResponse Response)
        {
            if (!Request.HasData)
                throw new BadRequestException("Missing data.");
 
            string ContentType = Request.Header.ContentType?.Value;
            if (string.IsNullOrEmpty(ContentType) || Array.IndexOf(Content.Binary.BinaryCodec.BinaryContentTypes, ContentType) < 0)
                throw new UnsupportedMediaTypeException("Expected Binary data.");
 
            string From = Request.Header.From?.Value;
            if (string.IsNullOrEmpty(From))
                throw new BadRequestException("No From header.");
 
            string To = Request.Header["Origin"];
            if (string.IsNullOrEmpty(To))
                throw new BadRequestException("No Origin header.");
 
            string Referer = Request.Header.Referer?.Value;
            string EndpointReference;
            string SymmetricCipherReference;
            int i;
 
            if (!string.IsNullOrEmpty(Referer) && (i = Referer.IndexOf(':')) >= 0)
            {
                EndpointReference = Referer.Substring(0, i);
                SymmetricCipherReference = Referer.Substring(i + 1);
            }
            else
            {
                EndpointReference = string.Empty;
                SymmetricCipherReference = string.Empty;
            }
 
            string Key = Request.SubPath;
            if (string.IsNullOrEmpty(Key))
                throw new BadRequestException("No sub-path provided.");
 
            Key = Key.Substring(1);
 
            KeyValuePair<EventHandlerAsync<PostBackEventArgs>, object> Rec;
 
            lock (this.synchObj)
            {
                if (this.queries is null || !this.queries.TryGetValue(Key, out Rec))
                    throw new NotFoundException("Resource sub-key not found.");
            }
 
            Request.DataStream.Position = 0;
 
            TemporaryStream Data = new TemporaryStream();
            try
            {
                await Request.DataStream.CopyToAsync(Data);
                Data.Position = 0;
                Task _ = Task.Run(() => this.Process(Data, Response, Rec.Key, Rec.Value, From, To, EndpointReference, SymmetricCipherReference));
            }
            catch (Exception ex)
            {
                Data.Dispose();
                ExceptionDispatchInfo.Capture(ex).Throw();
            }
        }
 
        private async Task Process(TemporaryStream Data, HttpResponse Response, EventHandlerAsync<PostBackEventArgs> Callback, object State,
            string From, string To, string EndpointReference, string SymmetricCipherReference)
        {
            try
            {
                // Permit callback to raise exceptions.
                await Callback(this, new PostBackEventArgs(Data, State, From, To, EndpointReference, SymmetricCipherReference));
 
                Response.StatusCode = 200;
                await Response.SendResponse();
            }
            catch (Exception ex)
            {
                await Response.SendResponse(ex);
            }
            finally
            {
                Data.Dispose();
                await Response.DisposeAsync();
            }
        }
 
    }
}