LegalIdentityGetter.cs

using System;
using System.Collections.Generic;
using System.Collections.Specialized;
using System.Runtime.ExceptionServices;
using System.Security.Cryptography.X509Certificates;
using System.Text;
using System.Threading.Tasks;
using System.Web;
using Waher.Content;
using Waher.IoTGateway;
using Waher.Networking.XMPP.Contracts;
using Waher.Networking.XMPP.Contracts.EventArguments;
using Waher.Runtime.Inventory;
using Waher.Runtime.Temporary;
 
namespace Waher.Service.IoTBroker.Getters
{
    public class LegalIdentityGetter : IContentGetter, IDisposable
    {
        private static string defaultPurpose = string.Empty;
        private static int defaultTimeoutMilliseconds = 60000;
 
        private readonly Dictionary<string, TaskCompletionSource<LegalIdentityPetitionResponseEventArgs>> identityPetitions = new Dictionary<string, TaskCompletionSource<LegalIdentityPetitionResponseEventArgs>>();
        private readonly object syncObj = new object();
        private bool handlerAdded = false;
 
        public LegalIdentityGetter()
        {
        }
 
        public static string DefaultPurpose
        {
            get => defaultPurpose;
            set
            {
                if (string.IsNullOrEmpty(value))
                    throw new ArgumentException("Default purpose cannot be empty.", nameof(DefaultPurpose));
 
                defaultPurpose = value;
            }
        }
 
        public static int DefaultTimeoutMilliseconds
        {
            get => defaultTimeoutMilliseconds;
            set
            {
                if (value <= 0)
                    throw new ArgumentException("Default timeout must be positivt.", nameof(DefaultTimeoutMilliseconds));
 
                defaultTimeoutMilliseconds = value;
            }
        }
 
        public string[] UriSchemes => new string[] { "iotid" };
 
        public bool CanGet(Uri Uri, out Grade Grade)
        {
            if (string.Compare(Uri.Scheme, "iotid", true) == 0)
            {
                Grade = Grade.Ok;
                return true;
            }
            else
            {
                Grade = Grade.NotAtAll;
                return false;
            }
        }
 
        public void Dispose()
        {
            lock (this.syncObj)
            {
                if (this.handlerAdded)
                {
                    Gateway.ContractsClient.PetitionedIdentityResponseReceived -= this.Client_PetitionedIdentityResponseReceived;
                    this.handlerAdded = false;
                }
            }
        }
 
        public Task<object> GetAsync(Uri Uri, X509Certificate Certificate, RemoteCertificateEventHandler RemoteCertificateValidator, 
            params KeyValuePair<string, string>[] Headers)
        {
            return this.GetAsync(Uri, Certificate, RemoteCertificateValidator, defaultTimeoutMilliseconds, Headers);
        }
 
        public async Task<object> GetAsync(Uri Uri, X509Certificate Certificate, RemoteCertificateEventHandler RemoteCertificateValidator, 
            int TimeoutMs, params KeyValuePair<string, string>[] Headers)
        {
            ContractsClient Client = Gateway.ContractsClient
                ?? throw new NotSupportedException("Contracts feature not supported or activated on this system.");
 
            lock (this.syncObj)
            {
                if (!this.handlerAdded)
                {
                    Client.PetitionedIdentityResponseReceived += this.Client_PetitionedIdentityResponseReceived;
                    this.handlerAdded = true;
                }
            }
 
            string LegalId = Uri.AbsolutePath;
 
            try
            {
                return await Client.GetLegalIdentityAsync(LegalId);
            }
            catch (Exception)
            {
                TaskCompletionSource<LegalIdentityPetitionResponseEventArgs> Result = new TaskCompletionSource<LegalIdentityPetitionResponseEventArgs>();
                string PetitionId = Guid.NewGuid().ToString();
                string Purpose = null;
 
                if (!string.IsNullOrEmpty(Uri.Query))
                {
                    NameValueCollection Parameters = HttpUtility.ParseQueryString(Uri.Query);
 
                    foreach (string Parameter in Parameters.AllKeys)
                    {
                        switch (Parameter.ToLower())
                        {
                            case "p":
                            case "purpose":
                                Purpose = Parameters[Parameter];
                                break;
                        }
                    }
                }
 
                if (string.IsNullOrEmpty(Purpose))
                    Purpose = "Processing referenced identity.";
 
                lock (this.syncObj)
                {
                    this.identityPetitions[PetitionId] = Result;
                }
 
                try
                {
                    await Client.PetitionIdentityAsync(LegalId, PetitionId, Purpose);
 
                    Task _ = Task.Delay(TimeoutMs).ContinueWith((T) =>
                    {
                        Result.TrySetException(new TimeoutException("Response to petition not received within allotted time."));
                        return Task.CompletedTask;
                    });
                }
                catch (Exception ex)
                {
                    lock (this.syncObj)
                    {
                        this.identityPetitions.Remove(PetitionId);
                    }
 
                    ExceptionDispatchInfo.Capture(ex).Throw();
                }
 
                LegalIdentityPetitionResponseEventArgs e = await Result.Task;
 
                return e.RequestedIdentity;
            }
        }
 
        private Task Client_PetitionedIdentityResponseReceived(object Sender, LegalIdentityPetitionResponseEventArgs e)
        {
            lock (this.syncObj)
            {
                if (this.identityPetitions.TryGetValue(e.PetitionId, out TaskCompletionSource<LegalIdentityPetitionResponseEventArgs> Result))
                    Result.TrySetResult(e);
            }
 
            return Task.CompletedTask;
        }
 
        public Task<KeyValuePair<string, TemporaryStream>> GetTempStreamAsync(Uri Uri, X509Certificate Certificate,
            RemoteCertificateEventHandler RemoteCertificateValidator, params KeyValuePair<string, string>[] Headers)
        {
            return this.GetTempStreamAsync(Uri, Certificate, RemoteCertificateValidator, defaultTimeoutMilliseconds, Headers);
        }
 
        public async Task<KeyValuePair<string, TemporaryStream>> GetTempStreamAsync(Uri Uri, X509Certificate Certificate,
            RemoteCertificateEventHandler RemoteCertificateValidator, int TimeoutMs, params KeyValuePair<string, string>[] Headers)
        {
            LegalIdentity Identity = (LegalIdentity)await this.GetAsync(Uri, Certificate, RemoteCertificateValidator, TimeoutMs, Headers);
            StringBuilder Xml = new StringBuilder();
            Identity.Serialize(Xml, true, true, true, true, true, true, true);
            byte[] Bin = Encoding.UTF8.GetBytes(Xml.ToString());
 
            TemporaryStream Result = new TemporaryStream();
            try
            {
                await Result.WriteAsync(Bin, 0, Bin.Length);
            }
            catch (Exception ex)
            {
                Result.Dispose();
                ExceptionDispatchInfo.Capture(ex).Throw();
                Result = null;
            }
 
            return new KeyValuePair<string, TemporaryStream>("application/xml; charset=utf-8", Result);
        }
    }
}