更新OSS功能

Author: JusterZhu

src/c#/GeneralUpdate.Client/Program.cs

@@ -22,7 +22,7 @@ private static void Main(string[] args)
                 await DifferentialCore.Instance?.Dirty(source, patch);
             });*/
 
-            Task.Run(() =>
+            /*Task.Run(() =>
             {
                 //Console.WriteLine("主程序启动辣！！！！");
                 //await Task.Delay(3000);
@@ -66,7 +66,10 @@ private static void Main(string[] args)
                     .Option(UpdateOption.Encoding, Encoding.UTF8)
                     .Option(UpdateOption.Format, Format.ZIP)
                     .LaunchAsync();
-            });
+            });*/
+
+            GeneralClientOSS.Start(new ParamsOSS("http://192.168.50.203/versions.json", "GeneralUpdate.Client.exe","1.0.0.0", "versions.json"));
+            
             Console.Read();
         }
 

src/c#/GeneralUpdate.ClientCore/GeneralClientOSS.cs

@@ -5,6 +5,7 @@
 using System.IO;
 using System.Linq;
 using System.Net;
+using System.Runtime.CompilerServices;
 using System.Text.Json;
 using System.Threading;
 using System.Threading.Tasks;
@@ -17,15 +18,12 @@ namespace GeneralUpdate.ClientCore;
 
 public sealed class GeneralClientOSS
 {
-    private GeneralClientOSS()
-    {
-    }
+    private GeneralClientOSS() { }
 
     /// <summary>
-    ///     Starting an OSS update for windows,Linux,mac platform.
+    /// Starting an OSS update for windows platform.
     /// </summary>
-    /// <param name="configInfo"></param>
-    public static async Task Start(ParamsOSS configParams, string upgradeAppName = "GeneralUpdate.Upgrade")
+    public static async Task Start(ParamsOSS configParams, string upgradeAppName = "GeneralUpdate.Upgrade.exe")
     {
         await Task.Run(() =>
         {
@@ -34,24 +32,29 @@ await Task.Run(() =>
                 var basePath = Thread.GetDomain().BaseDirectory;
                 //Download the version information file from OSS to be updated.(JSON)
                 var versionsFilePath = Path.Combine(basePath, configParams.VersionFileName);
-                DownloadFile(configParams.Url + "/" + configParams.VersionFileName, versionsFilePath);
+                DownloadFile(configParams.Url, versionsFilePath);
                 if (!File.Exists(versionsFilePath)) return;
                 var versions = GeneralFileManager.GetJson<List<VersionPO>>(versionsFilePath);
                 if (versions == null || versions.Count == 0) return;
                 versions = versions.OrderByDescending(x => x.PubTime).ToList();
                 var newVersion = versions.First();
                 //Determine whether the current client version needs to be upgraded.
-                if (!IsUpgrade(configParams.CurrentVersion, newVersion.Version)) return;
-                var appPath = Path.Combine(basePath, $"{upgradeAppName}.exe");
-                if (!File.Exists(appPath)) throw new Exception($"The application does not exist {upgradeAppName} !");
-                //If you confirm that an update is required, start the upgrade application.
+                if (!IsUpgrade(configParams.CurrentVersion, newVersion.Version)) 
+                    return;
+                
                 var json = JsonSerializer.Serialize(configParams);
-                //TODO: set environment variable
-                Process.Start(appPath, json);
+                Environment.SetEnvironmentVariable("ParamsOSS", json, EnvironmentVariableTarget.User);
+                
+                //If you confirm that an update is required, start the upgrade application.
+                var appPath = Path.Combine(basePath, $"{upgradeAppName}");
+                if (!File.Exists(appPath)) 
+                    throw new Exception($"The application does not exist {upgradeAppName} !");
+                
+                Process.Start(appPath);
             }
             catch (Exception ex)
             {
-                throw new Exception($"GeneralClientOSS update exception ! {ex.Message}", ex.InnerException);
+                EventManager.Instance.Dispatch(new GeneralClientOSS(), new ExceptionEventArgs(ex));
             }
             finally
             {
@@ -61,18 +64,18 @@ await Task.Run(() =>
     }
 
     /// <summary>
-    ///     Determine whether the current client version needs to be upgraded.
+    /// Determine whether the current client version needs to be upgraded.
     /// </summary>
     /// <param name="clientVersion"></param>
     /// <param name="serverVersion"></param>
     /// <returns>true: Upgrade required , false: No upgrade is required</returns>
     private static bool IsUpgrade(string clientVersion, string serverVersion)
     {
-        if (string.IsNullOrWhiteSpace(clientVersion) || string.IsNullOrWhiteSpace(serverVersion)) return false;
-        Version currentClientVersion = null;
-        Version currentServerVersion = null;
-        var isParseClientVersion = Version.TryParse(clientVersion, out currentClientVersion);
-        var isParseServerVersion = Version.TryParse(serverVersion, out currentServerVersion);
+        if (string.IsNullOrWhiteSpace(clientVersion) || string.IsNullOrWhiteSpace(serverVersion)) 
+            return false;
+        
+        var isParseClientVersion = Version.TryParse(clientVersion, out var currentClientVersion);
+        var isParseServerVersion = Version.TryParse(serverVersion, out var currentServerVersion);
         if (!isParseClientVersion || !isParseServerVersion) return false;
         if (currentClientVersion < currentServerVersion) return true;
         return false;
@@ -89,7 +92,7 @@ public static void AddListenerException(Action<object, ExceptionEventArgs> callb
 
     private static void AddListener<TArgs>(Action<object, TArgs> callbackAction) where TArgs : EventArgs
     {
-        Contract.Requires(callbackAction != null);
+        Debug.Assert(callbackAction != null);
         EventManager.Instance.AddListener(callbackAction);
     }
 }

src/c#/GeneralUpdate.Common/Shared/Object/ParamsOSS.cs

@@ -1,17 +1,26 @@
 using System;
+using System.Text.Json.Serialization;
 
 namespace GeneralUpdate.Common.Shared.Object
 {
     public class ParamsOSS
     {
+        [JsonPropertyName("Url")]
         public string Url { get; set; }
 
+        [JsonPropertyName("AppName")]
         public string AppName { get; set; }
 
+        [JsonPropertyName("CurrentVersion")]
         public string CurrentVersion { get; set; }
 
+        [JsonPropertyName("VersionFileName")]
         public string VersionFileName { get; set; }
 
+        public ParamsOSS()
+        {
+        }
+
         public ParamsOSS(string url, string appName, string currentVersion, string versionFileName)
         {
             Url = url ?? throw new ArgumentNullException(nameof(url));

src/c#/GeneralUpdate.Common/Shared/Object/VersionPO.cs

@@ -1,4 +1,7 @@
-namespace GeneralUpdate.Common.Shared.Object
+using System;
+using System.Text.Json.Serialization;
+
+namespace GeneralUpdate.Common.Shared.Object
 {
     /// <summary>
     /// Version data persistence.
@@ -8,26 +11,32 @@ public class VersionPO
         /// <summary>
         /// Update package release time.
         /// </summary>
-        public long PubTime { get; set; }
+        
+        [JsonPropertyName("PubTime")]
+        public DateTime PubTime { get; set; }
 
         /// <summary>
         /// Update package name.
         /// </summary>
-        public string Name { get; set; }
+        [JsonPropertyName("PacketName")]
+        public string PacketName { get; set; }
 
         /// <summary>
         /// Compare and verify with the downloaded update package.
         /// </summary>
+        [JsonPropertyName("Hash")]
         public string Hash { get; set; }
 
         /// <summary>
         /// The version number.
         /// </summary>
+        [JsonPropertyName("Version")]
         public string Version { get; set; }
 
         /// <summary>
         /// Remote service url address.
         /// </summary>
+        [JsonPropertyName("Url")]
         public string Url { get; set; }
     }
 }

src/c#/GeneralUpdate.Core/GeneralUpdateOSS.cs

@@ -1,8 +1,13 @@
 using System;
+using System.Collections.Generic;
+using System.Diagnostics;
 using System.Diagnostics.Contracts;
+using System.IO;
 using System.Runtime.InteropServices;
+using System.Text.Json;
 using System.Threading.Tasks;
 using GeneralUpdate.Common.Download;
+using GeneralUpdate.Common.FileBasic;
 using GeneralUpdate.Common.Internal;
 using GeneralUpdate.Common.Internal.Event;
 using GeneralUpdate.Common.Internal.Strategy;
@@ -14,25 +19,15 @@ namespace GeneralUpdate.Core
 {
     public sealed class GeneralUpdateOSS
     {
-        #region Constructors
-
-        private GeneralUpdateOSS()
-        { }
-
-        #endregion Constructors
+        private GeneralUpdateOSS() { }
 
         #region Public Methods
 
         /// <summary>
         /// Starting an OSS update for windows,Linux,mac platform.
         /// </summary>
-        /// <typeparam name="T"></typeparam>
-        /// <param name="parameter"></param>
         /// <returns></returns>
-        public static async Task Start(ParamsOSS parameter)
-        {
-            await BaseStart(parameter);
-        }
+        public static async Task Start()=> await BaseStart();
 
         public static void AddListenerMultiAllDownloadCompleted(Action<object, MultiAllDownloadCompletedEventArgs> callbackAction)
             => AddListener(callbackAction);
@@ -61,7 +56,7 @@ public static void AddListenerDownloadConfigProcess(Action<object, OSSDownloadAr
 
         private static void AddListener<TArgs>(Action<object, TArgs> callbackAction) where TArgs : EventArgs
         {
-            Contract.Requires(callbackAction != null);
+            Debug.Assert(callbackAction != null);
             EventManager.Instance.AddListener(callbackAction);
         }
 
@@ -71,27 +66,18 @@ private static void AddListener<TArgs>(Action<object, TArgs> callbackAction) whe
         /// <typeparam name="T">The class that needs to be injected with the corresponding platform update policy or inherits the abstract update policy.</typeparam>
         /// <param name="args">List of parameter.</param>
         /// <returns></returns>
-        private static async Task BaseStart(ParamsOSS parameter)
+        private static async Task BaseStart()
         {
-            var strategy = StrategyFactory();
-            //strategy.Create(parameter);
-            //Implement different update strategies depending on the platform.
+            var json = Environment.GetEnvironmentVariable("ParamsOSS", EnvironmentVariableTarget.User);
+            if (string.IsNullOrWhiteSpace(json))
+                return;
+
+            var parameter = JsonSerializer.Deserialize<ParamsOSS>(json);
+            var strategy = new OSSStrategy();
+            strategy.Create(parameter);
             await strategy.ExecuteAsync();
         }
 
-        private static IStrategy StrategyFactory()
-        {
-            IStrategy strategy = null;
-            if (RuntimeInformation.IsOSPlatform(OSPlatform.Windows))
-                strategy = new WindowsStrategy();
-            else if (RuntimeInformation.IsOSPlatform(OSPlatform.Linux))
-                strategy = new LinuxStrategy();
-            else
-                throw new PlatformNotSupportedException("The current operating system is not supported!");
-
-            return strategy;
-        }
-
         #endregion Private Methods
     }
 }