public void Run (ProgressMonitorStatusMessage progressMessage, IPackageAction action)
		{
			RunProgressMessage = progressMessage;
			ActionRun = action;

			RunAction (progressMessage, action);
		}

		public void Run (ProgressMonitorStatusMessage progressMessage, IEnumerable<IPackageAction> actions)
		{
			AddInstallActionsToPendingQueue (actions);
			packageManagementEvents.OnPackageOperationsStarting ();
			runCount++;
			BackgroundDispatch (() => TryRunActionsWithProgressMonitor (progressMessage, actions.ToList ()));
		}

		void RestorePackages(IProgressMonitor progressMonitor, ProgressMonitorStatusMessage progressMessage)
		{
			var commandLine = new NuGetPackageRestoreCommandLine(solution);

			progressMonitor.Log.WriteLine(commandLine.ToString());

			RestorePackages(progressMonitor, progressMessage, commandLine);
		}

		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 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 void Restore (ProgressMonitorStatusMessage progressMessage)
		{
			try {
				if (AnyMissingPackages ()) {
					RestoreWithProgressMonitor (progressMessage);
				}
			} catch (Exception ex) {
				LoggingService.LogInternalError (ex);
				RestoreFailed = true;
			}
		}

		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 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);
			}
		}

		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);
			}
		}

		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);
		}

		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);
			}
		}

		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 ();
						});
					}
				}
			}
		}

		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 ();
		}

		void TryRunActionsWithProgressMonitor (ProgressMonitorStatusMessage progressMessage, IList<IPackageAction> actions)
		{
			try {
				RunActionsWithProgressMonitor (progressMessage, actions);
			} catch (Exception ex) {
				LoggingService.LogInternalError (ex);
			} finally {
				GuiDispatch (() => runCount--);
			}
		}

		public void ReportResult (ProgressMonitorStatusMessage progressMessage)
		{
			if (HasWarnings) {
				progressMonitor.ReportWarning (progressMessage.Warning);
			} else {
				progressMonitor.ReportSuccess (progressMessage.Success);
			}
		}