SoftwareUpdateClient.cs

using System;
using System.Collections.Generic;
using System.IO;
using System.Text;
using System.Threading.Tasks;
using System.Xml;
using Waher.Content;
using Waher.Content.Getters;
using Waher.Content.Xml;
using Waher.Events;
using Waher.Networking.XMPP.Events;
using Waher.Runtime.Temporary;
 
namespace Waher.Networking.XMPP.Software
{
    public class SoftwareUpdateClient : XmppExtension
    {
        public const string Wildcard = "*";
 
        private readonly string componentAddress;
        private readonly string packageFolder;
        private readonly Random rnd = new Random();
 
        public const string NamespaceSoftwareUpdatesIeeeV1 = "urn:ieee:iot:swu:1.0";
 
        public const string NamespaceSoftwareUpdatesNeuroFoundationV1 = "urn:nf:iot:swu:1.0";
 
        public const string NamespaceSoftwareUpdatesCurrent = NamespaceSoftwareUpdatesNeuroFoundationV1;
 
        public static readonly string[] NamespacesSoftwareUpdates = new string[]
        {
            NamespaceSoftwareUpdatesIeeeV1,
            NamespaceSoftwareUpdatesNeuroFoundationV1
        };
 
        public SoftwareUpdateClient(XmppClient Client, string ComponentAddress, string PackageFolder)
            : base(Client)
        {
            this.componentAddress = ComponentAddress;
            this.packageFolder = PackageFolder;
 
            if (!Directory.Exists(PackageFolder))
                Directory.CreateDirectory(PackageFolder);
 
            #region Neuro-Foundation V1
 
            this.Client.RegisterMessageHandler("packageInfo", NamespaceSoftwareUpdatesNeuroFoundationV1, this.PackageNotificationHandler, true);
            this.Client.RegisterMessageHandler("packageDeleted", NamespaceSoftwareUpdatesNeuroFoundationV1, this.PackageDeletedNotificationHandler, false);
 
            #endregion
 
            #region IEEE V1
 
            this.Client.RegisterMessageHandler("packageInfo", NamespaceSoftwareUpdatesIeeeV1, this.PackageNotificationHandler, true);
            this.Client.RegisterMessageHandler("packageDeleted", NamespaceSoftwareUpdatesIeeeV1, this.PackageDeletedNotificationHandler, false);
 
            #endregion
        }
 
        public override void Dispose()
        {
            #region Neuro-Foundation V1
 
            this.Client.UnregisterMessageHandler("packageInfo", NamespaceSoftwareUpdatesNeuroFoundationV1, this.PackageNotificationHandler, true);
            this.Client.UnregisterMessageHandler("packageDeleted", NamespaceSoftwareUpdatesNeuroFoundationV1, this.PackageDeletedNotificationHandler, false);
 
            #endregion
 
            #region IEEE V1
 
            this.Client.UnregisterMessageHandler("packageInfo", NamespaceSoftwareUpdatesIeeeV1, this.PackageNotificationHandler, true);
            this.Client.UnregisterMessageHandler("packageDeleted", NamespaceSoftwareUpdatesIeeeV1, this.PackageDeletedNotificationHandler, false);
 
            #endregion
        
            base.Dispose();
        }
 
        public override string[] Extensions => new string[] { };
 
        public string ComponentAddress => this.componentAddress;
 
        public string PackageFolder => this.packageFolder;
 
        public Task GetPackageInformation(string FileName, EventHandlerAsync<PackageEventArgs> Callback, object State)
        {
            StringBuilder Xml = new StringBuilder();
 
            Xml.Append("<getPackageInfo xmlns='");
            Xml.Append(NamespaceSoftwareUpdatesCurrent);
            Xml.Append("' fileName='");
            Xml.Append(XML.Encode(FileName));
            Xml.Append("'/>");
 
            return this.client.SendIqGet(this.componentAddress, Xml.ToString(), async (Sender, e) =>
            {
                XmlElement E = e.FirstElement;
                Package PackageInfo = null;
 
                if (e.Ok && !(E is null) && E.LocalName == "packageInfo")
                    PackageInfo = Package.Parse(E);
                else
                    e.Ok = false;
 
                PackageEventArgs e2 = new PackageEventArgs(PackageInfo, e);
                await Callback.Raise(this, e2);
 
            }, State);
        }
 
        public async Task<Package> GetPackageInformationAsync(string FileName)
        {
            TaskCompletionSource<Package> Result = new TaskCompletionSource<Package>();
 
            await this.GetPackageInformation(FileName, (Sender, e) =>
            {
                if (e.Ok)
                    Result.TrySetResult(e.Package);
                else
                    Result.TrySetException(e.StanzaError ?? new Exception("Unable to get package information."));
 
                return Task.CompletedTask;
 
            }, null);
 
            return await Result.Task;
        }
 
        public Task GetPackagesInformation(EventHandlerAsync<PackagesEventArgs> Callback, object State)
        {
            StringBuilder Xml = new StringBuilder();
 
            Xml.Append("<getPackages xmlns='");
            Xml.Append(NamespaceSoftwareUpdatesCurrent);
            Xml.Append("'/>");
 
            return this.client.SendIqGet(this.componentAddress, Xml.ToString(), async (Sender, e) =>
            {
                XmlElement E = e.FirstElement;
                Package[] PackagesInfo = null;
 
                if (e.Ok && !(E is null) && E.LocalName == "packages")
                {
                    List<Package> Packages = new List<Package>();
 
                    foreach (XmlNode N in E.ChildNodes)
                    {
                        if (N is XmlElement E2 && E2.LocalName == "packageInfo")
                            Packages.Add(Package.Parse(E2));
                    }
 
                    PackagesInfo = Packages.ToArray();
                }
                else
                    e.Ok = false;
 
                PackagesEventArgs e2 = new PackagesEventArgs(PackagesInfo, e);
                await Callback.Raise(this, e2);
 
            }, State);
        }
 
        public async Task<Package[]> GetPackagesAsync()
        {
            TaskCompletionSource<Package[]> Result = new TaskCompletionSource<Package[]>();
 
            await this.GetPackagesInformation((Sender, e) =>
            {
                if (e.Ok)
                    Result.TrySetResult(e.Packages);
                else
                    Result.TrySetException(e.StanzaError ?? new Exception("Unable to get packages."));
 
                return Task.CompletedTask;
 
            }, null);
 
            return await Result.Task;
        }
 
        public Task Subscribe(string FileName, EventHandlerAsync<IqResultEventArgs> Callback, object State)
        {
            StringBuilder Xml = new StringBuilder();
 
            Xml.Append("<subscribe xmlns='");
            Xml.Append(NamespaceSoftwareUpdatesCurrent);
            Xml.Append("' fileName='");
            Xml.Append(XML.Encode(FileName));
            Xml.Append("'/>");
 
            return this.client.SendIqSet(this.componentAddress, Xml.ToString(), Callback, State);
        }
 
        public async Task SubscribeAsync(string FileName)
        {
            TaskCompletionSource<bool> Result = new TaskCompletionSource<bool>();
 
            await this.Subscribe(FileName, (Sender, e) =>
            {
                if (e.Ok)
                    Result.TrySetResult(true);
                else
                    Result.TrySetException(e.StanzaError ?? new Exception("Unable to subscribe to software updates for " + FileName + "."));
 
                return Task.CompletedTask;
 
            }, null);
 
            await Result.Task;
        }
 
        public Task Unsubscribe(string FileName, EventHandlerAsync<IqResultEventArgs> Callback, object State)
        {
            StringBuilder Xml = new StringBuilder();
 
            Xml.Append("<unsubscribe xmlns='");
            Xml.Append(NamespaceSoftwareUpdatesCurrent);
            Xml.Append("' fileName='");
            Xml.Append(XML.Encode(FileName));
            Xml.Append("'/>");
 
            return this.client.SendIqSet(this.componentAddress, Xml.ToString(), Callback, State);
        }
 
        public async Task UnsubscribeAsync(string FileName)
        {
            TaskCompletionSource<bool> Result = new TaskCompletionSource<bool>();
 
            await this.Unsubscribe(FileName, (Sender, e) =>
            {
                if (e.Ok)
                    Result.TrySetResult(true);
                else
                {
                    Result.TrySetException(e.StanzaError ?? new Exception("Unable to unsubscribe from software updates for " + FileName + "."));
                }
 
                return Task.CompletedTask;
 
            }, null);
 
            await Result.Task;
        }
 
        public Task GetSubscriptions(EventHandlerAsync<SubscriptionsEventArgs> Callback, object State)
        {
            StringBuilder Xml = new StringBuilder();
 
            Xml.Append("<getSubscriptions xmlns='");
            Xml.Append(NamespaceSoftwareUpdatesCurrent);
            Xml.Append("'/>");
 
            return this.client.SendIqGet(this.componentAddress, Xml.ToString(), async (Sender, e) =>
            {
                XmlElement E = e.FirstElement;
                string[] FileNames = null;
 
                if (e.Ok && !(E is null) && E.LocalName == "subscriptions")
                {
                    List<string> Subscriptions = new List<string>();
 
                    foreach (XmlNode N in E.ChildNodes)
                    {
                        if (N is XmlElement E2 && E2.LocalName == "subscription")
                            Subscriptions.Add(E2.InnerText);
                    }
 
                    FileNames = Subscriptions.ToArray();
                }
                else
                    e.Ok = false;
 
                SubscriptionsEventArgs e2 = new SubscriptionsEventArgs(FileNames, e);
                await Callback.Raise(this, e2);
            }, State);
        }
 
        public async Task<string[]> GetSubscriptionsAsync()
        {
            TaskCompletionSource<string[]> Result = new TaskCompletionSource<string[]>();
 
            await this.GetSubscriptions((Sender, e) =>
            {
                if (e.Ok)
                    Result.TrySetResult(e.FileNames);
                else
                    Result.TrySetException(e.StanzaError ?? new Exception("Unable to get list of current subscriptions."));
 
                return Task.CompletedTask;
 
            }, null);
 
            return await Result.Task;
        }
 
        private async Task PackageNotificationHandler(object Sender, MessageEventArgs e)
        {
            if (string.Compare(e.From, this.componentAddress, true) != 0)
            {
                this.client.Warning("Discarding package notification. Expected source: " + this.componentAddress + ". Actual source: " + e.From);
                return;
            }
 
            Package PackageInfo = Package.Parse(e.Content);
            PackageUpdatedEventArgs e2 = new PackageUpdatedEventArgs(PackageInfo, e);
 
            await this.OnSoftwareUpdated.Raise(this, e2, false);
 
            if (e2.Download)
            {
                Task _ = Task.Run(() => this.Download(PackageInfo, e));
            }
        }
 
        private async Task Download(Package PackageInfo, MessageEventArgs e)
        {
            try
            {
                string FileName = await this.DownloadPackageAsync(PackageInfo);
                PackageFileEventArgs e3 = new PackageFileEventArgs(PackageInfo, FileName, e);
 
                if (!await this.OnSoftwareValidation.Raise(this, e3, false))
                {
                    File.Delete(FileName);
                    Log.Warning("Package with invalid signature downloaded and deleted.", FileName);
                    return;
                }
 
                await this.OnSoftwareDownloaded.Raise(this, e3);
            }
            catch (Exception ex)
            {
                Log.Exception(ex, PackageInfo.FileName);
            }
        }
 
        public Task<string> DownloadPackageAsync(Package PackageInfo)
        {
            return this.DownloadPackageAsync(PackageInfo, null);
        }
 
        public Task<string> DownloadPackageAsync(Package PackageInfo, TemporaryStream Destination)
        {
            return this.DownloadPackageAsync(PackageInfo, Destination, GetDefaultRemoteCertificateValidator(PackageInfo));
        }
 
        private static EventHandler<RemoteCertificateEventArgs> GetDefaultRemoteCertificateValidator(Package PackageInfo)
        {
            if (PackageInfo.Url.StartsWith("https://localhost:") ||
                PackageInfo.Url.StartsWith("https://localhost/"))
            {
                return TrustLocalhost;
            }
            else
                return null;
        }
 
        private static void TrustLocalhost(object Sender, RemoteCertificateEventArgs e)
        {
            e.IsValid = true;
        }
 
        public async Task<string> DownloadPackageAsync(Package PackageInfo, TemporaryStream Destination,
            EventHandler<RemoteCertificateEventArgs> RemoteCertificateValidator)
        {
            string FileName = Path.Combine(this.packageFolder, PackageInfo.FileName);
            int MaxRetryDelayMinutes = 5;
 
            while (true)
            {
                string ErrorMessage;
                int StatusCode;
 
                try
                {
                    ContentStreamResponse Content = await InternetContent.GetTempStreamAsync(
                        new Uri(PackageInfo.Url), null, RemoteCertificateValidator, 120000, Destination);
 
                    if (Content.HasError)
                    {
                        if (Content.Error is WebException ex)
                            StatusCode = (int)ex.StatusCode;
                        else
                            StatusCode = (int)System.Net.HttpStatusCode.InternalServerError;
 
                        ErrorMessage = Content.Error.Message;
                    }
                    else
                    {
                        using Stream Output = File.Create(FileName);
 
                        Content.Encoded.Position = 0;
                        await Content.Encoded.CopyToAsync(Output);
 
                        return FileName;
                    }
                }
                catch (WebException ex)
                {
                    StatusCode = (int)ex.StatusCode;
                    ErrorMessage = ex.Message;
                }
                catch (Exception ex)
                {
                    StatusCode = (int)System.Net.HttpStatusCode.InternalServerError;
                    ErrorMessage = ex.Message;
                }
 
                if (StatusCode < 500)
                {
                    throw new GenericException("Unable to download new package from server.", 
                        null, PackageInfo.FileName, null, null, null, null, null,
                        new KeyValuePair<string, object>("Status Code", StatusCode),
                        new KeyValuePair<string, object>("Message", ErrorMessage));
                }
 
                int MsDelay;
 
                lock (this.rnd)
                {
                    MsDelay = this.rnd.Next(1000, MaxRetryDelayMinutes * 60000);
 
                    MaxRetryDelayMinutes <<= 1;
                    if (MaxRetryDelayMinutes > 1440)
                        MaxRetryDelayMinutes = 1440;    // Try at least once a day.
                }
 
                await Task.Delay(MsDelay);
            }
        }
 
        public event EventHandlerAsync<PackageUpdatedEventArgs> OnSoftwareUpdated = null;
 
        public event EventHandlerAsync<PackageFileEventArgs> OnSoftwareValidation = null;
 
        public event EventHandlerAsync<PackageFileEventArgs> OnSoftwareDownloaded = null;
 
        private async Task PackageDeletedNotificationHandler(object Sender, MessageEventArgs e)
        {
            if (string.Compare(e.From, this.componentAddress, true) != 0)
                return;
 
            Package PackageInfo = Package.Parse(e.Content);
            PackageDeletedEventArgs e2 = new PackageDeletedEventArgs(PackageInfo, e);
            await this.OnSoftwareDeleted.Raise(this, e2, false);
 
            if (e2.Delete)
            {
                try
                {
                    string FileName = Path.Combine(this.packageFolder, PackageInfo.FileName);
 
                    if (File.Exists(FileName))
                    {
                        File.Delete(FileName);
 
                        await this.OnDownloadedSoftwareDeleted.Raise(this, new PackageFileEventArgs(PackageInfo, FileName, e));
                    }
                }
                catch (Exception ex)
                {
                    Log.Exception(ex);
                }
            }
        }
 
        public event EventHandlerAsync<PackageDeletedEventArgs> OnSoftwareDeleted = null;
 
        public event EventHandlerAsync<PackageFileEventArgs> OnDownloadedSoftwareDeleted = null;
 
    }
}