RelayToSecondary.cs

using System.Text;
using System.Threading.Tasks;
using Waher.Content.Xml;
using Waher.IoTGateway;
using Waher.Networking.XMPP.Server;
using Waher.Persistence;
using Waher.Service.IoTBroker.EDaler.Uris;
 
namespace Waher.Service.IoTBroker.EDaler.Transactions
{
    public class RelayToSecondary : EDalerTransaction
    {
        private readonly CaseInsensitiveString domain;
        private CaseInsensitiveString componentAddress;
 
        public RelayToSecondary(EDalerUri Uri, CaseInsensitiveString Domain)
            : base(Uri)
        {
            this.domain = Domain;
        }
 
        public CaseInsensitiveString Domain => this.domain;
 
        protected override async Task<bool> DoPrepare()
        {
            if (Gateway.HasDomain &&
                !await this.Uri.EDaler.Legal.InSameTreeOfTrust(this.Uri.SecondaryDomain.Value))
            {
                this.Uri.State.Error(Uris.States.EDalerUriErrorType.Forbidden, 
                    "Secondary domain (" + this.Uri.SecondaryDomain.Value + 
                    ") not in same tree of trust.", false);
                return false;
            }
 
            this.componentAddress = await this.Uri.EDaler.Server.FindComponentAsync(this.domain, EDalerComponent.NamespaceEDaler);
 
            StringBuilder Xml = new StringBuilder();
            TaskCompletionSource<bool> Result = new TaskCompletionSource<bool>();
 
            Xml.Append("<uri xmlns=\"");
            Xml.Append(EDalerComponent.NamespaceEDaler);
 
            if (this.Uri.ToType == EntityType.NetworkJid)
            {
                Xml.Append("\" for=\"");
                Xml.Append(XML.Encode(this.Uri.To.Address));
            }
            else if (!this.Uri.State.Relayed)
            {
                Xml.Append("\" for=\"");
                Xml.Append(XML.Encode(this.Uri.State.Sender));
            }
 
            Xml.Append("\">");
            Xml.Append(XML.Encode(this.Uri.UriString));
            Xml.Append("</uri>");
 
            if (!await this.Uri.EDaler.Server.SendIqRequest("set",
                new XmppAddress(this.Uri.EDaler.Server.Domain),
                new XmppAddress(this.componentAddress),
                string.Empty, Xml.ToString(), false, (sender2, e2) =>
                {
                    if (!e2.Ok)
                        this.Uri.State.Error(e2.ErrorType.ToString().ToLower(), string.Empty, this.Uri.PrincipalDomain + " reports: " + e2.ErrorText);
 
                    Result.TrySetResult(e2.Ok);
 
                    return Task.CompletedTask;
 
                }, null))
            {
                this.Uri.State.Error(Uris.States.EDalerUriErrorType.ServiceUnavailable, "Unable to relay URI to secondary domain.", false);
                return false;
            }
 
            return await Result.Task;
        }
 
        protected override Task<bool> DoExecute()
        {
            return this.DoCommand("execute");
        }
 
        private async Task<bool> DoCommand(string Command)
        {
            StringBuilder Xml = new StringBuilder();
            TaskCompletionSource<string> Result = new TaskCompletionSource<string>();
 
            Xml.Append('<');
            Xml.Append(Command);
            Xml.Append(" xmlns=\"");
            Xml.Append(EDalerComponent.NamespaceEDaler);
            Xml.Append("\" id=\"");
            Xml.Append(this.Uri.Id.ToString());
            Xml.Append("\"/>");
 
            if (!await this.Uri.EDaler.Server.SendIqRequest("set",
                new XmppAddress(this.Uri.EDaler.Server.Domain),
                new XmppAddress(this.componentAddress),
                string.Empty, Xml.ToString(), false, (sender2, e2) =>
                {
                    if (e2.Ok)
                        Result.TrySetResult(null);
                    else
                        Result.TrySetResult(string.IsNullOrEmpty(e2.ErrorText) ? "Unable to process request." : e2.ErrorText);
 
                    return Task.CompletedTask;
 
                }, null))
            {
                return false;
            }
 
            string Msg = await Result.Task;
            if (string.IsNullOrEmpty(Msg))
                return true;
 
            this.Uri.State.Error(Uris.States.EDalerUriErrorType.ServiceUnavailable, "Secondary domain rejected the request: " + Msg, false);
            return false;
        }
 
        protected override Task<bool> DoCommit()
        {
            return this.DoCommand("commit");
        }
 
        protected override Task<bool> DoRollback()
        {
            return this.DoCommand("rollback");
        }
    }
}