public void Run (ProgressMonitorStatusMessage progressMessage, IEnumerable<IPackageAction> actions)
{
AddInstallActionsToPendingQueue (actions);
packageManagementEvents.OnPackageOperationsStarting ();
runCount++;
BackgroundDispatch (() => TryRunActionsWithProgressMonitor (progressMessage, actions.ToList ()));
}
public void Run(
ProgressMonitorStatusMessage progressMessage,
IEnumerable <IPackageAction> actions,
bool clearConsole)
{
Run(progressMessage, actions, null, clearConsole);
}
public void Run (ProgressMonitorStatusMessage progressMessage, IPackageAction action)
{
RunProgressMessage = progressMessage;
ActionRun = action;
RunAction (progressMessage, action);
}
public Task RunAsync(ProgressMonitorStatusMessage progressMessage, IEnumerable <IPackageAction> actions)
{
var taskCompletionSource = new TaskCompletionSource <bool> ();
Run(progressMessage, actions, taskCompletionSource);
return(taskCompletionSource.Task);
}
public override void Run(Solution solution, IList <PackageReferencesForCreatedProject> packageReferencesForCreatedProjects)
{
List <InstallPackageAction> installPackageActions = CreateInstallPackageActions(solution, packageReferencesForCreatedProjects);
ProgressMonitorStatusMessage progressMessage = ProgressMonitorStatusMessageFactory.CreateInstallingProjectTemplatePackagesMessage();
backgroundPackageActionRunner.Run(progressMessage, installPackageActions);
}
public void RunAndWait(ProgressMonitorStatusMessage progressMessage, IEnumerable <IPackageAction> actions)
{
AddInstallActionsToPendingQueue(actions);
packageManagementEvents.OnPackageOperationsStarting();
runCount++;
BackgroundDispatchAndWait(() => TryRunActionsWithProgressMonitor(progressMessage, actions.ToList()));
}
void RunActionsWithProgressMonitor(
ProgressMonitorStatusMessage progressMessage,
IList <IPackageAction> installPackageActions,
TaskCompletionSource <bool> taskCompletionSource,
bool clearConsole,
CancellationTokenSource cancellationTokenSource)
{
using (ProgressMonitor monitor = progressMonitorFactory.CreateProgressMonitor(progressMessage.Status, clearConsole, cancellationTokenSource)) {
using (PackageManagementEventsMonitor eventMonitor = CreateEventMonitor(monitor, taskCompletionSource)) {
try {
monitor.BeginTask(null, installPackageActions.Count);
RunActionsWithProgressMonitor(monitor, installPackageActions);
eventMonitor.ReportResult(progressMessage);
} catch (Exception ex) {
RemoveInstallActions(installPackageActions);
bool showPackageConsole = !monitor.CancellationToken.IsCancellationRequested;
eventMonitor.ReportError(progressMessage, ex, showPackageConsole);
} finally {
monitor.EndTask();
GuiDispatch(() => {
RemoveInstallActions(installPackageActions);
packageManagementEvents.OnPackageOperationsFinished();
});
}
}
}
}
void RestorePackages(IProgressMonitor progressMonitor, ProgressMonitorStatusMessage progressMessage)
{
var commandLine = new NuGetPackageRestoreCommandLine(solution);
progressMonitor.Log.WriteLine(commandLine.ToString());
RestorePackages(progressMonitor, progressMessage, commandLine);
}
public void ShowError(ProgressMonitorStatusMessage progressMessage, string error)
{
using (IProgressMonitor monitor = progressMonitorFactory.CreateProgressMonitor(progressMessage.Status)) {
monitor.Log.WriteLine(error);
monitor.ReportError(progressMessage.Error, null);
monitor.ShowPackageConsole();
}
}
void RestorePackages(IProgressMonitor progressMonitor, ProgressMonitorStatusMessage progressMessage)
{
var commandLine = new NuGetPackageRestoreCommandLine(solution);
progressMonitor.Log.WriteLine(commandLine.ToString());
RestorePackages(progressMonitor, progressMessage, commandLine);
}
public void ReportError(ProgressMonitorStatusMessage progressMessage, Exception ex)
{
LoggingService.LogInternalError(ex);
progressMonitor.Log.WriteLine(ex.Message);
progressMonitor.ReportError(progressMessage.Error, null);
ShowPackageConsole(progressMonitor);
packageManagementEvents.OnPackageOperationError(ex);
}
public CheckForUpdatesProgressMonitor (
IPackageManagementProgressMonitorFactory progressMonitorFactory,
IPackageManagementEvents packageEvents)
{
progressMessage = ProgressMonitorStatusMessageFactory.CreateCheckingForPackageUpdatesMessage ();
this.progressMonitor = progressMonitorFactory.CreateProgressMonitor (progressMessage.Status);
eventMonitor = new PackageUpdatesEventMonitor (progressMonitor, packageEvents);
}
void CheckForPackageUpdates (IProgressMonitor progressMonitor, ProgressMonitorStatusMessage progressMessage)
{
updatedPackagesInSolution.CheckForUpdates ();
if (updatedPackagesInSolution.AnyUpdates ()) {
progressMonitor.ReportSuccess (GettextCatalog.GetString ("Package updates are available."));
} else {
progressMonitor.ReportSuccess (progressMessage.Success);
}
}
public CheckForUpdatesProgressMonitor(
IPackageManagementProgressMonitorFactory progressMonitorFactory,
IPackageManagementEvents packageEvents)
{
progressMessage = ProgressMonitorStatusMessageFactory.CreateCheckingForPackageUpdatesMessage();
this.progressMonitor = progressMonitorFactory.CreateProgressMonitor(progressMessage.Status);
eventMonitor = new PackageUpdatesEventMonitor(progressMonitor, packageEvents);
}
void Update (UpdateAllPackagesInSolution updateAllPackages, ProgressMonitorStatusMessage progressMessage)
{
try {
List<UpdatePackageAction> updateActions = updateAllPackages.CreateActions ().ToList ();
PackageManagementServices.BackgroundPackageActionRunner.Run (progressMessage, updateActions);
} catch (Exception ex) {
PackageManagementServices.BackgroundPackageActionRunner.ShowError (progressMessage, ex);
}
}
public static ProgressMonitorStatusMessage CreateUpdatingPackagesInSolutionMessage(IEnumerable <IDotNetProject> projects)
{
ProgressMonitorStatusMessage message = CreateUpdatingPackagesInSolutionMessage();
return(new UpdatePackagesProgressMonitorStatusMessage(
projects,
GettextCatalog.GetString("Packages are up to date."),
GettextCatalog.GetString("No updates found but warnings were reported."),
message));
}
public static ProgressMonitorStatusMessage CreateUpdatingSinglePackageMessage(string packageId, IDotNetProject project)
{
ProgressMonitorStatusMessage message = CreateUpdatingSinglePackageMessage(packageId);
return(new UpdatePackagesProgressMonitorStatusMessage(
project,
GettextCatalog.GetString("{0} is up to date.", packageId),
GettextCatalog.GetString("No update found but warnings were reported."),
message));
}
void TryRunActionsWithProgressMonitor(ProgressMonitorStatusMessage progressMessage, IList <IPackageAction> actions)
{
try {
RunActionsWithProgressMonitor(progressMessage, actions);
} catch (Exception ex) {
LoggingService.LogInternalError(ex);
} finally {
GuiDispatch(() => runCount--);
}
}
public static ProgressMonitorStatusMessage CreateUpdatingPackagesInProjectMessage(int count, IPackageManagementProject project)
{
ProgressMonitorStatusMessage message = CreateUpdatingPackagesInProjectMessage(count);
return(new UpdatePackagesProgressMonitorStatusMessage(
project,
GetString("Packages are up to date."),
GetString("No updates found but warnings were reported."),
message));
}
public static ProgressMonitorStatusMessage CreateUpdatingSinglePackageMessage(string packageId, IPackageManagementProject project)
{
ProgressMonitorStatusMessage message = CreateUpdatingSinglePackageMessage(packageId);
return(new UpdatePackagesProgressMonitorStatusMessage(
project,
GetString("{0} is up to date.", packageId),
GetString("No update found but warnings were reported. Please see Package Console for details."),
message));
}
public static ProgressMonitorStatusMessage CreateUpdatingPackagesInSolutionMessage(IEnumerable <IPackageManagementProject> projects)
{
ProgressMonitorStatusMessage message = CreateUpdatingPackagesInSolutionMessage();
return(new UpdatePackagesProgressMonitorStatusMessage(
projects,
GetString("Packages are up to date."),
GetString("No updates found but warnings were reported. Please see Package Console for details."),
message));
}
public Task UninstallPackagesAsync(
Project project,
IEnumerable <string> packages,
bool removeDependencies = false)
{
var actions = CreateUninstallActions(project, packages, removeDependencies).ToList();
ProgressMonitorStatusMessage progressMessage = GetUninstallingStatusMessages(actions);
return(backgroundActionRunner.RunAsync(progressMessage, actions));
}
public void Restore (ProgressMonitorStatusMessage progressMessage)
{
try {
if (AnyMissingPackages ()) {
RestoreWithProgressMonitor (progressMessage);
}
} catch (Exception ex) {
LoggingService.LogInternalError (ex);
RestoreFailed = true;
}
}
public UpdatePackagesProgressMonitorStatusMessage(
IEnumerable <IDotNetProject> projects,
string packagesUpToDateMessage,
string packagesUpToDateWarningMessage,
ProgressMonitorStatusMessage message)
: base(message.Status, message.Success, message.Error, message.Warning)
{
this.packagesUpToDateMessage = packagesUpToDateMessage;
this.packagesUpToDateWarningMessage = packagesUpToDateWarningMessage;
monitor = new UpdatedPackagesMonitor(projects);
}
void OnPackageRestoreCompleted(
IAsyncOperation operation,
IProgressMonitor progressMonitor,
ProgressMonitorStatusMessage progressMessage)
{
if (operation.Success)
{
RefreshProjectReferences();
}
ReportOutcome(operation, progressMonitor, progressMessage);
}
public void ReportResult(ProgressMonitorStatusMessage progressMessage)
{
if (HasWarnings)
{
progressMonitor.ReportWarning(progressMessage.Warning);
}
else
{
progressMonitor.ReportSuccess(progressMessage.Success);
}
}
void InstallPackages(
IEnumerable <SourceRepository> repositories,
Project project,
IEnumerable <PackageManagementPackageReference> packages,
bool licensesAccepted)
{
var actions = CreateInstallActions(repositories, project, packages, licensesAccepted).ToList();
ProgressMonitorStatusMessage progressMessage = GetProgressMonitorStatusMessages(actions);
backgroundActionRunner.Run(progressMessage, actions);
}
public UpdatePackagesProgressMonitorStatusMessage (
IEnumerable<IPackageManagementProject> projects,
string packagesUpToDateMessage,
string packagesUpToDateWarningMessage,
ProgressMonitorStatusMessage message)
: base (message.Status, message.Success, message.Error, message.Warning)
{
this.packagesUpToDateMessage = packagesUpToDateMessage;
this.packagesUpToDateWarningMessage = packagesUpToDateWarningMessage;
monitor = new UpdatedPackagesMonitor (projects);
}
void InstallPackages(List <IPackageAction> packageActions)
{
if (packageActions.Count > 0)
{
ProgressMonitorStatusMessage progressMessage = GetProgressMonitorStatusMessages(packageActions);
backgroundActionRunner.Run(progressMessage, packageActions);
viewModel.OnInstallingSelectedPackages();
Close();
}
}
/// <summary>
/// Installs NuGet packages into the selected project using the enabled package sources.
/// </summary>
/// <param name="project">Project.</param>
/// <param name="packages">Packages.</param>
public Task InstallPackagesAsync(Project project, IEnumerable <PackageManagementPackageReference> packages)
{
var repositoryProvider = SourceRepositoryProviderFactory.CreateSourceRepositoryProvider();
var repositories = repositoryProvider.GetRepositories().ToList();
var actions = CreateInstallActions(repositories, project, packages, licensesAccepted: false).ToList();
ProgressMonitorStatusMessage progressMessage = GetInstallingStatusMessages(actions);
return(backgroundActionRunner.RunAsync(progressMessage, actions));
}
void InstallPackages(List <IPackageAction> packageActions)
{
if (packageActions.Count > 0)
{
AddRecentPackages(packageActions);
ProgressMonitorStatusMessage progressMessage = GetProgressMonitorStatusMessages(packageActions);
backgroundActionRunner.Run(progressMessage, packageActions);
Close();
}
}
public void Restore(ProgressMonitorStatusMessage progressMessage)
{
try {
if (AnyMissingPackages())
{
RestoreWithProgressMonitor(progressMessage);
}
} catch (Exception ex) {
LoggingService.LogError("Package restore failed", ex);
RestoreFailed = true;
}
}
void Restore(PackageRestorer restorer, Action afterRestore)
{
ProgressMonitorStatusMessage progressMessage = ProgressMonitorStatusMessageFactory.CreateRestoringPackagesBeforeUpdateMessage();
PackageManagementBackgroundDispatcher.Dispatch(() => {
restorer.Restore(progressMessage);
if (!restorer.RestoreFailed)
{
afterRestore();
}
});
}
void RemovePackage (PackageReferenceNode packageReferenceNode, ProgressMonitorStatusMessage progressMessage)
{
IPackageManagementProject project = PackageManagementServices.Solution.GetActiveProject ();
UninstallPackageAction action = project.CreateUninstallPackageAction ();
action.Package = project.FindPackage (packageReferenceNode.Id);
if (action.Package != null) {
PackageManagementServices.BackgroundPackageActionRunner.Run (progressMessage, action);
} else {
ShowMissingPackageError (progressMessage, packageReferenceNode);
}
}
void OnPackageRestoreCompleted(
IAsyncOperation operation,
IProgressMonitor progressMonitor,
ProgressMonitorStatusMessage progressMessage)
{
if (operation.Success)
{
RefreshProjectReferences();
ForceCreationOfSharedRepositoriesConfigFile();
}
ReportOutcome(operation, progressMonitor, progressMessage);
}
public UpdatePackagesProgressMonitorStatusMessage (
IPackageManagementProject project,
string packagesUpToDateMessage,
string packagesUpToDateWarningMessage,
ProgressMonitorStatusMessage message)
: this (
new IPackageManagementProject [] { project },
packagesUpToDateMessage,
packagesUpToDateWarningMessage,
message)
{
}
public UpdatePackagesProgressMonitorStatusMessage(
IDotNetProject project,
string packagesUpToDateMessage,
string packagesUpToDateWarningMessage,
ProgressMonitorStatusMessage message)
: this(
new IDotNetProject [] { project },
packagesUpToDateMessage,
packagesUpToDateWarningMessage,
message)
{
}
public void ReportError(ProgressMonitorStatusMessage progressMessage, Exception ex)
{
LoggingService.LogError(progressMessage.Error, ex);
progressMonitor.Log.WriteLine(GetErrorMessageForPackageConsole(ex));
progressMonitor.ReportError(progressMessage.Error, null);
ShowPackageConsole(progressMonitor);
packageManagementEvents.OnPackageOperationError(ex);
if (taskCompletionSource != null)
{
taskCompletionSource.TrySetException(ExceptionUtility.Unwrap(ex));
}
}
void RunInternal (IProgressMonitor progressMonitor, ProgressMonitorStatusMessage progressMessage)
{
var commandLine = new MonoPclCommandLine () {
List = true
};
commandLine.BuildCommandLine ();
progressMonitor.ShowPackageConsole ();
progressMonitor.Log.WriteLine (commandLine.ToString ());
progressMonitor.Log.WriteLine ();
RunMonoPcl (progressMonitor, progressMessage, commandLine);
}
public void Run(PackageReferenceNode packageReferenceNode, ProgressMonitorStatusMessage progressMessage)
{
try {
IPackageManagementProject project = solution.GetProject(packageReferenceNode.Project);
ReinstallPackageAction action = project.CreateReinstallPackageAction();
action.PackageId = packageReferenceNode.Id;
action.PackageVersion = packageReferenceNode.Version;
runner.Run(progressMessage, action);
} catch (Exception ex) {
runner.ShowError(progressMessage, ex);
}
}
public void Run (PackageReferenceNode packageReferenceNode, ProgressMonitorStatusMessage progressMessage)
{
try {
IPackageManagementProject project = solution.GetActiveProject ();
ReinstallPackageAction action = project.CreateReinstallPackageAction ();
action.PackageId = packageReferenceNode.Id;
action.PackageVersion = packageReferenceNode.Version;
runner.Run (progressMessage, action);
} catch (Exception ex) {
runner.ShowError (progressMessage, ex);
}
}
public void Run(InstallPackageCommand command)
{
try {
IPackageManagementProject project = PackageManagementServices.Solution.GetActiveProject();
var action = new InstallPackageAction(project, PackageManagementServices.PackageManagementEvents);
action.PackageId = command.PackageId;
action.PackageVersion = command.GetVersion();
ProgressMonitorStatusMessage progressMessage = CreateProgressMessage(action.PackageId);
PackageManagementServices.BackgroundPackageActionRunner.Run(progressMessage, action);
} catch (Exception ex) {
ShowStatusBarError(ex);
}
}
void CheckForPackageUpdates (
ProgressMonitor progressMonitor,
ProgressMonitorStatusMessage progressMessage,
PackageUpdatesEventMonitor eventMonitor)
{
updatedPackagesInSolution.CheckForUpdates ();
if (updatedPackagesInSolution.AnyUpdates ()) {
progressMonitor.ReportSuccess (GettextCatalog.GetString ("Package updates are available."));
} else if (eventMonitor.WarningReported) {
progressMonitor.ReportWarning (progressMessage.Warning);
} else {
progressMonitor.ReportSuccess (progressMessage.Success);
}
}
void RunInternal ()
{
progressMessage = CreateCheckingPackageCompatibilityMessage ();
using (progressMonitor = CreateProgressMonitor ()) {
using (PackageManagementEventsMonitor eventMonitor = CreateEventMonitor (progressMonitor)) {
try {
CheckCompatibility ();
} catch (Exception ex) {
eventMonitor.ReportError (progressMessage, ex);
}
}
}
}
public void Run (ProgressMonitorStatusMessage progressMessage)
{
IProgressMonitor progressMonitor = CreateProgressMonitor (progressMessage);
try {
RestorePackages(progressMonitor, progressMessage);
} catch (Exception ex) {
LoggingService.LogInternalError (ex);
progressMonitor.Log.WriteLine(ex.Message);
progressMonitor.ReportError (progressMessage.Error, null);
progressMonitor.ShowPackageConsole ();
progressMonitor.Dispose();
RestoreFailed = true;
}
}
public void Run (PackageReferenceNode packageReferenceNode, ProgressMonitorStatusMessage progressMessage)
{
try {
var solutionManager = PackageManagementServices.Workspace.GetSolutionManager (packageReferenceNode.Project.ParentSolution);
var action = new ReinstallNuGetPackageAction (
packageReferenceNode.Project,
solutionManager);
action.PackageId = packageReferenceNode.Id;
action.Version = packageReferenceNode.Version;
runner.Run (progressMessage, action);
} catch (Exception ex) {
runner.ShowError (progressMessage, ex);
}
}
public void Run (ProgressMonitorStatusMessage progressMessage)
{
using (ProgressMonitor progressMonitor = CreateProgressMonitor (progressMessage)) {
using (PackageManagementEventsMonitor eventMonitor = CreateEventMonitor (progressMonitor)) {
try {
RestorePackages (progressMonitor, progressMessage);
} catch (Exception ex) {
LoggingService.LogError (progressMessage.Error, ex);
progressMonitor.Log.WriteLine (ex.Message);
progressMonitor.ReportError (progressMessage.Error, null);
progressMonitor.ShowPackageConsole ();
progressMonitor.Dispose ();
RestoreFailed = true;
}
}
}
}
void CreateRunner ()
{
actions = new List<IPackageAction> ();
progressMessage = new ProgressMonitorStatusMessage ("Status", "Success", "Error", "Warning");
packageManagementEvents = new PackageManagementEvents ();
progressMonitorFactory = new FakeProgressMonitorFactory ();
progressMonitor = progressMonitorFactory.ProgressMonitor;
repositoryFactoryEvents = new FakePackageRepositoryFactoryEvents ();
progressProvider = new PackageManagementProgressProvider (repositoryFactoryEvents, handler => {
handler.Invoke ();
});
runner = new TestableBackgroundPackageActionRunner (
progressMonitorFactory,
packageManagementEvents,
progressProvider);
}
void RunActionsWithProgressMonitor (ProgressMonitorStatusMessage progressMessage, IList<IPackageAction> installPackageActions)
{
using (IProgressMonitor monitor = progressMonitorFactory.CreateProgressMonitor (progressMessage.Status)) {
using (PackageManagementEventsMonitor eventMonitor = CreateEventMonitor (monitor)) {
try {
monitor.BeginTask (null, installPackageActions.Count);
RunActionsWithProgressMonitor (monitor, installPackageActions);
eventMonitor.ReportResult (progressMessage);
} catch (Exception ex) {
RemoveInstallActions (installPackageActions);
eventMonitor.ReportError (progressMessage, ex);
} finally {
monitor.EndTask ();
GuiDispatch (() => {
RemoveInstallActions (installPackageActions);
packageManagementEvents.OnPackageOperationsFinished ();
});
}
}
}
}
public void ReportResult (ProgressMonitorStatusMessage progressMessage)
{
if (HasWarnings) {
progressMonitor.ReportWarning (progressMessage.Warning);
} else {
progressMonitor.ReportSuccess (progressMessage.Success);
}
}
void ShowMissingPackageError (ProgressMonitorStatusMessage progressMessage, PackageReferenceNode packageReferenceNode)
{
string message = GettextCatalog.GetString ("Unable to find package {0} {1} to remove it from the project. Please restore the package first.", packageReferenceNode.Id, packageReferenceNode.Version);
PackageManagementServices.BackgroundPackageActionRunner.ShowError (progressMessage, message);
}
void UpdatePackage (ProgressMonitorStatusMessage progressMessage, UpdatePackageAction action)
{
try {
PackageManagementServices.BackgroundPackageActionRunner.Run (progressMessage, action);
} catch (Exception ex) {
PackageManagementServices.BackgroundPackageActionRunner.ShowError (progressMessage, ex);
}
}
public void ShowError (ProgressMonitorStatusMessage progressMessage, Exception exception)
{
LoggingService.LogError (progressMessage.Error, exception);
ShowError (progressMessage, exception.Message);
}
public void ShowError (ProgressMonitorStatusMessage progressMessage, string error)
{
using (ProgressMonitor monitor = progressMonitorFactory.CreateProgressMonitor (progressMessage.Status)) {
monitor.Log.WriteLine (error);
monitor.ReportError (progressMessage.Error, null);
monitor.ShowPackageConsole ();
}
}
ProgressMonitor CreateProgressMonitor (ProgressMonitorStatusMessage progressMessage)
{
return progressMonitorFactory.CreateProgressMonitor (progressMessage.Status);
}
public void Run (IDotNetProject project, ProgressMonitorStatusMessage progressMessage)
{
this.project = project;
Run (progressMessage);
}
void RestorePackages (ProgressMonitor progressMonitor, ProgressMonitorStatusMessage progressMessage)
{
var msbuildTargetsMonitor = new MSBuildTargetsRestoredMonitor (packageManagementEvents);
using (msbuildTargetsMonitor) {
var action = new RestorePackagesAction (solution, packageManagementEvents);
if (project != null) {
action.Project = project;
}
action.Execute ();
}
RefreshProjectReferences (msbuildTargetsMonitor.AnyMSBuildTargetsRestored);
ForceCreationOfSharedRepositoriesConfigFile ();
progressMonitor.ReportSuccess (progressMessage.Success);
packageManagementEvents.OnPackagesRestored ();
}
public void Run (ProgressMonitorStatusMessage progressMessage, IPackageAction action)
{
Run (progressMessage, new IPackageAction [] { action });
}
void TryRunActionsWithProgressMonitor (ProgressMonitorStatusMessage progressMessage, IList<IPackageAction> actions)
{
try {
RunActionsWithProgressMonitor (progressMessage, actions);
} catch (Exception ex) {
LoggingService.LogInternalError (ex);
} finally {
GuiDispatch (() => runCount--);
}
}
public void ReportError (ProgressMonitorStatusMessage progressMessage, Exception ex)
{
LoggingService.LogError (progressMessage.Error, ex);
progressMonitor.Log.WriteLine (ex.Message);
progressMonitor.ReportError (progressMessage.Error, null);
ShowPackageConsole (progressMonitor);
packageManagementEvents.OnPackageOperationError (ex);
}
