HttpxPutter.cs

using System;
using System.Collections.Generic;
using System.IO;
using System.Security.Cryptography.X509Certificates;
using System.Threading;
using System.Threading.Tasks;
using Waher.Content;
using Waher.Content.Putters;
using Waher.Networking.HTTP;
using Waher.Runtime.Inventory;
 
namespace Waher.Networking.XMPP.HTTPX
{
    public class HttpxPutter : PutterBase
    {
        public HttpxPutter()
        {
        }
 
        public override string[] UriSchemes => new string[] { HttpxGetter.HttpxUriScheme };
 
        public override bool CanPut(Uri Uri, out Grade Grade)
        {
            switch (Uri.Scheme)
            {
                case HttpxGetter.HttpxUriScheme:
                    Grade = Grade.Ok;
                    return true;
 
                default:
                    Grade = Grade.NotAtAll;
                    return false;
            }
        }
 
        public override async Task<KeyValuePair<byte[], string>> PutAsync(Uri Uri, byte[] EncodedData, string ContentType, 
            X509Certificate Certificate, RemoteCertificateEventHandler RemoteCertificateValidator, int TimeoutMs, 
            params KeyValuePair<string, string>[] Headers)
        {
            HttpxClient HttpxClient;
            string BareJid;
            string FullJid;
            string LocalUrl;
 
            if (Types.TryGetModuleParameter("HTTPX", out object Obj) && Obj is HttpxProxy Proxy)
            {
                if (Proxy.DefaultXmppClient.Disposed || Proxy.ServerlessMessaging.Disposed)
                    throw new InvalidOperationException("Service is being shut down.");
 
                GetClientResponse Rec = await Proxy.GetClientAsync(Uri);
 
                BareJid = Rec.BareJid;
                FullJid = Rec.FullJid;
                HttpxClient = Rec.HttpxClient;
                LocalUrl = Rec.LocalUrl;
            }
            else if (Types.TryGetModuleParameter("XMPP", out Obj) && Obj is XmppClient XmppClient)
            {
                if (XmppClient.Disposed)
                    throw new InvalidOperationException("Service is being shut down.");
 
                if (!XmppClient.TryGetExtension(out HttpxClient HttpxClient2))
                    throw new InvalidOperationException("No HTTPX Extesion has been registered on the XMPP Client.");
 
                HttpxClient = HttpxClient2;
 
                if (string.IsNullOrEmpty(Uri.UserInfo))
                    FullJid = BareJid = Uri.Authority;
                else
                {
                    BareJid = Uri.UserInfo + "@" + Uri.Authority;
 
                    RosterItem Item = XmppClient.GetRosterItem(BareJid);
 
                    if (Item is null)
                        throw new ConflictException("No approved presence subscription with " + BareJid + ".");
                    else if (!Item.HasLastPresence || !Item.LastPresence.IsOnline)
                        throw new ServiceUnavailableException(BareJid + " is not online.");
                    else
                        FullJid = Item.LastPresenceFullJid;
                }
 
                LocalUrl = Uri.PathAndQuery + Uri.Fragment;
            }
            else
                throw new InvalidOperationException("An HTTPX Proxy or XMPP Client Module Parameter has not been registered.");
 
            List<HttpField> Headers2 = new List<HttpField>();
            bool HasContentType = false;
            bool HasHost = false;
 
            foreach (KeyValuePair<string, string> Header in Headers)
            {
                switch (Header.Key.ToLower())
                {
                    case "host":
                        Headers2.Add(new HttpField("Host", BareJid));
                        HasHost = true;
                        break;
 
                    case "cookie":
                    case "set-cookie":
                        // Do not forward cookies.
                        break;
 
                    case "content-type":
                        Headers2.Add(new HttpField(Header.Key, Header.Value));
                        HasContentType = true;
                        break;
 
                    default:
                        Headers2.Add(new HttpField(Header.Key, Header.Value));
                        break;
                }
            }
 
            if (!HasContentType)
                Headers2.Add(new HttpField("Content-Type", ContentType));
 
            if (!HasHost)
                Headers2.Add(new HttpField("Host", Uri.Authority));
 
            MemoryStream Data = new MemoryStream(EncodedData);
            State State = null;
            Timer Timer = null;
 
            try
            {
                State = new State();
                Timer = new Timer((P) =>
                {
                    State.Done.TrySetResult(false);
                }, null, TimeoutMs, Timeout.Infinite);
 
                // TODO: Transport public part of Client certificate, if provided.
 
                await HttpxClient.Request(FullJid, "PUT", LocalUrl, 1.1, Headers2, Data, async (Sender, e) =>
                    {
                        if (e.Ok)
                        {
                            State.HttpResponse = e.HttpResponse;
                            State.StatusCode = e.StatusCode;
                            State.StatusMessage = e.StatusMessage;
 
                            if (e.HasData)
                            {
                                if (State.Data is null)
                                    State.Data = new MemoryStream();
 
                                if (!(e.Data is null))
                                {
                                    await State.Data.WriteAsync(e.Data, 0, e.Data.Length);
                                    State.Done.TrySetResult(true);
                                }
                            }
                            else
                                State.Done.TrySetResult(true);
                        }
                        else
                            State.Done.TrySetException(e.StanzaError ?? new Exception("Unable to get resource."));
 
                    }, async (Sender, e) =>
                    {
                        if (State.Data is null)
                            State.Data = new MemoryStream();
 
                        await State.Data.WriteAsync(e.Data, 0, e.Data.Length);
                        if (e.Last)
                            State.Done.TrySetResult(true);
 
                    }, State);
 
                if (!await State.Done.Task)
                    throw new TimeoutException("Request timed out.");
 
                Timer.Dispose();
                Timer = null;
 
                if (State.StatusCode >= 200 && State.StatusCode < 300)
                    return new KeyValuePair<byte[], string>(State.Data?.ToArray(), State.HttpResponse?.ContentType);
                else
                {
                    ContentType = string.Empty;
                    EncodedData = State.Data?.ToArray();
 
                    throw HttpxGetter.GetExceptionObject(State.StatusCode, State.StatusMessage,
                        State.HttpResponse, EncodedData, ContentType);
                }
            }
            finally
            {
                State.Data?.Dispose();
                State.Data = null;
 
                if (!(State.HttpResponse is null))
                {
                    await State.HttpResponse.DisposeAsync();
                    State.HttpResponse = null;
                }
 
                Timer?.Dispose();
                Timer = null;
 
                Data.Dispose();
            }
        }
 
        private class State
        {
            public HttpResponse HttpResponse = null;
            public MemoryStream Data = null;
            public TaskCompletionSource<bool> Done = new TaskCompletionSource<bool>();
            public string StatusMessage = string.Empty;
            public int StatusCode = 0;
        }
 
    }
}