|
public static WriteToActivityLog ( |
||
| exception | ||
| Результат | void | |
internal static IEnumerable <Tuple <ProjectItem, AssemblyName> > GetAssemblyReferences(this MsBuildProject project)
{
foreach (ProjectItem referenceProjectItem in project.GetItems(ReferenceProjectItem))
{
AssemblyName assemblyName = null;
try
{
assemblyName = new AssemblyName(referenceProjectItem.EvaluatedInclude);
}
catch (Exception exception)
{
ExceptionHelper.WriteToActivityLog(exception);
// Swallow any exceptions we might get because of malformed assembly names
}
// We can't yield from within the try so we do it out here if everything was successful
if (assemblyName != null)
{
yield return(Tuple.Create(referenceProjectItem, assemblyName));
}
}
}
private bool CheckForMissingPackagesCore()
{
// this can happen during unit tests
if (_packageManagerFactory == null)
{
return(false);
}
try
{
IVsPackageManager packageManager = _packageManagerFactory.CreatePackageManager();
IPackageRepository localRepository = packageManager.LocalRepository;
var projectReferences = GetAllPackageReferences(packageManager);
return(projectReferences.Any(reference => !localRepository.Exists(reference.Id, reference.Version)));
}
catch (Exception exception)
{
// if an exception happens during the check, assume no missing packages and move on.
ExceptionHelper.WriteToActivityLog(exception);
return(false);
}
}
public void RestorePackages(Project project)
{
try
{
var solutionDirectory = _solutionManager.SolutionDirectory;
var nuGetProjectContext = new EmptyNuGetProjectContext();
// We simply use ThreadHelper.JoinableTaskFactory.Run instead of PumpingJTF.Run, unlike,
// VsPackageInstaller and VsPackageUninstaller. Because, no powershell scripts get executed
// as part of the operations performed below. Powershell scripts need to be executed on the
// pipeline execution thread and they might try to access DTE. Doing that under
// ThreadHelper.JoinableTaskFactory.Run will consistently result in a hang
NuGetUIThreadHelper.JoinableTaskFactory.Run(() =>
_restoreManager.RestoreMissingPackagesInSolutionAsync(solutionDirectory,
nuGetProjectContext,
CancellationToken.None));
}
catch (Exception ex)
{
ExceptionHelper.WriteToActivityLog(ex);
}
}
/// <summary>
/// Creates a .refresh file in bin directory of the IFileSystem that points to the assembly being installed.
/// This works around issues in DTE's AddReference method when dealing with GACed binaries.
/// </summary>
/// <param name="fileSystem">The project system the assembly is being referenced by.</param>
/// <param name="assemblyPath">The relative path to the assembly being added</param>
public static void CreateRefreshFile(this IFileSystem fileSystem, string assemblyPath)
{
string referenceName = Path.GetFileName(assemblyPath);
string refreshFilePath = Path.Combine("bin", referenceName + RefreshFileExtension);
if (!fileSystem.FileExists(refreshFilePath))
{
string projectPath = PathUtility.EnsureTrailingSlash(fileSystem.Root);
string relativeAssemblyPath = PathUtility.GetRelativePath(projectPath, assemblyPath);
try
{
using (var stream = relativeAssemblyPath.AsStream())
{
fileSystem.AddFile(refreshFilePath, stream);
}
}
catch (UnauthorizedAccessException exception)
{
// log IO permission error
ExceptionHelper.WriteToActivityLog(exception);
}
}
}
public void EnableCurrentSolutionForRestore(bool fromActivation)
{
if (!_solutionManager.IsSolutionOpen)
{
throw new InvalidOperationException(VsResources.SolutionNotAvailable);
}
if (fromActivation)
{
// if not in quiet mode, ask user for confirmation before proceeding
bool?result = MessageHelper.ShowQueryMessage(
VsResources.PackageRestoreConfirmation,
VsResources.DialogTitle,
showCancelButton: false);
if (result != true)
{
return;
}
}
Exception exception = null;
IVsThreadedWaitDialog2 waitDialog;
_waitDialogFactory.CreateInstance(out waitDialog);
try
{
waitDialog.StartWaitDialog(
VsResources.DialogTitle,
VsResources.PackageRestoreWaitMessage,
String.Empty,
varStatusBmpAnim: null,
szStatusBarText: null,
iDelayToShowDialog: 0,
fIsCancelable: false,
fShowMarqueeProgress: true);
if (fromActivation)
{
// only enable package restore consent if this is called as a result of user enabling package restore
SetPackageRestoreConsent();
}
EnablePackageRestore(fromActivation);
}
catch (Exception ex)
{
exception = ex;
ExceptionHelper.WriteToActivityLog(exception);
}
finally
{
int canceled;
waitDialog.EndWaitDialog(out canceled);
}
if (fromActivation)
{
if (exception != null)
{
// show error message
MessageHelper.ShowErrorMessage(
VsResources.PackageRestoreErrorMessage +
Environment.NewLine +
Environment.NewLine +
ExceptionUtility.Unwrap(exception).Message,
VsResources.DialogTitle);
}
else
{
// show success message
MessageHelper.ShowInfoMessage(
VsResources.PackageRestoreCompleted,
VsResources.DialogTitle);
}
}
}
public Task RestoreMissingPackages()
{
TaskScheduler uiScheduler;
try
{
uiScheduler = TaskScheduler.FromCurrentSynchronizationContext();
}
catch (InvalidOperationException)
{
// this exception occurs during unit tests
uiScheduler = TaskScheduler.Default;
}
Task task = Task.Factory.StartNew(() =>
{
IVsPackageManager packageManager = _packageManagerFactory.CreatePackageManagerWithAllPackageSources();
IPackageRepository localRepository = packageManager.LocalRepository;
var projectReferences = GetAllPackageReferences(packageManager);
foreach (var reference in projectReferences)
{
if (!localRepository.Exists(reference.Id, reference.Version))
{
// Resolve the package to install
IPackage package = PackageRepositoryHelper.ResolvePackage(
packageManager.SourceRepository,
packageManager.LocalRepository,
reference.Id,
reference.Version,
allowPrereleaseVersions: true);
// Resolve actions
var resolver = new ActionResolver()
{
Logger = packageManager.Logger,
DependencyVersion = packageManager.DependencyVersion,
IgnoreDependencies = true,
AllowPrereleaseVersions = true
};
resolver.AddOperation(PackageAction.Install, package, new NullProjectManager(packageManager));
var actions = resolver.ResolveActions();
// Execute actions
var actionExecutor = new ActionExecutor()
{
Logger = packageManager.Logger
};
actionExecutor.Execute(actions);
}
}
});
task.ContinueWith(originalTask =>
{
if (originalTask.IsFaulted)
{
ExceptionHelper.WriteToActivityLog(originalTask.Exception);
}
else
{
// we don't allow canceling
Debug.Assert(!originalTask.IsCanceled);
// after we're done with restoring packages, do the check again
CheckForMissingPackages();
}
}, uiScheduler);
return(task);
}
