Ejemplo n.º 1
0
        private async Task InstallPackagesInternalAsync(
            IEnumerable <ProjectInstallActionSummaryModel> summaries,
            INuGetProjectContext projectContext,
            bool shouldThrow,
            CancellationToken token)
        {
            projectContext.ActionType  = NuGetActionType.Install;
            projectContext.OperationId = Guid.NewGuid();

            List <NuGetProject>    projects = summaries.Select(t => t.Project).ToList();
            List <PackageIdentity> packages = summaries.SelectMany(t => t.NeedInstall).Distinct().ToList();

            using (SourceCacheContext sourceCacheContext = new SourceCacheContext())
            {
                foreach (PackageIdentity packageIdentity in packages)
                {
                    IReadOnlyList <ResolvedAction> actions = await GetActionsForInstallAsync(projects,
                                                                                             packageIdentity,
                                                                                             projectContext,
                                                                                             sourceCacheContext,
                                                                                             token);

                    if (actions.Count != 0)
                    {
                        PackageInstalling?.Invoke(packageIdentity.Id, packageIdentity.Version.ToNormalizedString());

                        try
                        {
                            await ExecuteActionsAsync(actions, packageIdentity, projectContext, sourceCacheContext, token);
                        }
                        catch (Exception ex)
                        {
                            Debug.WriteLine(ex);
                            if (shouldThrow)
                            {
                                throw;
                            }
                        }
                        finally
                        {
                            PackageInstalled?.Invoke(packageIdentity.Id, packageIdentity.Version.ToNormalizedString());
                        }
                    }
                }
            }
        }
Ejemplo n.º 2
0
        /// <summary>
        /// Installs the package.
        /// </summary>
        /// <param name="package">The package.</param>
        /// <param name="isPlugin">if set to <c>true</c> [is plugin].</param>
        /// <param name="progress">The progress.</param>
        /// <param name="cancellationToken">The cancellation token.</param>
        /// <returns>Task.</returns>
        /// <exception cref="ArgumentNullException">package</exception>
        public async Task InstallPackage(PackageVersionInfo package, bool isPlugin, IProgress <double> progress, CancellationToken cancellationToken)
        {
            if (package == null)
            {
                throw new ArgumentNullException(nameof(package));
            }

            if (progress == null)
            {
                throw new ArgumentNullException(nameof(progress));
            }

            var installationInfo = new InstallationInfo
            {
                Id           = Guid.NewGuid(),
                Name         = package.name,
                AssemblyGuid = package.guid,
                UpdateClass  = package.classification,
                Version      = package.versionStr
            };

            var innerCancellationTokenSource = new CancellationTokenSource();

            var tuple = new Tuple <InstallationInfo, CancellationTokenSource>(installationInfo, innerCancellationTokenSource);

            // Add it to the in-progress list
            lock (CurrentInstallations)
            {
                CurrentInstallations.Add(tuple);
            }

            var innerProgress = new ActionableProgress <double>();

            // Whenever the progress updates, update the outer progress object and InstallationInfo
            innerProgress.RegisterAction(percent =>
            {
                progress.Report(percent);

                installationInfo.PercentComplete = percent;
            });

            var linkedToken = CancellationTokenSource.CreateLinkedTokenSource(cancellationToken, innerCancellationTokenSource.Token).Token;

            var installationEventArgs = new InstallationEventArgs
            {
                InstallationInfo   = installationInfo,
                PackageVersionInfo = package
            };

            PackageInstalling?.Invoke(this, installationEventArgs);

            try
            {
                await InstallPackageInternal(package, isPlugin, innerProgress, linkedToken).ConfigureAwait(false);

                lock (CurrentInstallations)
                {
                    CurrentInstallations.Remove(tuple);
                }

                CompletedInstallationsInternal.Add(installationInfo);

                PackageInstallationCompleted?.Invoke(this, installationEventArgs);
            }
            catch (OperationCanceledException)
            {
                lock (CurrentInstallations)
                {
                    CurrentInstallations.Remove(tuple);
                }

                _logger.LogInformation("Package installation cancelled: {0} {1}", package.name, package.versionStr);

                PackageInstallationCancelled?.Invoke(this, installationEventArgs);

                throw;
            }
            catch (Exception ex)
            {
                _logger.LogError(ex, "Package installation failed");

                lock (CurrentInstallations)
                {
                    CurrentInstallations.Remove(tuple);
                }

                PackageInstallationFailed?.Invoke(this, new InstallationFailedEventArgs
                {
                    InstallationInfo = installationInfo,
                    Exception        = ex
                });

                throw;
            }
            finally
            {
                // Dispose the progress object and remove the installation from the in-progress list
                tuple.Item2.Dispose();
            }
        }
Ejemplo n.º 3
0
 private void NuGetPackageInstalling(string packageId, string version)
 {
     PackageInstalling?.Invoke(packageId, version);
 }
Ejemplo n.º 4
0
        private async Task UpdatePackagesInternalAsync(
            IEnumerable <ProjectInstallActionSummaryModel> summaries,
            INuGetProjectContext projectContext,
            bool shouldThrow,
            CancellationToken token)
        {
            projectContext.ActionType  = NuGetActionType.UpdateAll;
            projectContext.OperationId = Guid.NewGuid();

            List <NuGetProject>    projects = summaries.Select(t => t.Project).ToList();
            List <PackageIdentity> packages = summaries.SelectMany(t => t.NeedInstall).Distinct().ToList();

            using (SourceCacheContext sourceCacheContext = new SourceCacheContext())
            {
                foreach (PackageIdentity packageIdentity in packages)
                {
                    IReadOnlyList <ResolvedAction> actions = await GetActionsForUpdateAsync(projects,
                                                                                            packageIdentity,
                                                                                            projectContext,
                                                                                            sourceCacheContext,
                                                                                            token);

                    if (actions.Count != 0)
                    {
                        PackageInstalling?.Invoke(packageIdentity.Id, packageIdentity.Version.ToNormalizedString());

                        try
                        {
                            await ExecuteActionsAsync(actions, packageIdentity, projectContext, sourceCacheContext, token);
                        }
                        catch (PackageReferenceRollbackException rollbackException)
                        {
                            StringBuilder sb = new StringBuilder();
                            sb.AppendLine(rollbackException.Message);

                            if (rollbackException.LogMessages != null)
                            {
                                foreach (var item in rollbackException.LogMessages)
                                {
                                    sb.AppendLine(item.FormatWithCode());
                                }
                            }

                            throw new Exception(sb.ToString());
                        }
                        catch (Exception ex)
                        {
                            Debug.WriteLine(ex);
                            if (shouldThrow)
                            {
                                throw;
                            }
                        }
                        finally
                        {
                            PackageInstalled?.Invoke(packageIdentity.Id, packageIdentity.Version.ToNormalizedString());
                        }
                    }
                }
            }
        }