示例#1
0
        public void Upgrade(ILogger logger, IDeploymentComponentFactory deploymentComponentFactory, NugetPackage installedPackage)
        {
            PerformanceLogger performanceLogger = new PerformanceLogger(logger);

            performanceLogger.Restart("Opening, Calculating and planing deployment component");
            using (ParallelReadableZipArchive upgradeZipArchive = Open(packagePathAndFileName))
            {
                if (upgradeZipArchive == null)
                {
                    throw new InvalidOperationException($"Source archive {packagePathAndFileName} not found.");
                }

                using (ParallelReadableZipArchive installedzipArchive = installedPackage?.Open())
                {
                    IReadOnlyCollection <ParallelReadableZipArchiveEntry> installedEntries = installedzipArchive?.Entries;
                    IReadOnlyCollection <ParallelReadableZipArchiveEntry> newEntries       = upgradeZipArchive.Entries;

                    IReadOnlyCollection <IDeploymentComponent> deploymentComponents = deploymentComponentFactory.CreateDeploymentComponents(this, installedPackage, installedEntries, newEntries);

                    performanceLogger.Stop();

                    performanceLogger.Restart("Execution of deployment activities");
                    UpgradeDeploymentComponents(deploymentComponents, newEntries);
                    performanceLogger.Stop();
                }
            }
        }
        public async override Task Extract(IAsyncStreamReader <ExtractFileRequest> requestStream, IServerStreamWriter <ExtractFileResponse> responseStream, ServerCallContext context)
        {
            while (await requestStream.MoveNext())
            {
                var request           = requestStream.Current;
                var zipArchive        = new ParallelReadableZipArchive(request.FilePathAndName);
                var zipArchiveEntries = zipArchive.Entries;
                var items             = zipArchiveEntries.Count;

                ConcurrentStack <int> progressStack = new ConcurrentStack <int>();
                IProgress <int>       progress      = CreateProgress(progressStack);


                int itemFinished = 0;
                var responseTask = Task.Run(() => ReportProgress(request, responseStream, progressStack, items));

                await Task.Run(() => Parallel.ForEach(zipArchiveEntries, zipArchiveEntry =>
                {
                    var targetFile         = Path.Combine(request.TargetPath, zipArchiveEntry.FullName);
                    string?targetDirectory = Path.GetDirectoryName(targetFile);
                    if (targetDirectory != null)
                    {
                        Directory.CreateDirectory(targetDirectory);
                    }
                    zipArchiveEntry.ExtractToFile(targetFile, true);

                    var result = Interlocked.Increment(ref itemFinished);
                    progress.Report(result);
                }));

                await responseTask;

                await responseStream.WriteAsync(new ExtractFileResponse
                {
                    Id             = request.Id,
                    Finished       = true,
                    Items          = items,
                    ItemsInstalled = items
                });
            }

            Console.WriteLine("Ended correctly");
        }