DC_Initlizer/AwInitilizer/Procedure/FirmwareUpdateProcedure.cs

using AwInitilizer.Assist;
using AwInitilizer.Model;
using InitializerModel;
using Newtonsoft.Json;
using System;
using System.Collections.Generic;
using System.Collections.Specialized;
using System.ComponentModel;
using System.Globalization;
using System.IO;
using System.Linq;
using System.Net;
using System.Text;
using System.Threading.Tasks;
using System.Web;
using System.Windows.Ink;

namespace AwInitilizer.Procedure
{
    public class FirmwareUpdateProcedure : ProcedureBase
    {
        internal string Version;
        internal string fileName;
        internal string module;
        //internal int SleepMinuts = 6;

        private FirmwareUpdateModel _model;

        public FirmwareUpdateProcedure(FirmwareUpdateModel model) :base()
        {
            _model = model;

            Name = string.Format("Firmware {0}", model.Module);
            Content = string.Format("Update {0} Firemware and check version matched", model.Module);

            Version = model.Version;
            fileName = model.FirmwareFileName;
            module = model.Module;
        }

        internal override async Task<bool> Run()
        {
            var oldVersion = await GetSpecificVersion();
            MesLogData.Add($"{module}OldVersion", oldVersion, true);
            if (string.IsNullOrEmpty(oldVersion))
            {
                InfoLog += $"Get {Name} version failed\n";
                Logger.Print($"Get {Name} version failed",isError:true);
                return false;
            }
            InfoLog += $"version before update : {oldVersion}\n";
            if (oldVersion == Version)
            {
                Logger.Print("Updated version detected");
            }
            Logger.Print("Firmware Uploading...");
            var uploadResult = await Uploadfiremware(fileName);
            MesLogData.Add($"{module}Upload", uploadResult.ToString(), true);
            if (uploadResult)
            {
                //wait restart
                Logger.Print("Waiting restart..");

                bool response = false;
                int pollinfCnt = 0;
                await Task.Delay(TimeSpan.FromMinutes(2));
                for (pollinfCnt = 0; pollinfCnt < 28; pollinfCnt++)
                {
                    await Task.Delay(TimeSpan.FromSeconds(15));
                    response = await ChekCsuBootCompelete();
                    if (response)
                        break;
                }

                //timeout
                if(pollinfCnt>=28)
                {
                    Logger.Print("Wait restart timeout",isError:true);
                    return false;
                }
            }
            else
            {
                InfoLog += $"Upload {Name} failed\n";
                Logger.Print($"Upload {Name} failed", isError: true);
                return false;
            }
            var updatedVersion = await GetSpecificVersion();
            //MesLogData.Add($"{module}NewVersion", updatedVersion);
            if (string.IsNullOrEmpty(updatedVersion))
            {
                InfoLog += $"Get updated {Name} version failed\n";
                Logger.Print($"Get updated {Name} version failed", isError: true);
                MesLogData.Add($"{module}NewVersion", "empty" , false);
                return false;
            }
            InfoLog += $"Get updated version : {updatedVersion}\n";
            bool isVersionMatched = false;
            if(module== "CsuRootFsFwRev")
            {
                isVersionMatched = updatedVersion.StartsWith(Version);
            }
            else
            {
                isVersionMatched = updatedVersion == Version;
            }
            if (isVersionMatched)
            {
                InfoLog += $"{Name}:Updated Version mismatched\n";
                Logger.Print($"{Name}:Updated Version mismatched", isError: true);
                MesLogData.Add($"{module}NewVersion", updatedVersion, false);
                return false;
            }
            else
            {
                MesLogData.Add($"{module}NewVersion", updatedVersion, true);
                Logger.Print($"{Name}:updated success");
            }

            return true;
        }

        internal virtual async Task<string> GetSpecificVersion()
        {
            var versions = await GetVersion();
            if(versions == null ||
                !versions.ContainsKey(module))
            {
                return "";
            }
            return versions[module];
        }

        internal async Task<Dictionary<string,string>> GetVersion(bool isConnectTest = false)
        {
            try
            {
                var result = await EvApi.GetVersion();
                InfoLog += $"get version response:{result.Response}\n";
                return result.Result;
            }
            catch(Exception e)
            {
                if (!isConnectTest)
                {
                    Logger.Print("Get Version Failed", isError: true);
                    Logger.Print(e.Message + "", isError: true);

                    InfoLog += "Get Version Failed\n";
                    InfoLog += e.Message;
                    InfoLog += "\n";
                }

                return null;
            }
        }

        internal async Task<bool> Uploadfiremware(string fileName)
        {
            try
            {
                var result = await EvApi.Uploadfirmware(fileName);
                InfoLog += $"get firmware update response {result.Response}\n";
                if (result.Response != null && result.Response.Contains("file is uploaded"))
                    return true;
                return false;

                //using (var stream = File.Open(fileName, FileMode.Open))
                //{
                //    UploadFileAsync(
                //    new NameValueCollection()
                //    {
                //        {"fw_tag","iso" }
                //    },
                //    new UploadFile()
                //    {
                //        Name = "file",
                //        Filename = Path.GetFileName(fileName),
                //        Stream = stream
                //    }
                //    );
                //}

                //return true;
                //using (var stream = File.Open(fileName, FileMode.Open))
                //{
                //    var response = await UploadFiles(
                //    $"https://{ServerIpAddress}/upgrade_iso_action.php",
                //    new List<UploadFile>() {
                //        new UploadFile()
                //        {
                //            Name="file",
                //            Filename= Path.GetFileName(fileName),
                //            Stream = stream
                //        }
                //    },
                //    new NameValueCollection() {
                //        {"fw_tag","iso" }
                //    }
                //    );

                //    var responseStr = Encoding.ASCII.GetString(response).ToLower();
                //    InfoLog += $"get firmware update response {responseStr}\n";
                //    if (responseStr.Contains("file is uploaded"))
                //        return true;
                //    return false;
                //}
                //return true;
                //using (WebClient webClient = new WebClient())
                //{
                //    NameValueCollection parameters = new NameValueCollection();
                //    parameters.Add("fw_tag", "iso");
                //    webClient.QueryString = parameters;

                //    var responseBytes = await webClient.UploadFileTaskAsync($"https://{ServerIpAddress}/upgrade_iso_action.php", fileName);
                //    string responseString = Encoding.ASCII.GetString(responseBytes);
                //    return true;
                //}
            }
            catch(Exception e)
            {
                Logger.Print("Upload Firmware Failed", isError: true);
                Logger.Print(e.Message + "", isError: true);

                InfoLog += "Upload Firmware Failed\n";
                InfoLog += e.Message;
                InfoLog += "\n";

                return false;
            }
        }

        public async Task<byte[]> UploadFiles(string address, IEnumerable<UploadFile> files, NameValueCollection values)
        {
            var request = (HttpWebRequest) HttpWebRequest.Create(address);
            //request.Timeout = 10 * 1000;
            request.KeepAlive = true;
            request.Accept = "*/*";
            request.Method = "POST";
            request.Referer = address;
            request.Expect = "";
            var boundary = "---------------------------" + DateTime.Now.Ticks.ToString("x", NumberFormatInfo.InvariantInfo);
            request.ContentType = "multipart/form-data; boundary=" + boundary;
            boundary = "--" + boundary;

            using (var requestStream = request.GetRequestStream())
            {
                // Write the values
                foreach (string name in values.Keys)
                {
                    var buffer = Encoding.ASCII.GetBytes(boundary + Environment.NewLine);
                    requestStream.Write(buffer, 0, buffer.Length);
                    buffer = Encoding.ASCII.GetBytes(string.Format("Content-Disposition: form-data; name=\"{0}\"{1}{1}", name, Environment.NewLine));
                    requestStream.Write(buffer, 0, buffer.Length);
                    buffer = Encoding.UTF8.GetBytes(values[name] + Environment.NewLine);
                    requestStream.Write(buffer, 0, buffer.Length);
                }

                // Write the files
                foreach (var file in files)
                {
                    var buffer = Encoding.ASCII.GetBytes(boundary + Environment.NewLine);
                    requestStream.Write(buffer, 0, buffer.Length);
                    buffer = Encoding.UTF8.GetBytes(string.Format("Content-Disposition: form-data; name=\"{0}\"; filename=\"{1}\"{2}", file.Name, file.Filename, Environment.NewLine));
                    requestStream.Write(buffer, 0, buffer.Length);
                    var ctype = MimeMapping.GetMimeMapping(file.Filename);
                    buffer = Encoding.ASCII.GetBytes(string.Format("Content-Type: {0}{1}{1}", MimeMapping.GetMimeMapping(file.Filename), Environment.NewLine));
                    requestStream.Write(buffer, 0, buffer.Length);
                    file.Stream.CopyTo(requestStream);
                    buffer = Encoding.ASCII.GetBytes(Environment.NewLine);
                    requestStream.Write(buffer, 0, buffer.Length);
                }

                var boundaryBuffer = Encoding.ASCII.GetBytes(boundary + "--");
                requestStream.Write(boundaryBuffer, 0, boundaryBuffer.Length);
            }

            using (var response = await request.GetResponseAsync())
            using (var responseStream = response.GetResponseStream())
            using (var stream = new MemoryStream())
            {
                responseStream.CopyTo(stream);
                return stream.ToArray();
            }
        }

        [Obsolete]
        public void UploadFileAsync(NameValueCollection values, UploadFile file )
        {
            //to fire events on the calling thread
            var _asyncOperation = AsyncOperationManager.CreateOperation(null);
            var ms = new MemoryStream();
            //make a copy of the input stream in case sb uses disposable stream
            file.Stream.CopyTo(ms);
            //you cannot set stream position often enough to zero
            ms.Position = 0;

            Task.Factory.StartNew(() =>
            {
                try
                {
                    const string contentType = "application/octet-stream";

                    var request = WebRequest.Create($"https://{ServerIpAddress}/get_query_action.php");
                    request.Method = "POST";
                    var boundary = "---------------------------" + DateTime.Now.Ticks.ToString("x", NumberFormatInfo.InvariantInfo);
                    request.ContentType = "multipart/form-data; boundary=" + boundary;
                    boundary = "--" + boundary;

                    var dataStream = new MemoryStream();
                    byte[] buffer;
                    // Write the values
                    foreach (string name in values.Keys)
                    {
                        buffer = Encoding.ASCII.GetBytes(boundary + Environment.NewLine);
                        dataStream.Write(buffer, 0, buffer.Length);
                        buffer = Encoding.ASCII.GetBytes(string.Format("Content-Disposition: form-data; name=\"{0}\"{1}{1}", name, Environment.NewLine));
                        dataStream.Write(buffer, 0, buffer.Length);
                        buffer = Encoding.UTF8.GetBytes(values[name] + Environment.NewLine);
                        dataStream.Write(buffer, 0, buffer.Length);
                    }

                    // Write the file
                    buffer = Encoding.ASCII.GetBytes(boundary + Environment.NewLine);
                    dataStream.Write(buffer, 0, buffer.Length);
                    buffer = Encoding.UTF8.GetBytes($"Content-Disposition: form-data; name=\"{file.Name}\"; filename=\"{file.Filename}\"{Environment.NewLine}");
                    dataStream.Write(buffer, 0, buffer.Length);
                    buffer = Encoding.ASCII.GetBytes(string.Format("Content-Type: {0}{1}{1}", MimeMapping.GetMimeMapping(file.Filename), Environment.NewLine));
                    dataStream.Write(buffer, 0, buffer.Length);
                    ms.CopyTo(dataStream);
                    buffer = Encoding.ASCII.GetBytes(Environment.NewLine);
                    dataStream.Write(buffer, 0, buffer.Length);

                    buffer = Encoding.ASCII.GetBytes(boundary + "--");
                    dataStream.Write(buffer, 0, buffer.Length);


                    dataStream.Position = 0;
                    //IMPORTANT: set content length to directly write to network socket
                    request.ContentLength = dataStream.Length;
                    var requestStream = request.GetRequestStream();

                    //Write data in chunks and report progress
                    var size = dataStream.Length;
                    const int chunkSize = 64 * 1024;
                    buffer = new byte[chunkSize];
                    long bytesSent = 0;
                    int readBytes;
                    while ((readBytes = dataStream.Read(buffer, 0, buffer.Length)) > 0)
                    {
                        requestStream.Write(buffer, 0, readBytes);
                        bytesSent += readBytes;

                        var status = "Uploading... " + bytesSent / 1024 + "KB of " + size / 1024 + "KB";
                        Console.WriteLine(status);
                    }

                    //get response
                    using (var response = request.GetResponse())
                    using (var responseStream = response.GetResponseStream())
                    using (var stream = new MemoryStream())
                    {
                        // ReSharper disable once PossibleNullReferenceException - exception would get catched anyway
                        responseStream.CopyTo(stream);
                        var result = Encoding.Default.GetString(stream.ToArray());
                        Console.WriteLine(result);
                    }
                }
                catch (Exception e )
                {
                    Console.WriteLine(e);
                }
            }, System.Threading.CancellationToken.None, TaskCreationOptions.LongRunning, TaskScheduler.Default);
        }
    }
}