public void RemovePackage (IPackageName package)
{
int index = packages.FindIndex (existingPackageName => existingPackageName.Id == package.Id);
if (index >= 0) {
packages.RemoveAt (index);
}
}
public Stream OpenPackageSourceFile(IPackageName package, string relativePath)
{
relativePath = relativePath.Replace('/', Path.DirectorySeparatorChar);
// Try to return the source file from its uncompressed location
var parts = new[] {
package.Id,
package.Version.ToString(),
"src",
relativePath
};
var stream = OpenFile(Path.Combine(parts));
if (stream != null)
{
return(stream);
}
// If the file wasn't found uncompressed look for it in symbol package zip file
var packagePath = GetNupkgPath(package);
if (!File.Exists(packagePath))
{
return(null);
}
var srcPath = Path.Combine("src", relativePath);
var packageFile = FastZipPackage.Open(packagePath, new byte[0]);
var file = packageFile.GetFiles().SingleOrDefault(f => f.Path.Equals(srcPath, StringComparison.InvariantCultureIgnoreCase));
return(file != null ? new PackageDisposingStream(packageFile, file.GetStream()) : null);
}
public string CreateSourceMappingIndex(IPackageName package, string symbolSourceUri, List <string> referencedSources, ISet <string> sourceFiles)
{
var version = package.Version;
var packageId = package.Id;
var sb = new StringBuilder();
sb.AppendLine("SRCSRV: ini ------------------------------------------------");
sb.AppendLine("VERSION=2");
sb.AppendLine("INDEXVERSION=2");
sb.AppendLine("VERCTRL=http");
sb.AppendFormat("DATETIME={0}" + Environment.NewLine, DateTime.UtcNow);
sb.AppendLine("SRCSRV: variables ------------------------------------------");
sb.AppendLine("SRCSRVVERCTRL=http");
sb.AppendFormat("SRCSRVTRG={0}/%var4%/%var2%/%var5%", symbolSourceUri);
sb.AppendLine("SRCSRVCMD=");
sb.AppendLine("SRCSRV: source files ---------------------------------------");
foreach (var source in referencedSources)
{
var relativePath = FindSourceFile(source, sourceFiles);
if (string.IsNullOrWhiteSpace(relativePath))
{
continue;
}
sb.AppendFormat("{0}*{1}*_*{2}*{3}" + Environment.NewLine, source, version, packageId, relativePath);
}
sb.AppendLine("SRCSRV: end ------------------------------------------------");
return(sb.ToString());
}
SemanticVersion GetUpdatedPackageVersion (IPackageName updatedPackage)
{
if (updatedPackage != null) {
return updatedPackage.Version;
}
return null;
}
public void DownloadPackage(IHttpClient downloadClient, IPackageName package, Stream targetStream)
{
if (downloadClient == null)
{
throw new ArgumentNullException("downloadClient");
}
if (targetStream == null)
{
throw new ArgumentNullException("targetStream");
}
// Get the operation display text
string operation = String.Format(CultureInfo.CurrentCulture, NuGetResources.DownloadProgressStatus, package.Id, package.Version);
CurrentDownloadPackageId = package.Id;
EventHandler<ProgressEventArgs> progressAvailableHandler = (sender, e) =>
{
OnPackageDownloadProgress(new ProgressEventArgs(operation, e.PercentComplete));
};
try
{
downloadClient.ProgressAvailable += progressAvailableHandler;
downloadClient.SendingRequest += OnSendingRequest;
downloadClient.DownloadData(targetStream);
}
finally
{
downloadClient.ProgressAvailable -= progressAvailableHandler;
downloadClient.SendingRequest -= OnSendingRequest;
CurrentDownloadPackageId = null;
}
}
public string CreateSourceMappingIndex(IPackageName package, string symbolSourceUri, List<string> referencedSources, ISet<string> sourceFiles)
{
var version = package.Version;
var packageId = package.Id;
var sb = new StringBuilder();
sb.AppendLine("SRCSRV: ini ------------------------------------------------");
sb.AppendLine("VERSION=2");
sb.AppendLine("INDEXVERSION=2");
sb.AppendLine("VERCTRL=NuGet");
sb.AppendFormat("DATETIME={0}" + Environment.NewLine, DateTime.UtcNow);
sb.AppendLine("SRCSRV: variables ------------------------------------------");
sb.AppendLine("SRCSRVVERCTRL=http");
sb.AppendFormat("NUGET={0}" + Environment.NewLine, symbolSourceUri);
sb.AppendLine("HTTP_EXTRACT_TARGET=%NUGET%/%var4%/%var2%/%var5%");
sb.AppendLine("SRCSRVTRG=%HTTP_EXTRACT_TARGET%");
sb.AppendLine("SRCSRVCMD=");
sb.AppendLine("SRCSRV: source files ---------------------------------------");
foreach (var source in referencedSources)
{
var relativePath = FindSourceFile(source, sourceFiles);
if (string.IsNullOrWhiteSpace(relativePath)) continue;
sb.AppendFormat("{0}*{1}*_*{2}*{3}" + Environment.NewLine, source, version, packageId, relativePath);
}
sb.AppendLine("SRCSRV: end ------------------------------------------------");
return sb.ToString();
}
SemanticVersion GetUpdatedPackageVersion(IPackageName updatedPackage)
{
if (updatedPackage != null)
{
return(updatedPackage.Version);
}
return(null);
}
public void RemovePackage(IPackageName package)
{
int index = packages.FindIndex(existingPackageName => existingPackageName.Id == package.Id);
if (index >= 0)
{
packages.RemoveAt(index);
}
}
private IEnumerable <PackageIdentity> CreatePackageIdentityFromNupkgPath()
{
PackageIdentity identity = null;
IPackage package = null;
try
{
// Example: install-package2 https://az320820.vo.msecnd.net/packages/microsoft.aspnet.mvc.4.0.20505.nupkg
if (_isHttp)
{
PackageIdentity packageIdentity = ParsePackageIdentityFromHttpSource(Id);
IPackageCacheRepository packageCache = this.Projects.FirstOrDefault().TryGetFeature <IPackageCacheRepository>();
IPackageName packageName = CoreConverters.SafeToPackageName(packageIdentity);
SemanticVersion packageSemVer = CoreConverters.SafeToSemanticVersion(packageIdentity.Version);
Uri downloadUri = new Uri(Id);
PackageDownloader downloader = new PackageDownloader();
// Try to download the package through the cache.
bool success = packageCache.InvokeOnPackage(
packageIdentity.Id,
packageSemVer,
(targetStream) =>
downloader.DownloadPackage(
new HttpClient(downloadUri),
packageName,
targetStream));
if (success)
{
// Try to get it from the cache again
package = packageCache.FindPackage(packageIdentity.Id, packageSemVer);
}
}
else
{
// Example: install-package2 c:\temp\packages\jQuery.1.10.2.nupkg
string fullPath = Path.GetFullPath(Id);
package = new OptimizedZipPackage(fullPath);
}
if (package != null)
{
Id = package.Id;
Version = package.Version.ToString();
identity = new PackageIdentity(Id, NuGetVersion.Parse(Version));
}
}
catch (Exception ex)
{
Log(MessageLevel.Error, Resources.Cmdlet_FailToParsePackages, Id, ex.Message);
}
return(new List <PackageIdentity>()
{
identity
});
}
public Task RemoveSymbolsAsync(IPackageName package)
{
var nupkgPath = GetNupkgPath(package);
if (File.Exists(nupkgPath))
{
File.Delete(nupkgPath);
}
return Task.FromResult(true);
}
public void RemoveUpdatedPackages(IEnumerable <PackageReference> packageReferences)
{
foreach (PackageReference packageReference in packageReferences)
{
IPackageName package = packages.Find(existingPackageName => existingPackageName.Id == packageReference.Id);
if ((package != null) && (package.Version <= packageReference.Version))
{
packages.Remove(package);
}
}
}
public Task RemoveSymbolsAsync(IPackageName package)
{
var nupkgPath = GetNupkgPath(package);
if (File.Exists(nupkgPath))
{
File.Delete(nupkgPath);
}
return(Task.FromResult(true));
}
public Task RemoveSymbolsAsync(IPackageName package)
{
var path = GetPackageSymbolPath(package);
if (Directory.Exists(path))
{
Directory.Delete(path, recursive: true);
}
return Task.FromResult(true);
}
protected string GetPackageFilePath(IPackageName package)
{
var lucenePackage = package as LucenePackage ?? FindLucenePackage(package.Id, package.Version);
if (lucenePackage != null && !string.IsNullOrEmpty(lucenePackage.Path))
{
return(lucenePackage.Path);
}
return(base.GetPackageFilePath(package.Id, package.Version));
}
public Stream OpenPackageSourceFile(IPackageName package, string relativePath)
{
var parts = new[]
{
package.Id,
package.Version.ToString(),
"src",
relativePath
};
return OpenFile(Path.Combine(parts));
}
public PackageReferenceNode (
PackageReference packageReference,
bool installed,
bool pending = false,
IPackageName updatedPackage = null)
{
PackageReference = packageReference;
Installed = installed;
IsInstallPending = pending;
UpdatedVersion = GetUpdatedPackageVersion (updatedPackage);
IsReinstallNeeded = packageReference.RequireReinstallation;
}
public PackageReferenceNode(
PackageReference packageReference,
bool installed,
bool pending = false,
IPackageName updatedPackage = null)
{
PackageReference = packageReference;
Installed = installed;
IsInstallPending = pending;
UpdatedVersion = GetUpdatedPackageVersion(updatedPackage);
IsReinstallNeeded = packageReference.RequireReinstallation;
}
public void GetUpdatedPackages_OnePackageReferencedAndUpdateAvailable_InstalledPackageNameUsedToCheckIfSourceRepositoryHasAnyUpdates()
{
AddPackageReference("Test", "1.0");
AddPackageToSourceRepository("Test", "1.1");
CreateUpdatedPackages();
updatedPackages.GetUpdatedPackages();
IPackageName packageChecked = packageNamesUsedWhenCheckingForUpdates.FirstOrDefault();
Assert.AreSame("Test", packageChecked.Id);
Assert.AreSame("1.0", packageChecked.Version.ToString());
Assert.AreEqual(1, packageNamesUsedWhenCheckingForUpdates.Count);
}
public void GetUpdatedPackages_JQueryPackageInstalledTwiceWithDifferentVersionsAndNewerVersionsFirst_OnlyOlderJQueryPackageUsedToDetermineUpdatedPackages()
{
AddPackageReference("jquery", "1.7");
AddPackageReference("jquery", "1.6");
AddPackageToSourceRepository("jquery", "2.1");
CreateUpdatedPackages();
updatedPackages.GetUpdatedPackages();
IPackageName packageChecked = packageNamesUsedWhenCheckingForUpdates.FirstOrDefault();
Assert.AreSame("jquery", packageChecked.Id);
Assert.AreSame("1.6", packageChecked.Version.ToString());
Assert.AreEqual(1, packageNamesUsedWhenCheckingForUpdates.Count);
}
private Result<byte[]> DownloadPackageTask(IPackageName package)
{
var dataServicePackage = package as DataServicePackage;
if (dataServicePackage == null)
{
Log.Information("Package {id} is an unrecognised type: {type}", package.Id, package.GetType());
return Result<byte[]>.Failed($"Error processing package {package.Id}");
}
using (var ms = new MemoryStream())
{
_repository.PackageDownloader.DownloadPackage(dataServicePackage.DownloadUrl, dataServicePackage, ms);
return ms.ToArray();
}
}
private static void AddToCache(IPackageName package, MemoryCache memoryCache)
{
var cachedObject = memoryCache[package.Id];
if (cachedObject != null)
{
if (package.Version > ((IPackage)cachedObject).Version)
{
memoryCache[package.Id] = package;
}
}
else
{
memoryCache[package.Id] = package;
}
}
public async Task<Result<byte[]>> DownloadPackage(IPackageName package)
{
var type = typeof(TestPackageRepositoryWrapper);
var resourceName = $"{type.Namespace}.{package.Id}.{package.Version}.nupkg";
using (var s = type.Assembly.GetManifestResourceStream(resourceName))
{
if(s == null)
return Result<byte[]>.Failed($"Package {package.Id} {package.Version} not found");
using (var ms = new MemoryStream())
{
await s.CopyToAsync(ms);
return ms.ToArray();
}
}
}
public Task RemoveSymbolsAsync(IPackageName package)
{
var nupkgPath = GetNupkgPath(package);
if (File.Exists(nupkgPath))
{
File.Delete(nupkgPath);
}
var folderPath = GetUnzippedPackagePath(package);
if (Directory.Exists(folderPath))
{
Directory.Delete(folderPath, recursive: true);
}
return Task.FromResult(true);
}
public Stream OpenPackageSourceFile(IPackageName package, string relativePath)
{
relativePath = relativePath.Replace('/', Path.DirectorySeparatorChar);
var packagePath = GetNupkgPath(package);
if (!File.Exists(packagePath))
{
return(null);
}
var srcPath = Path.Combine("src", relativePath);
var packageFile = FastZipPackage.Open(packagePath, new byte[0]);
var file = packageFile.GetFiles().SingleOrDefault(f => f.Path.Equals(srcPath, StringComparison.InvariantCultureIgnoreCase));
return(file != null ? new PackageDisposingStream(packageFile, file.GetStream()) : null);
}
internal static int LaunchGallery(
PackageConfiguration packageConfiguration,
string editorRepositoryPath,
string editorPath,
IPackageName editorPackageName)
{
EnableVisualStyles();
using (var galleryDialog = new GalleryDialog(editorRepositoryPath))
using (var monitor = new PackageConfigurationUpdater(packageConfiguration, galleryDialog.PackageManager, editorPath, editorPackageName))
{
if (galleryDialog.ShowDialog() == DialogResult.OK)
{
AppResult.SetResult(galleryDialog.InstallPath);
}
return(Program.NormalExitCode);
}
}
public Task RemoveSymbolsAsync(IPackageName package)
{
var nupkgPath = GetNupkgPath(package);
if (File.Exists(nupkgPath))
{
File.Delete(nupkgPath);
}
var folderPath = GetUnzippedPackagePath(package);
if (Directory.Exists(folderPath))
{
Directory.Delete(folderPath, recursive: true);
}
return(Task.FromResult(true));
}
internal static int LaunchPackageManager(
PackageConfiguration packageConfiguration,
string editorRepositoryPath,
string editorPath,
IPackageName editorPackageName,
bool updatePackages)
{
EnableVisualStyles();
using (var packageManagerDialog = new PackageManagerDialog(editorRepositoryPath))
using (var monitor = new PackageConfigurationUpdater(packageConfiguration, packageManagerDialog.PackageManager, editorPath, editorPackageName))
{
packageManagerDialog.DefaultTab = updatePackages ? PackageManagerTab.Updates : PackageManagerTab.Online;
if (packageManagerDialog.ShowDialog() == DialogResult.OK)
{
AppResult.SetResult(packageManagerDialog.InstallPath);
}
return(Program.NormalExitCode);
}
}
public void DownloadPackage(IHttpClient downloadClient, IPackageName package, Stream targetStream)
{
if (downloadClient == null)
{
throw new ArgumentNullException("downloadClient");
}
if (targetStream == null)
{
throw new ArgumentNullException("targetStream");
}
// Get the operation display text
string operation = String.Format(CultureInfo.CurrentCulture, NuGetResources.DownloadProgressStatus, package.Id, package.Version);
CurrentDownloadPackageId = package.Id;
CurrentDownloadPackageVersion = package.Version.ToString();
EventHandler <ProgressEventArgs> progressAvailableHandler = (sender, e) =>
{
OnPackageDownloadProgress(new ProgressEventArgs(operation, e.PercentComplete));
};
try
{
downloadClient.ProgressAvailable += progressAvailableHandler;
downloadClient.SendingRequest += OnSendingRequest;
downloadClient.DownloadData(targetStream);
}
finally
{
downloadClient.ProgressAvailable -= progressAvailableHandler;
downloadClient.SendingRequest -= OnSendingRequest;
CurrentDownloadPackageId = null;
}
}
/// <summary>
/// Creates a temp directory that gets deleted when the returned object is disposed
/// </summary>
/// <param name="package"></param>
/// <returns>An IDisposable that deletes the folder when disposed</returns>
protected TempFolder CreateTempFolderForPackage(IPackageName package)
{
return(new TempFolder(GetTempFolderPathForPackage(package)));
}
public bool AreSymbolsPresentFor(IPackageName package)
{
var path = GetPackageSymbolPath(package);
return Directory.Exists(path);
}
public bool AreSymbolsPresentFor(IPackageName package)
{
return File.Exists(GetNupkgPath(package));
}
public virtual string GetNupkgPath(IPackageName package)
{
return(Path.Combine(SymbolsPath, package.Id, package.Id + "." + package.Version + ".symbols.nupkg"));
}
public virtual string GetNupkgPath(IPackageName package)
{
return Path.Combine(SymbolsPath, package.Id, package.Id + "." + package.Version + ".symbols.nupkg");
}
public Stream OpenPackageSourceFile(IPackageName package, string relativePath)
{
relativePath = relativePath.Replace('/', Path.DirectorySeparatorChar);
var packagePath = GetNupkgPath(package);
if (!File.Exists(packagePath)) return null;
var srcPath = Path.Combine("src", relativePath);
var packageFile = FastZipPackage.Open(packagePath, new byte[0]);
var file = packageFile.GetFiles().SingleOrDefault(f => f.Path.Equals(srcPath, StringComparison.InvariantCultureIgnoreCase));
return file != null ? new PackageDisposingStream(packageFile, file.GetStream()) : null;
}
/// <summary>
/// Uses symstore.exe to copy a PDB symbol file to a location
/// where debuggers will attempt to load it from.
/// </summary>
public Task IndexSymbolFile(IPackageName package, string symbolFile)
{
return ExecuteToolAsync("symstore", string.Format(" add /f \"{0}\" /s \"{1}\" /t {2} /v {3}", symbolFile, SymbolPath, package.Id, package.Version));
}
public bool AreSymbolsPresentFor(IPackageName package)
{
return(File.Exists(GetNupkgPath(package)));
}
public static bool Exists(this IPackageRepository repository, IPackageName package) => repository.Exists(package.Id, package.Version);
internal bool <.cctor> b__7_0(IPackageName x, IPackageName y) => (x.Id.Equals(y.Id, StringComparison.OrdinalIgnoreCase) && x.Version.Equals(y.Version));
public PackageOverwriteDeniedException(IPackageName packageName)
:base(string.Format("Package '{0}' version '{1}' already exists.", packageName.Id, packageName.Version))
{
this.packageName = packageName;
}
public bool AreSymbolsPresentFor(IPackageName package)
{
return File.Exists(GetNupkgPath(package))
|| Directory.Exists(GetUnzippedPackagePath(package));
}
public Stream OpenPackageSourceFile(IPackageName package, string relativePath)
{
relativePath = relativePath.Replace('/', Path.DirectorySeparatorChar);
// Try to return the source file from its uncompressed location
var parts = new[] {
package.Id,
package.Version.ToString(),
"src",
relativePath
};
var stream = OpenFile(Path.Combine(parts));
if (stream != null) return stream;
// If the file wasn't found uncompressed look for it in symbol package zip file
var packagePath = GetNupkgPath(package);
if (!File.Exists(packagePath)) return null;
var srcPath = Path.Combine("src", relativePath);
var packageFile = new ZipPackage(packagePath);
var file = packageFile.GetFiles().SingleOrDefault(f => f.Path.Equals(srcPath, StringComparison.InvariantCultureIgnoreCase));
return file != null ? file.GetStream() : null;
}
/// <summary>
/// Returns the path a package should be decompressed to
/// </summary>
/// <param name="package"></param>
/// <returns></returns>
public virtual string GetUnzippedPackagePath(IPackageName package)
{
return Path.Combine(SymbolsPath, package.Id, package.Version.ToString());
}
public Task<Result<byte[]>> DownloadPackage(IPackageName package)
{
return Task.Run(() => DownloadPackageTask(package));
}
internal static IPackage GetEditorPackage(
PackageConfiguration packageConfiguration,
string editorRepositoryPath,
string editorPath,
IPackageName editorPackageName,
bool showDialog)
{
const string OldExtension = ".old";
var backupExePath = editorPath + OldExtension;
if (File.Exists(backupExePath))
{
try { File.Delete(backupExePath); }
catch { } // best effort
}
var packageManager = CreatePackageManager(editorRepositoryPath);
if (!showDialog)
{
packageManager.Logger = ConsoleLogger.Default;
packageManager.RequiringLicenseAcceptance += (sender, e) => e.LicenseAccepted = true;
}
var missingPackages = GetMissingPackages(packageConfiguration.Packages, packageManager.LocalRepository).ToList();
if (missingPackages.Count > 0)
{
if (showDialog)
{
EnableVisualStyles();
}
using (var monitor = new PackageConfigurationUpdater(packageConfiguration, packageManager, editorPath, editorPackageName))
{
Task RestoreMissingPackages()
{
var restoreTasks = missingPackages.Select(package => packageManager.StartRestorePackage(package.Id, ParseVersion(package.Version)));
return(Task.Factory.ContinueWhenAll(restoreTasks.ToArray(), operations =>
{
foreach (var task in operations)
{
if (task.IsFaulted || task.IsCanceled)
{
continue;
}
var package = task.Result;
if (packageManager.LocalRepository.Exists(package.Id))
{
packageManager.UpdatePackage(
package,
updateDependencies: false,
allowPrereleaseVersions: true);
}
else
{
packageManager.InstallPackage(
package,
ignoreDependencies: true,
allowPrereleaseVersions: true,
ignoreWalkInfo: true);
}
}
Task.WaitAll(operations);
}));
};
if (!showDialog)
{
RestoreMissingPackages().Wait();
}
else
{
PackageHelper.RunPackageOperation(packageManager, RestoreMissingPackages);
}
}
}
var editorPackage = packageManager.LocalRepository.FindPackage(editorPackageName.Id);
if (editorPackage == null || editorPackage.Version < editorPackageName.Version)
{
if (showDialog)
{
EnableVisualStyles();
}
using (var monitor = new PackageConfigurationUpdater(packageConfiguration, packageManager, editorPath, editorPackageName))
{
Task RestoreEditorPackage()
{
return(packageManager
.StartInstallPackage(editorPackageName.Id, editorPackageName.Version)
.ContinueWith(task => editorPackage = task.Result));
};
if (!showDialog)
{
RestoreEditorPackage().Wait();
}
else
{
PackageHelper.RunPackageOperation(
packageManager,
RestoreEditorPackage,
operationLabel: editorPackage != null ? "Updating..." : null);
}
if (editorPackage == null)
{
var assemblyName = Assembly.GetEntryAssembly().GetName();
var errorMessage = editorPackage == null ? Resources.InstallEditorPackageError : Resources.UpdateEditorPackageError;
if (!showDialog)
{
ConsoleLogger.Default.Log(MessageLevel.Error, errorMessage);
}
else
{
MessageBox.Show(errorMessage, assemblyName.Name, MessageBoxButtons.OK, MessageBoxIcon.Error);
}
return(null);
}
}
}
return(editorPackage);
}
public async Task ProcessSymbolFileAsync(IPackageName package, string symbolFilePath, string symbolSourceUri)
{
var referencedSources = (await SymbolTools.GetSources(symbolFilePath)).ToList();
var srcDir = Path.Combine(GetPackageSymbolPath(package), "src");
var sourceFiles = new HashSet<string>(Directory.EnumerateFiles(srcDir, "*", SearchOption.AllDirectories)
.Select(s => s.Substring(srcDir.Length+1)));
if (referencedSources.Any() && sourceFiles.Any())
{
var sourceMapper = new SymbolSourceMapper();
var mappings = sourceMapper.CreateSourceMappingIndex(package, symbolSourceUri, referencedSources, sourceFiles);
await SymbolTools.MapSourcesAsync(symbolFilePath, mappings);
await SymbolTools.IndexSymbolFile(package, symbolFilePath);
}
}
public async Task ProcessSymbolsAsync(IPackageName package, string symbolSourceUri)
{
var packageSymbolsDir = Path.Combine(GetPackageSymbolPath(package), "lib");
var files = Directory.EnumerateFiles(packageSymbolsDir, "*.pdb", SearchOption.AllDirectories);
foreach (var file in files)
{
await ProcessSymbolFileAsync(package, file, symbolSourceUri);
}
}
public static bool IsReleaseVersion(this IPackageName packageMetadata)
{
return(String.IsNullOrEmpty(packageMetadata.Version.SpecialVersion));
}
public string GetPackageSymbolPath(IPackageName package)
{
return Path.Combine(SymbolsPath, package.Id, package.Version.ToString());
}
protected virtual string GetTempFolderPathForPackage(IPackageName package)
{
return(Path.Combine(SymbolsPath, package.Id + "-" + package.Version + ".tmp"));
}
/// <summary>
/// Uses symstore.exe to copy a PDB symbol file to a location
/// where debuggers will attempt to load it from.
/// </summary>
public Task IndexSymbolFile(IPackageName package, string symbolFile)
{
return(ExecuteToolAsync("symstore", string.Format(" add /f \"{0}\" /s \"{1}\" /t {2} /v {3}", symbolFile, SymbolPath, package.Id, package.Version)));
}
private void AddToCache(IPackageName package)
{
var memoryCache = Cache;
AddToCache(package, memoryCache);
}
public static string GetFullName(this IPackageName package)
{
return(package.Id + " " + package.Version);
}
private static string GetPackageKey(IPackageName package)
{
return(GetPackageKey(package.Id, package.Version.ToString()));
}
protected virtual string GetTempFolderPathForPackage(IPackageName package)
{
return Path.Combine(SymbolsPath, package.Id + "-" + package.Version + ".tmp");
}
public PackageOverwriteDeniedException(IPackageName packageName)
: base(string.Format("Package '{0}' version '{1}' already exists.", packageName.Id, packageName.Version))
{
this.packageName = packageName;
}
protected string GetPackageFilePath(IPackageName package)
{
var lucenePackage = package as LucenePackage ?? FindLucenePackage(package.Id, package.Version);
if (lucenePackage != null && !string.IsNullOrEmpty(lucenePackage.Path))
{
return lucenePackage.Path;
}
return base.GetPackageFilePath(package.Id, package.Version);
}
/// <summary>
/// Creates a temp directory that gets deleted when the returned object is disposed
/// </summary>
/// <param name="package"></param>
/// <returns>An IDisposable that deletes the folder when disposed</returns>
protected TempFolder CreateTempFolderForPackage(IPackageName package)
{
return new TempFolder(GetTempFolderPathForPackage(package));
}
