예제 #1
0
 public void Rollback(Manifest manifest)
 {
     try
     {
         string filename = string.Empty;
         foreach (var file in manifest.ManifestFiles.Files)
         {
             filename = Path.Combine(backupFilePath, file.Source);
             File.Copy(filename, Path.Combine(Path.GetFullPath(manifest.Application.Location), file.Source));
         }
         Directory.Delete(backupFilePath, true);
     }
     catch
     {
     }
 }
예제 #2
0
 private void Backup(Manifest manifest)
 {
     try
     {
         string sourcePath = Path.GetFullPath(manifest.Application.Location);
         string s_filename = string.Empty;
         string t_filename = string.Empty;
         if (!Directory.Exists(backupFilePath))
         {
             Directory.CreateDirectory(backupFilePath);
         }
         foreach (var file in manifest.ManifestFiles.Files)
         {
             t_filename = Path.Combine(backupFilePath, file.Source);
             s_filename = Path.Combine(sourcePath, file.Source);
             if (File.Exists(s_filename))
             {
                 File.Copy(s_filename, t_filename, true);
             }
         }
     }
     catch
     {
     }
 }
예제 #3
0
 public void Activate(Manifest[] manifests)
 {
     foreach (var m in manifests)
     {
         OnActivationInitializing(new ManifestEventArgs() { Manifest = m });
         Backup(m);
         ActivationStartedEventArgs e = new ActivationStartedEventArgs() { Manifest = m };
         OnActivationStarted(e);
         if (e.Cancel)
         {
             Clear();
             break;
         }
         else
         {
             fileCopyer.CopyAsync(m, downloader.TempPath);
         }
     }
 }
예제 #4
0
 public void DownloadAsync(Manifest[] manifests)
 {
     foreach (var m in manifests)
     {
         downloader.DownloadAsync(m);
     }
 }
예제 #5
0
 /// <summary>
 /// 异步下载并指定任务Id
 /// </summary>
 /// <param name="manifest"></param>
 /// <param name="taskId"></param>
 public void DownloadAsync(Manifest manifest,object taskId)
 {
     AsyncOperation asyncOp = AsyncOperationManager.CreateOperation(taskId);
     lock (userStateToLifetime.SyncRoot)
     {
         if (userStateToLifetime.Contains(taskId))
         {
             throw new ArgumentException("参数taskId必须是唯一的", "taskId");
         }
         userStateToLifetime[taskId] = asyncOp;
     }
     WorkerEventHandler workerDelegate = new WorkerEventHandler(DownloadWorker);
     workerDelegate.BeginInvoke(asyncOp, null, null);
 }
예제 #6
0
 private void Init(Manifest manifest)
 {
     this.manifest = manifest;
     webClient.BaseAddress = manifest.ManifestFiles.BaseUrl;
     webClient.Credentials = CredentialCache.DefaultCredentials;
     webClient.Encoding = Encoding.UTF8;
 }
예제 #7
0
 /// <summary>
 /// 同步下载
 /// </summary>
 /// <param name="manifest"></param>
 public void Download(Manifest manifest)
 {
     Init(manifest);
     foreach (var file in manifest.ManifestFiles.Files)
     {
         string serverFileName = Path.Combine(manifest.ManifestFiles.BaseUrl, file.Source);
         string clientFileName = Path.Combine(tempPath, file.Source);
         Uri uri = new Uri(serverFileName);
         if (!Directory.Exists(Path.GetDirectoryName(clientFileName)))
         {
             Directory.CreateDirectory(Path.GetDirectoryName(clientFileName));
         }
         webClient.DownloadFile(uri, clientFileName);
     }
 }
예제 #8
0
 /// <summary>
 /// 异步下载
 /// </summary>
 /// <param name="manifest"></param>
 public void DownloadAsync(Manifest manifest)
 {
     Init(manifest);
     DownloadAsync(manifest,defaultTaskId);
 }
예제 #9
0
 public void Copy(Manifest manifest, string sourcePath)
 {
     string[] sourceFiles = null;
     string[] targetFiles = null;
     GetFiles(manifest, sourcePath, out sourceFiles, out targetFiles);
     for (int i = 0; i < sourceFiles.Length; i++)
     {
         if (!Directory.Exists(Path.GetDirectoryName(targetFiles[i])))
         {
             Directory.CreateDirectory(Path.GetDirectoryName(targetFiles[i]));
         }
         File.Copy(sourceFiles[i], targetFiles[i], true);
     }
 }
예제 #10
0
 private void GetFiles(Manifest manifest, string sourcePath, out string[] sourceFiles, out string[] targetFiles)
 {
     sourceFiles = new string[manifest.ManifestFiles.Files.Length];
     targetFiles = new string[manifest.ManifestFiles.Files.Length];
     string path = Path.GetFullPath(manifest.Application.Location);
     for (int i = 0; i < manifest.ManifestFiles.Files.Length; i++)
     {
         sourceFiles[i] = Path.Combine(sourcePath, manifest.ManifestFiles.Files[i].Source);
         targetFiles[i] = Path.Combine(path, manifest.ManifestFiles.Files[i].Source);
     }
 }
예제 #11
0
        private void FileCopyWorker(Manifest manifest, string sourcePath, AsyncOperation asyncOp)
        {
            Exception exception = null;
            FileCopyProgressChangedEventArgs e = null;
            Stream rStream = null;
            Stream wStream = null;
            double writeBytes = 0;
            string[] sourceFiles = null;
            string[] targetFiles = null;
            GetFiles(manifest, sourcePath, out sourceFiles, out targetFiles);
            if (!TaskCanceled(asyncOp.UserSuppliedState))
            {
                try
                {
                    double totalBytes = GetFileLength(sourceFiles);
                    byte[] buffer = new byte[writeFileLength];
                    int len = 0;
                    int offset = 0;
                    for (int i = 0; i < sourceFiles.Length; i++)
                    {
                        try
                        {
                            if (!Directory.Exists(Path.GetDirectoryName(targetFiles[i])))
                            {
                                Directory.CreateDirectory(Path.GetDirectoryName(targetFiles[i]));
                            }
                            rStream = new FileStream(sourceFiles[i], FileMode.Open, FileAccess.Read, FileShare.None);
                            wStream = new FileStream(targetFiles[i], FileMode.Create, FileAccess.Write, FileShare.None);
                            while ((len = rStream.Read(buffer, offset, writeFileLength)) > 0)
                            {
                                wStream.Write(buffer, offset, len);
                                writeBytes += len;
                                e = new FileCopyProgressChangedEventArgs((int)(writeBytes / totalBytes * 100), asyncOp.UserSuppliedState);
                                e.SourceFileName = sourceFiles[i];
                                e.TargetFileName = targetFiles[i];
                                e.TotalBytesToCopy = totalBytes;
                                e.BytesToCopy = len;
                                e.Manifest = manifest;
                                asyncOp.Post(this.onProgressReportDelegate, e);
                                Thread.Sleep(1);
                            }
                        }
                        finally
                        {
                            DisposeStream(wStream);
                            DisposeStream(rStream);
                        }
                    }
                }
                catch (Exception ex)
                {
                    exception = ex;
                    OnFileCopyError(new FileCopyErrorEventArgs() { Error = ex, Manifest = manifest });
                }

                if (exception == null && targetFiles.Length > 0)
                {
                    //解压文件
                    string fileName = targetFiles.First();
                    ZipHelper.DeCompressionZip(fileName, Path.GetFullPath("."));
                    File.Delete(fileName);
                }
            }
            this.CompletionMethod(manifest, exception, TaskCanceled(asyncOp.UserSuppliedState), asyncOp);
        }
예제 #12
0
        private void CompletionMethod(Manifest manifest, Exception exception, bool canceled, AsyncOperation asyncOp)
        {
            if (!canceled)
            {
                lock (userStateToLifetime.SyncRoot)
                {
                    userStateToLifetime.Remove(asyncOp.UserSuppliedState);
                }
            }

            FileCopyCompletedEventArgs e = new FileCopyCompletedEventArgs(exception, canceled, asyncOp.UserSuppliedState);
            e.Manifest = manifest;
            asyncOp.PostOperationCompleted(onCompletedDelegate, e);
        }
예제 #13
0
 public void CopyAsync(Manifest manifest, string sourcePath)
 {
     CopyAsync(manifest, sourcePath, defaultTaskId);
 }