private async Task DetectVersionWhenNeccessary()
{
await _lock.WaitAsync();
try
{
if (_repo != null)
{
return;
}
bool r = await IsV3Async(_source);
if (r)
{
_repo = new V3SourceRepository(_source, _host);
return;
}
r = await IsV2Async(_source);
if (r)
{
_repo = new NuGet.Client.Interop.V2SourceRepository(
_source, _v2RepoFactory.CreateRepository(_source.Url), _host);
return;
}
throw new InvalidOperationException(
String.Format("source {0} is not available", _source.Url));
}
finally
{
_lock.Release();
}
}
public override async Task<Tuple<bool, INuGetResource>> TryCreate(SourceRepository source, CancellationToken cancellationToken)
{
V3TotalsStatsResource totalsStatsResource = null;
var serviceIndex = await source.GetResourceAsync<ServiceIndexResourceV3>(cancellationToken);
if (serviceIndex != null)
{
// TODO: fix this for resource templates
throw new NotImplementedException();
//ResourceSelector resourceSelector = new ResourceSelector(source);
//IList<Uri> resourceUrls = serviceIndex[ServiceTypes.TotalStats];
//Uri resourceUri = await resourceSelector.DetermineResourceUrlAsync(resourceUrls, cancellationToken);
//var messageHandlerResource = await source.GetResourceAsync<HttpHandlerResource>(cancellationToken);
//DataClient client = new DataClient(messageHandlerResource.MessageHandler);
//// construct a new resource
//totalsStatsResource = new V3TotalsStatsResource(client, resourceUri);
}
return new Tuple<bool, INuGetResource>(totalsStatsResource != null, totalsStatsResource);
}
/// <summary>
/// Sets <param name="targetPackageStream"></param> for a given <param name="packageIdentity"></param>
/// from the given <param name="sourceRepository"></param>. If successfully set, returns true. Otherwise, false
/// </summary>
public static async Task<bool> GetPackageStream(SourceRepository sourceRepository, PackageIdentity packageIdentity, Stream targetPackageStream, CancellationToken token)
{
// TODO: Tie up machine cache with CacheClient?!
try
{
token.ThrowIfCancellationRequested();
// Step-1 : Get the download stream for packageIdentity
Stream downloadStream = await GetDownloadStream(sourceRepository, packageIdentity, token);
if(downloadStream == null)
{
return false;
}
token.ThrowIfCancellationRequested();
// Step-2: Copy download stream to targetPackageStream if it is not null
await downloadStream.CopyToAsync(targetPackageStream);
return true;
}
catch (Exception)
{
return false;
}
}
void CreateAction ()
{
project = new FakeDotNetProject (@"d:\projects\MyProject\MyProject.csproj");
solutionManager = new FakeSolutionManager ();
nugetProject = new FakeNuGetProject (project);
solutionManager.NuGetProjects[project] = nugetProject;
var metadataResourceProvider = new FakePackageMetadataResourceProvider ();
packageMetadataResource = metadataResourceProvider.PackageMetadataResource;
var source = new PackageSource ("http://test.com");
var providers = new INuGetResourceProvider[] {
metadataResourceProvider
};
var sourceRepository = new SourceRepository (source, providers);
primaryRepositories = new [] {
sourceRepository
}.ToList ();
solutionManager.SourceRepositoryProvider.Repositories.AddRange (primaryRepositories);
action = new TestableUpdateAllNuGetPackagesInProjectAction (
solutionManager,
project);
packageManager = action.PackageManager;
packageManagementEvents = action.PackageManagementEvents;
fileRemover = action.FileRemover;
restoreManager = action.RestoreManager;
}
void CreateAction (
string packageId = "Test",
string version = "2.1")
{
project = new FakeDotNetProject (@"d:\projects\MyProject\MyProject.csproj");
solutionManager = new FakeSolutionManager ();
nugetProject = new FakeNuGetProject (project);
solutionManager.NuGetProjects[project] = nugetProject;
var metadataResourceProvider = new FakePackageMetadataResourceProvider ();
packageMetadataResource = metadataResourceProvider.PackageMetadataResource;
var source = new PackageSource ("http://test.com");
var providers = new INuGetResourceProvider[] {
metadataResourceProvider
};
var sourceRepository = new SourceRepository (source, providers);
primaryRepositories = new [] {
sourceRepository
}.ToList ();
action = new TestableInstallNuGetPackageAction (
primaryRepositories,
solutionManager,
project);
packageManager = action.PackageManager;
packageManagementEvents = action.PackageManagementEvents;
fileRemover = action.FileRemover;
action.PackageId = packageId;
action.Version = new NuGetVersion (version);
}
public MultiSourcePackageMetadataProvider(
IEnumerable<SourceRepository> sourceRepositories,
SourceRepository optionalLocalRepository,
IEnumerable<SourceRepository> optionalGlobalLocalRepositories,
NuGetProject[] projects,
bool isSolution,
Common.ILogger logger)
{
if (sourceRepositories == null)
{
throw new ArgumentNullException(nameof(sourceRepositories));
}
if (projects == null)
{
throw new ArgumentNullException(nameof(projects));
}
_sourceRepositories = sourceRepositories;
_localRepository = optionalLocalRepository;
_globalLocalRepositories = optionalGlobalLocalRepositories;
_projects = projects;
_isSolution = isSolution;
if (logger == null)
{
throw new ArgumentNullException(nameof(logger));
}
_logger = logger;
}
public async Task ResolveVersion(SourceRepository localRepository,
IReadOnlyList<SourceRepository> remoteRepositories, bool updatePackages, ILogger logger)
{
string versionRangeString = _versionRange == null ? string.Empty : " " + _versionRange;
Trace.Verbose($"Resolving package version for {_packageId}{versionRangeString} (with dependencies)");
IReadOnlyList<SourceRepository> sourceRepositories = GetSourceRepositories(remoteRepositories);
NuGetVersion versionMatch = null;
if (!_getLatest && !updatePackages)
{
// Get the latest matching version in the local repository
versionMatch = await GetLatestMatchingVersion(localRepository, logger);
}
if (versionMatch != null)
{
Trace.Verbose($"Package {_packageId}{versionRangeString} is satisfied by version {versionMatch.Version}");
}
else
{
// The package either wasn't installed locally, the local version didn't match, or we requested a package update
// Get the latest remote version, but only if we actually have remote repositories
if (sourceRepositories != null && sourceRepositories.Count > 0)
{
versionMatch = await GetLatestMatchingVersion(sourceRepositories, logger);
}
if (versionMatch == null)
{
Trace.Verbose($"Package {_packageId}{versionRangeString} was not found on any remote source repositories");
}
}
_versionMatch = versionMatch;
}
/// <summary>
/// Get all versions for a specific package Id.
/// </summary>
/// <param name="sourceRepository"></param>
/// <param name="packageId"></param>
/// <param name="project"></param>
/// <param name="includePrerelease"></param>
/// <returns></returns>
public static IEnumerable<NuGetVersion> GetAllVersionsForPackageId(SourceRepository sourceRepository, string packageId, NuGetProject project, bool includePrerelease)
{
IEnumerable<string> targetFrameworks = GetProjectTargetFrameworks(project);
SearchFilter searchfilter = new SearchFilter();
searchfilter.IncludePrerelease = includePrerelease;
searchfilter.SupportedFrameworks = targetFrameworks;
searchfilter.IncludeDelisted = false;
PSSearchResource resource = sourceRepository.GetResource<PSSearchResource>();
PSSearchMetadata result = null;
IEnumerable<NuGetVersion> allVersions = Enumerable.Empty<NuGetVersion>();
try
{
Task<IEnumerable<PSSearchMetadata>> task = resource.Search(packageId, searchfilter, 0, 30, CancellationToken.None);
result = task.Result
.Where(p => string.Equals(p.Identity.Id, packageId, StringComparison.OrdinalIgnoreCase))
.FirstOrDefault();
allVersions = result.Versions;
}
catch (Exception)
{
if (result == null || !allVersions.Any())
{
throw new InvalidOperationException(
String.Format(CultureInfo.CurrentCulture,
Resources.UnknownPackage, packageId));
}
}
return result.Versions;
}
/// <summary>
/// Resolve package from online and local repository
/// Used for Install-Package and Update-Package command to verify the specified package version exists in the repo.
/// </summary>
/// <param name="sourceRepository"></param>
/// <param name="localRepository"></param>
/// <param name="identity"></param>
/// <param name="allowPrereleaseVersions"></param>
/// <returns></returns>
public static PackageIdentity ResolvePackage(SourceRepository sourceRepository, IPackageRepository localRepository,
PackageIdentity identity, bool allowPrereleaseVersions)
{
string packageId = identity.Id;
NuGetVersion nVersion = identity.Version;
string version = identity.Version.ToNormalizedString();
if (String.IsNullOrEmpty(identity.Id))
{
throw new ArgumentException(CommonResources.Argument_Cannot_Be_Null_Or_Empty, "packageId");
}
PackageIdentity resolvedIdentity = null;
// If we're looking for an exact version of a package then try local first
if (version != null)
{
SemanticVersion sVersion = new SemanticVersion(version);
IPackage package = localRepository.FindPackage(packageId, sVersion, allowPrereleaseVersions, allowUnlisted: false);
if (package != null)
{
resolvedIdentity = new PackageIdentity(packageId, NuGetVersion.Parse(package.Version.ToString()));
}
}
if (resolvedIdentity == null)
{
if (nVersion == null)
{
throw new InvalidOperationException(
String.Format(CultureInfo.CurrentCulture,
NuGetResources.UnknownPackageSpecificVersion, packageId, version));
}
else
{
Task<JObject> task = sourceRepository.GetPackageMetadata(packageId, nVersion);
JObject package = task.Result;
if (package == null)
{
if (version != null)
{
throw new InvalidOperationException(
String.Format(CultureInfo.CurrentCulture,
NuGetResources.UnknownPackageSpecificVersion, packageId, version));
}
throw new InvalidOperationException(
String.Format(CultureInfo.CurrentCulture,
NuGetResources.UnknownPackage, packageId));
}
else
{
resolvedIdentity = new PackageIdentity(packageId, nVersion);
}
}
}
return resolvedIdentity;
}
public SourceRepositoryDependencyProvider(
SourceRepository sourceRepository,
ILogger logger,
bool noCache)
{
_sourceRepository = sourceRepository;
_logger = logger;
_noCache = noCache;
}
public static NuGetProjectAction CreateInstallProjectAction(PackageIdentity packageIdentity, SourceRepository sourceRepository)
{
if(sourceRepository == null)
{
throw new ArgumentNullException("sourceRepository");
}
return new NuGetProjectAction(packageIdentity, NuGetProjectActionType.Install, sourceRepository);
}
public ActionResolver(
SourceRepository source,
SourceRepository dependencyResolutionSource,
ResolutionContext context)
{
_source = source;
_dependencyResolver = new DependencyResolverFromSourceRepo(dependencyResolutionSource);
_context = context;
}
public override void ValidateConnection(SourceRepository repo)
{
if (repo != null)
{
if (string.IsNullOrEmpty(repo.RemoteUrl))
this.ExecuteGitCommand(repo, "log -n 1"); // show commit log, limit to 1 commit
else
this.ExecuteGitCommand(repo, "ls-remote --heads origin"); // list remote branches
}
}
public PackageAction(PackageActionType actionType, PackageIdentity packageName, JObject package, InstallationTarget target, SourceRepository source, PackageIdentity dependentPackage)
{
ActionType = actionType;
PackageIdentity = packageName;
Package = package;
Target = target;
Source = source;
DependentPackage = dependentPackage;
IsUpdate = false;
}
public override async Task<Tuple<bool, INuGetResource>> TryCreate(SourceRepository source, CancellationToken token)
{
PSSearchResource resource = null;
UISearchResource uiSearchResource = await source.GetResourceAsync<UISearchResource>(token);
if (uiSearchResource != null)
{
resource = new PowerShellSearchResourceV2(uiSearchResource);
}
return new Tuple<bool, INuGetResource>(resource != null, resource);
}
protected async Task<V2Resource> GetRepository(SourceRepository source, CancellationToken token)
{
var repositoryResource = await source.GetResourceAsync<PackageRepositoryResourceV2>(token);
if (repositoryResource != null && repositoryResource.V2Client != null)
{
return repositoryResource;
}
return null;
}
private NuGetProjectAction(PackageIdentity packageIdentity, NuGetProjectActionType nuGetProjectActionType, SourceRepository sourceRepository = null)
{
if (packageIdentity == null)
{
throw new ArgumentNullException("packageIdentity");
}
PackageIdentity = packageIdentity;
NuGetProjectActionType = nuGetProjectActionType;
SourceRepository = sourceRepository;
}
private static async Task<Stream> GetDownloadStream(SourceRepository sourceRepository, PackageIdentity packageIdentity, CancellationToken token)
{
Stream downloadStream = null;
DownloadResource downloadResource = await sourceRepository.GetResourceAsync<DownloadResource>(token);
if(downloadResource != null)
{
downloadStream = await downloadResource.GetStream(packageIdentity, token);
return downloadStream;
}
return null;
}
public override async Task<Tuple<bool, INuGetResource>> TryCreate(SourceRepository source, CancellationToken token)
{
DependencyInfoResource DependencyInfoResourceV2 = null;
var v2repo = await GetRepository(source, token);
if (v2repo != null)
{
DependencyInfoResourceV2 = new DependencyInfoResourceV2(v2repo, source);
}
return Tuple.Create<bool, INuGetResource>(DependencyInfoResourceV2 != null, DependencyInfoResourceV2);
}
public override async Task<Tuple<bool, INuGetResource>> TryCreate(SourceRepository source, CancellationToken token)
{
HttpHandlerResourceV3 curResource = null;
#if !DNXCORE50
// Everyone gets a dataclient
var HttpHandler = TryGetCredentialAndProxy(source.PackageSource) ?? DataClient.DefaultHandler;
curResource = new HttpHandlerResourceV3(HttpHandler);
#endif
return new Tuple<bool, INuGetResource>(curResource != null, curResource);
}
private void Init()
{
_repositories.Clear();
foreach (var source in _packageSourceProvider.LoadPackageSources())
{
if (source.IsEnabled)
{
var sourceRepo = new SourceRepository(source, _resourceProviders);
_repositories.Add(sourceRepo);
}
}
}
public override async Task<Tuple<bool, INuGetResource>> TryCreate(SourceRepository source, CancellationToken token)
{
SimpleSearchResourceV2 resource = null;
var v2repo = await GetRepository(source, token);
if (v2repo != null)
{
resource = new SimpleSearchResourceV2(v2repo);
}
return new Tuple<bool, INuGetResource>(resource != null, resource);
}
public override async Task<Tuple<bool, INuGetResource>> TryCreate(SourceRepository source, CancellationToken token)
{
SimpleSearchResourceV3 curResource = null;
var rawSearch = await source.GetResourceAsync<RawSearchResourceV3>(token);
if (rawSearch != null && rawSearch is RawSearchResourceV3)
{
curResource = new SimpleSearchResourceV3(rawSearch);
}
return new Tuple<bool, INuGetResource>(curResource != null, curResource);
}
public override async Task<Tuple<bool, INuGetResource>> TryCreate(SourceRepository sourceRepository, CancellationToken token)
{
INuGetResource resource = null;
var serviceIndexResource = await sourceRepository.GetResourceAsync<ServiceIndexResourceV3>();
if (serviceIndexResource != null)
{
resource = new RemoteV3FindPackageByIdResource(sourceRepository);
}
return Tuple.Create(resource != null, resource);
}
public override async Task<Tuple<bool, INuGetResource>> TryCreate(SourceRepository source, CancellationToken token)
{
DownloadResource DownloadResourceV2 = null;
var v2repo = await GetRepository(source, token);
if (v2repo != null)
{
DownloadResourceV2 = new DownloadResourceV2(v2repo);
}
return new Tuple<bool, INuGetResource>(DownloadResourceV2 != null, DownloadResourceV2);
}
public override Task<Tuple<bool, INuGetResource>> TryCreate(SourceRepository sourceRepository, CancellationToken token)
{
INuGetResource resource = null;
if (sourceRepository.PackageSource.IsHttp
&&
!sourceRepository.PackageSource.Source.EndsWith("json", StringComparison.OrdinalIgnoreCase))
{
resource = new RemoteV2FindPackageByIdResourcce(sourceRepository.PackageSource);
}
return Task.FromResult(Tuple.Create(resource != null, resource));
}
public SiteExtensionManager(IContinuousJobsManager continuousJobManager, ITriggeredJobsManager triggeredJobManager, IEnvironment environment, IDeploymentSettingsManager settings, ITraceFactory traceFactory, HttpContextBase context, IAnalytics analytics)
{
_rootPath = Path.Combine(environment.RootPath, "SiteExtensions");
_baseUrl = context.Request.Url == null ? String.Empty : context.Request.Url.GetLeftPart(UriPartial.Authority).TrimEnd('/');
_localRepository = GetSourceRepository(_rootPath);
_continuousJobManager = continuousJobManager;
_triggeredJobManager = triggeredJobManager;
_environment = environment;
_settings = settings;
_traceFactory = traceFactory;
_analytics = analytics;
}
public async Task TryCreate_ReturnsFalse_IfSourceDoesNotHaveAJsonSuffix(string location)
{
// Arrange
var packageSource = new PackageSource(location);
var provider = new ServiceIndexResourceV3Provider();
var sourceRepository = new SourceRepository(packageSource, new[] { provider });
// Act
var result = await provider.TryCreate(sourceRepository, default(CancellationToken));
// Assert
Assert.False(result.Item1);
Assert.Null(result.Item2);
}
public override async Task<Tuple<bool, INuGetResource>> TryCreate(SourceRepository sourceRepository, CancellationToken token)
{
INuGetResource resource = null;
var serviceIndexResource = await sourceRepository.GetResourceAsync<ServiceIndexResourceV3>();
var packageBaseAddress = serviceIndexResource?[HttpFileSystemIndexType];
if (packageBaseAddress != null
&& packageBaseAddress.Count > 0)
{
resource = new HttpFileSystemBasedFindPackageByIdResource(packageBaseAddress);
}
return Tuple.Create(resource != null, resource);
}
public override async Task<Tuple<bool, INuGetResource>> TryCreate(SourceRepository source, CancellationToken token)
{
PowerShellSearchResource resource = null;
// PS search depends on v3 json search
RawSearchResourceV3 rawSearch = await source.GetResourceAsync<RawSearchResourceV3>();
if (rawSearch != null)
{
resource = new PowerShellSearchResource(rawSearch);
}
return new Tuple<bool, INuGetResource>(resource != null, resource);
}
private static void TransformSequences_RemoveCompilerGeneratedBranches(IEnumerable <Method> methods, SourceRepository sourceRepository, DateTime moduleTime)
{
foreach (var method in methods
.Where(m => m.FileRefUniqueId != 0 &&
m.SequencePoints.Length != 0))
{
// Get method source if availabile
var source = sourceRepository.GetCodeCoverageStringTextSource(method.FileRefUniqueId);
if (source != null)
{
if (source.IsChanged(moduleTime))
{
("Source file is modified: " + source.FilePath).InformUser();
return;
}
if (!TransformSequences_RemoveCompilerGeneratedBranches(method, source))
{
return; // empty sequence found -> source.IsChanged (failed access to file-times)
}
}
}
}
/// <summary>
/// Query source repository for latest package base given package id
/// </summary>
internal static async Task <UIPackageMetadata> GetLatestPackageByIdFromSrcRepo(this SourceRepository srcRepo, string packageId)
{
// 7 references none of which uses bool includePrerelease = true, bool includeUnlisted = false
var metadataResource = await srcRepo.GetResourceAndValidateAsync <UIMetadataResource>();
return(await metadataResource.GetLatestPackageByIdFromMetaRes(packageId,
explicitTag : IsNuGetRepo(srcRepo.PackageSource.Source)));
}
public StrykerNugetFeedClient()
{
_logger = new Lazy <NuGet.Common.ILogger>(() => new NuGetLogger(ApplicationLogging.LoggerFactory.CreateLogger("NuGet")));
_sourceRepository = Repository.Factory.GetCoreV3(new PackageSource(NuGetConstants.V3FeedUrl));
_sourceCacheContext = new SourceCacheContext();
}
public static async Task UpdateLocalPackage(this SourceRepository srcRepo, SourceRepository localRepo, PackageIdentity identity, string destinationFolder, string pathToLocalCopyOfNupkg, ITracer tracer)
{
tracer.Trace("Performing incremental package update for {0}", identity.Id);
using (Stream newPackageStream = await srcRepo.GetPackageStream(identity))
{
// update file
var localPackage = await localRepo.GetLatestPackageByIdFromSrcRepo(identity.Id);
if (localPackage == null)
{
throw new FileNotFoundException(string.Format(CultureInfo.InvariantCulture, "Package {0} not found from local repo.", identity.Id));
}
using (Stream oldPackageStream = await localRepo.GetPackageStream(localPackage.Identity))
using (ZipFile oldPackageZip = ZipFile.Read(oldPackageStream))
using (ZipFile newPackageZip = ZipFile.Read(newPackageStream))
{
// we only care about stuff under "content" folder
IEnumerable <ZipEntry> oldContentEntries = oldPackageZip.Entries.Where(e => e.FileName.StartsWith(@"content/", StringComparison.InvariantCultureIgnoreCase));
IEnumerable <ZipEntry> newContentEntries = newPackageZip.Entries.Where(e => e.FileName.StartsWith(@"content/", StringComparison.InvariantCultureIgnoreCase));
List <ZipEntry> filesNeedToUpdate = new List <ZipEntry>();
Dictionary <string, ZipEntry> indexedOldFiles = new Dictionary <string, ZipEntry>();
foreach (var item in oldContentEntries)
{
indexedOldFiles.Add(item.FileName.ToLowerInvariant(), item);
}
foreach (var newEntry in newContentEntries)
{
var fileName = newEntry.FileName.ToLowerInvariant();
if (indexedOldFiles.ContainsKey(fileName))
{
// file name existed, only update if file has been touched
ZipEntry oldEntry = indexedOldFiles[fileName];
if (oldEntry.LastModified != newEntry.LastModified)
{
filesNeedToUpdate.Add(newEntry);
}
// remove from old index files buffer, the rest will be files that need to be deleted
indexedOldFiles.Remove(fileName);
}
else
{
// new files
filesNeedToUpdate.Add(newEntry);
}
}
int substringStartIndex = @"content/".Length;
foreach (var entry in filesNeedToUpdate)
{
string fullPath = Path.Combine(destinationFolder, entry.FileName.Substring(substringStartIndex));
if (entry.IsDirectory)
{
using (tracer.Step("Ensure directory: {0}", fullPath))
{
FileSystemHelpers.EnsureDirectory(fullPath.Replace('/', '\\'));
}
continue;
}
using (tracer.Step("Adding/Updating file: {0}", fullPath))
{
FileSystemHelpers.EnsureDirectory(Path.GetDirectoryName(fullPath));
using (Stream writeStream = FileSystemHelpers.OpenWrite(fullPath))
{
// reset length of file stream
writeStream.SetLength(0);
// let the thread go with itself, so that once file finishes writing, doesn't need to request thread context from main thread
await entry.OpenReader().CopyToAsync(writeStream).ConfigureAwait(false);
}
}
}
foreach (var entry in indexedOldFiles.Values)
{
string fullPath = Path.Combine(destinationFolder, entry.FileName.Substring(substringStartIndex));
if (entry.IsDirectory)
{
// in case the two zip file was created from different tool. some tool will include folder as seperate entry, some don`t.
// to be sure that foder is meant to be deleted, double check there is no files under it
var entryNameInLower = entry.FileName.ToLower();
if (!string.Equals(destinationFolder, fullPath, StringComparison.OrdinalIgnoreCase) &&
newContentEntries.FirstOrDefault(e => e.FileName.ToLowerInvariant().StartsWith(entryNameInLower)) == null)
{
using (tracer.Step("Deleting directory: {0}", fullPath))
{
FileSystemHelpers.DeleteDirectorySafe(fullPath);
}
}
continue;
}
using (tracer.Step("Deleting file: {0}", fullPath))
{
FileSystemHelpers.DeleteFileSafe(fullPath);
}
}
}
// update nupkg
newPackageStream.Position = 0;
using (tracer.Step("Updating nupkg file."))
{
WriteStreamToFile(newPackageStream, pathToLocalCopyOfNupkg);
if (!identity.Version.Equals(localPackage.Identity.Version))
{
using (tracer.Step("New package has difference version {0} from old package {1}. Remove old nupkg file.", identity.Version, localPackage.Identity.Version))
{
// if version is difference, nupkg file name will be difference. will need to clean up the old one.
var oldNupkg = pathToLocalCopyOfNupkg.Replace(
string.Format(CultureInfo.InvariantCulture, "{0}.{1}.nupkg", identity.Id, identity.Version.ToNormalizedString()),
string.Format(CultureInfo.InvariantCulture, "{0}.{1}.nupkg", localPackage.Identity.Id, localPackage.Identity.Version.ToNormalizedString()));
FileSystemHelpers.DeleteFileSafe(oldNupkg);
}
}
}
}
}
internal async Task<(IPackageFeed? mainFeed, IPackageFeed? recommenderFeed)> CreatePackageFeedAsync(
IReadOnlyCollection<IProjectContextInfo> projectContextInfos,
IReadOnlyCollection<string> targetFrameworks,
ItemFilter itemFilter,
bool isSolution,
bool recommendPackages,
IEnumerable<SourceRepository> sourceRepositories,
CancellationToken cancellationToken)
{
var logger = new VisualStudioActivityLogger();
var uiLogger = await ServiceLocator.GetComponentModelServiceAsync<INuGetUILogger>();
var packageFeeds = (mainFeed: (IPackageFeed?)null, recommenderFeed: (IPackageFeed?)null);
if (itemFilter == ItemFilter.All && recommendPackages == false)
{
packageFeeds.mainFeed = new MultiSourcePackageFeed(sourceRepositories, uiLogger, TelemetryActivity.NuGetTelemetryService);
return packageFeeds;
}
IInstalledAndTransitivePackages installedAndTransitivePackages = await GetInstalledAndTransitivePackagesAsync(projectContextInfos, cancellationToken);
PackageCollection installedPackageCollection = PackageCollection.FromPackageReferences(installedAndTransitivePackages.InstalledPackages);
PackageCollection transitivePackageCollection = PackageCollection.FromPackageReferences(installedAndTransitivePackages.TransitivePackages);
IEnumerable<SourceRepository> globalPackageFolderRepositories = await GetAllPackageFoldersAsync(projectContextInfos, cancellationToken);
SourceRepository packagesFolderSourceRepository = await _packagesFolderLocalRepositoryLazy.GetValueAsync(cancellationToken);
var metadataProvider = new MultiSourcePackageMetadataProvider(
sourceRepositories,
packagesFolderSourceRepository,
globalPackageFolderRepositories,
logger);
if (itemFilter == ItemFilter.All)
{
// if we get here, recommendPackages == true
packageFeeds.mainFeed = new MultiSourcePackageFeed(sourceRepositories, uiLogger, TelemetryActivity.NuGetTelemetryService);
packageFeeds.recommenderFeed = new RecommenderPackageFeed(
sourceRepositories,
installedPackageCollection,
transitivePackageCollection,
targetFrameworks,
metadataProvider,
logger);
return packageFeeds;
}
if (itemFilter == ItemFilter.Installed)
{
if (!isSolution && await ExperimentUtility.IsTransitiveOriginExpEnabled.GetValueAsync(cancellationToken))
{
packageFeeds.mainFeed = new InstalledAndTransitivePackageFeed(installedPackageCollection, transitivePackageCollection, metadataProvider);
}
else
{
packageFeeds.mainFeed = new InstalledPackageFeed(installedPackageCollection, metadataProvider);
}
return packageFeeds;
}
if (itemFilter == ItemFilter.Consolidate)
{
packageFeeds.mainFeed = new ConsolidatePackageFeed(installedPackageCollection, metadataProvider, logger);
return packageFeeds;
}
// Search all / updates available cannot work without a source repo
if (sourceRepositories == null)
{
return packageFeeds;
}
if (itemFilter == ItemFilter.UpdatesAvailable)
{
packageFeeds.mainFeed = new UpdatePackageFeed(
_serviceBroker,
installedPackageCollection,
metadataProvider,
projectContextInfos.ToArray());
return packageFeeds;
}
throw new InvalidOperationException(
string.Format(CultureInfo.CurrentCulture, Strings.UnsupportedFeedType, itemFilter));
}
public IPackage GetUpdate(IPackage package)
{
return(SourceRepository.GetUpdates(new[] { package }, includePrerelease: false).SingleOrDefault());
}
public void AddSourceRepository(SourceRepository source)
{
_cachedSources.TryAdd(source.PackageSource.Source, source);
}
static NuGetDiff()
{
source = Repository.Factory.GetCoreV3("https://api.nuget.org/v3/index.json");
cache = new SourceCacheContext();
logger = NullLogger.Instance;
}
public AdminController(SourceRepository repository)
{
db = repository;
}
private Task <string?> DownloadWithProgress(SourceRepository sourceRepository, PackageIdentity packageIdentity)
{
var progressDialogText = Resources.Dialog_DownloadingPackage;
if (packageIdentity.HasVersion)
{
progressDialogText = string.Format(CultureInfo.CurrentCulture, progressDialogText, packageIdentity.Id, packageIdentity.Version);
}
else
{
progressDialogText = string.Format(CultureInfo.CurrentCulture, progressDialogText, packageIdentity.Id, string.Empty);
}
string?description = null;
int? percent = null;
var updated = 0;
var progressDialogLock = new object();
#pragma warning disable CA2000 // Dispose objects before losing scope (handled in finally below)
var progressDialog = new ProgressDialog
{
Text = progressDialogText,
WindowTitle = Resources.Dialog_Title,
ShowTimeRemaining = true,
CancellationText = "Canceling download..."
};
// polling for Cancel button being clicked
var cts = new CancellationTokenSource();
var timer = new System.Timers.Timer(100);
#pragma warning restore CA2000 // Dispose objects before losing scope
timer.Elapsed += (o, e) =>
{
lock (progressDialogLock)
{
if (progressDialog.CancellationPending)
{
timer.Stop();
cts.Cancel();
}
else if (Interlocked.CompareExchange(ref updated, 0, 1) == 1)
{
progressDialog.ReportProgress(percent.GetValueOrDefault(), null, description);
}
}
};
var tcs = new TaskCompletionSource <string?>();
progressDialog.DoWork += (object sender, DoWorkEventArgs args) =>
{
var t = DoWorkAsync();
t.Wait(cts.Token);
tcs.TrySetResult(t.Result);
};
progressDialog.RunWorkerCompleted += (object sender, RunWorkerCompletedEventArgs args) =>
{
MainWindow.Value.Activate();
};
progressDialog.ShowDialog(MainWindow.Value);
timer.Start();
async Task <string?> DoWorkAsync()
{
try
{
var httpProgressProvider = new ProgressHttpHandlerResourceV3Provider(OnProgress);
var repository = PackageRepositoryFactory.CreateRepository(sourceRepository.PackageSource, new[] { new Lazy <INuGetResourceProvider>(() => httpProgressProvider) });
var downloadResource = await repository.GetResourceAsync <DownloadResource>(cts.Token).ConfigureAwait(false);
using var sourceCacheContext = new SourceCacheContext()
{
NoCache = true
};
var context = new PackageDownloadContext(sourceCacheContext, Path.GetTempPath(), true);
using var result = await downloadResource.GetDownloadResourceResultAsync(packageIdentity, context, string.Empty, NullLogger.Instance, cts.Token).ConfigureAwait(false);
if (result.Status == DownloadResourceResultStatus.Cancelled)
{
throw new OperationCanceledException();
}
if (result.Status == DownloadResourceResultStatus.NotFound)
{
throw new Exception($"Package '{packageIdentity.Id} {packageIdentity.Version}' not found");
}
var tempFilePath = Path.GetTempFileName();
using (var fileStream = File.OpenWrite(tempFilePath))
{
await result.PackageStream.CopyToAsync(fileStream).ConfigureAwait(false);
}
return(tempFilePath);
}
catch (OperationCanceledException)
{
return(null);
}
catch (Exception exception)
{
OnError(exception);
return(null);
}
finally
{
timer.Stop();
timer.Dispose();
cts.Dispose();
// close progress dialog when done
lock (progressDialogLock)
{
progressDialog.Dispose();
}
}
}
void OnProgress(long bytesReceived, long?totalBytes)
{
if (totalBytes.HasValue)
{
// TODO: remove ! once https://github.com/dotnet/roslyn/issues/33330 is fixed
percent = (int)((bytesReceived * 100L) / totalBytes) !;
description = string.Format(
CultureInfo.CurrentCulture,
"Downloaded {0} of {1}...",
FileSizeConverter.Convert(bytesReceived, typeof(string), null, CultureInfo.CurrentCulture),
FileSizeConverter.Convert(totalBytes.Value, typeof(string), null, CultureInfo.CurrentCulture));
}
else
{
percent = null;
description = string.Format(
CultureInfo.CurrentCulture,
"Downloaded {0}...",
FileSizeConverter.Convert(bytesReceived, typeof(string), null, CultureInfo.CurrentCulture));
}
Interlocked.Exchange(ref updated, 1);
}
return(tcs.Task);
}
public static async Task <DownloadResourceResult> GetDownloadResourceResult(string depsFolder, SourceCacheContext cache, SourceRepository repository, DownloadResource resource, string packageId, NuGetVersion packageVersion)
{
return(await resource.GetDownloadResourceResultAsync(
new SourcePackageDependencyInfo(packageId, packageVersion, null, true, repository),
new PackageDownloadContext(cache),
depsFolder,
NuGet.Common.NullLogger.Instance,
CancellationToken.None));
}
private async Task <SiteExtensionInfo> TryInstallExtension(string id, string version, string feedUrl, SiteExtensionInfo.SiteExtensionType type, ITracer tracer)
{
SiteExtensionInfo info = null;
HttpStatusCode status = HttpStatusCode.OK; // final status when success
bool alreadyInstalled = false;
if (_preInstalledExtensionDictionary.ContainsKey(id))
{
tracer.Trace("Pre-installed site extension found: {0}, not going to perform new installation.", id);
info = EnablePreInstalledExtension(_preInstalledExtensionDictionary[id], tracer);
alreadyInstalled = true;
}
else
{
try
{
// Check if site extension already installed (id, version, feedUrl), if already install return right away
if (await this.IsSiteExtensionInstalled(id, version, feedUrl))
{
// package already installed, return package from local repo.
tracer.Trace("Package {0} with version {1} from {2} already installed.", id, version, feedUrl);
info = await GetLocalExtension(id);
alreadyInstalled = true;
}
else
{
JsonSettings siteExtensionSettings = GetSettingManager(id);
feedUrl = (string.IsNullOrEmpty(feedUrl) ? siteExtensionSettings.GetValue(_feedUrlSetting) : feedUrl);
SourceRepository remoteRepo = GetRemoteRepository(feedUrl);
UIPackageMetadata localPackage = null;
UIPackageMetadata repoPackage = null;
if (string.IsNullOrWhiteSpace(version))
{
using (tracer.Step("Version is null, search latest package by id: {0}, will not search for unlisted package.", id))
{
repoPackage = await remoteRepo.GetLatestPackageById(id);
}
}
else
{
using (tracer.Step("Search package by id: {0} and version: {1}, will also search for unlisted package.", id, version))
{
repoPackage = await remoteRepo.GetPackageByIdentity(id, version);
}
}
if (repoPackage != null)
{
using (tracer.Step("Install package: {0}.", id))
{
string installationDirectory = GetInstallationDirectory(id);
localPackage = await InstallExtension(repoPackage, installationDirectory, feedUrl, type, tracer);
siteExtensionSettings.SetValues(new KeyValuePair <string, JToken>[] {
new KeyValuePair <string, JToken>(_versionSetting, localPackage.Identity.Version.ToNormalizedString()),
new KeyValuePair <string, JToken>(_feedUrlSetting, feedUrl),
new KeyValuePair <string, JToken>(_installUtcTimestampSetting, DateTime.UtcNow.ToString("u")),
new KeyValuePair <string, JToken>(_packageType, Enum.GetName(typeof(SiteExtensionInfo.SiteExtensionType), type))
});
}
}
info = await ConvertLocalPackageToSiteExtensionInfo(localPackage, checkLatest : true, tracer : tracer);
}
}
catch (FileNotFoundException ex)
{
_analytics.UnexpectedException(
ex,
method: "PUT",
path: string.Format(CultureInfo.InvariantCulture, "/api/siteextensions/{0}", id),
result: Constants.SiteExtensionProvisioningStateFailed,
message: string.Format(CultureInfo.InvariantCulture, "{{\"version\": {0}, \"feed_url\": {1}}}", version, feedUrl),
trace: false);
tracer.TraceError(ex);
info = new SiteExtensionInfo();
info.Id = id;
info.ProvisioningState = Constants.SiteExtensionProvisioningStateFailed;
info.Comment = string.Format(Constants.SiteExtensionProvisioningStateNotFoundMessageFormat, id);
status = HttpStatusCode.NotFound;
}
catch (WebException ex)
{
_analytics.UnexpectedException(
ex,
method: "PUT",
path: string.Format(CultureInfo.InvariantCulture, "/api/siteextensions/{0}", id),
result: Constants.SiteExtensionProvisioningStateFailed,
message: string.Format(CultureInfo.InvariantCulture, "{{\"version\": {0}, \"feed_url\": {1}}}", version, feedUrl),
trace: false);
tracer.TraceError(ex);
info = new SiteExtensionInfo();
info.Id = id;
info.ProvisioningState = Constants.SiteExtensionProvisioningStateFailed;
info.Comment = string.Format(Constants.SiteExtensionProvisioningStateDownloadFailureMessageFormat, id);
status = HttpStatusCode.BadRequest;
}
catch (InvalidEndpointException ex)
{
_analytics.UnexpectedException(ex, trace: false);
tracer.TraceError(ex);
info = new SiteExtensionInfo();
info.Id = id;
info.ProvisioningState = Constants.SiteExtensionProvisioningStateFailed;
info.Comment = ex.Message;
status = HttpStatusCode.BadRequest;
}
catch (Exception ex)
{
_analytics.UnexpectedException(
ex,
method: "PUT",
path: string.Format(CultureInfo.InvariantCulture, "/api/siteextensions/{0}", id),
result: Constants.SiteExtensionProvisioningStateFailed,
message: string.Format(CultureInfo.InvariantCulture, "{{\"version\": {0}, \"feed_url\": {1}}}", version, feedUrl),
trace: false);
tracer.TraceError(ex);
info = new SiteExtensionInfo();
info.Id = id;
info.ProvisioningState = Constants.SiteExtensionProvisioningStateFailed;
info.Comment = string.Format(Constants.SiteExtensionProvisioningStateInvalidPackageMessageFormat, id);
status = HttpStatusCode.BadRequest;
}
}
if (info == null)
{
// treat this as an error case since no result return from repo
_analytics.UnexpectedException(
new FileNotFoundException(id),
method: "PUT",
path: string.Format(CultureInfo.InvariantCulture, "/api/siteextensions/{0}", id),
result: Constants.SiteExtensionProvisioningStateFailed,
message: string.Format(CultureInfo.InvariantCulture, "{{\"version\": {0}, \"feed_url\": {1}}}", version, feedUrl),
trace: false);
info = new SiteExtensionInfo();
info.ProvisioningState = Constants.SiteExtensionProvisioningStateFailed;
info.Comment = string.Format(Constants.SiteExtensionProvisioningStateNotFoundMessageFormat, id);
status = HttpStatusCode.NotFound;
}
else if (!string.Equals(Constants.SiteExtensionProvisioningStateFailed, info.ProvisioningState, StringComparison.OrdinalIgnoreCase))
{
info.ProvisioningState = Constants.SiteExtensionProvisioningStateSucceeded;
info.Comment = null;
}
using (tracer.Step("Update arm settings for {0} installation. Status: {1}", id, status))
{
SiteExtensionStatus armSettings = new SiteExtensionStatus(_environment.SiteExtensionSettingsPath, id, tracer);
armSettings.ReadSiteExtensionInfo(info);
armSettings.Status = status;
armSettings.Operation = alreadyInstalled ? null : Constants.SiteExtensionOperationInstall;
}
return(info);
}
public Task <Tuple <bool, INuGetResource> > TryCreate(SourceRepository source, CancellationToken token)
{
throw new NotImplementedException();
}
public static HttpSourceTestHost Create(SourceRepository source, HttpClient client)
{
Func <Task <HttpHandlerResource> > factory = () => source.GetResourceAsync <HttpHandlerResource>();
return(new HttpSourceTestHost(source.PackageSource, factory, NullThrottle.Instance, client));
}
public override Task <IEnumerable <JObject> > SearchInstalled(SourceRepository source, string searchText, int skip, int take, System.Threading.CancellationToken cancelToken)
{
throw new System.NotImplementedException();
}
public override async Task <Tuple <bool, INuGetResource> > TryCreate(SourceRepository source, CancellationToken token)
{
ServiceIndexResourceV3 index = null;
ServiceIndexCacheInfo cacheInfo = null;
var url = source.PackageSource.Source;
// the file type can easily rule out if we need to request the url
if (source.PackageSource.ProtocolVersion == 3 ||
(source.PackageSource.IsHttp &&
url.EndsWith(".json", StringComparison.OrdinalIgnoreCase)))
{
var utcNow = DateTime.UtcNow;
var entryValidCutoff = utcNow.Subtract(MaxCacheDuration);
// check the cache before downloading the file
if (!_cache.TryGetValue(url, out cacheInfo) ||
entryValidCutoff > cacheInfo.CachedTime)
{
// Track if the semaphore needs to be released
var release = false;
try
{
await _semaphore.WaitAsync(token);
release = true;
token.ThrowIfCancellationRequested();
// check the cache again, another thread may have finished this one waited for the lock
if (!_cache.TryGetValue(url, out cacheInfo) ||
entryValidCutoff > cacheInfo.CachedTime)
{
index = await GetServiceIndexResourceV3(source, utcNow, NullLogger.Instance, token);
// cache the value even if it is null to avoid checking it again later
var cacheEntry = new ServiceIndexCacheInfo
{
CachedTime = utcNow,
Index = index
};
// If the cache entry has expired it will already exist
_cache.AddOrUpdate(url, cacheEntry, (key, value) => cacheEntry);
}
}
finally
{
if (release)
{
_semaphore.Release();
}
}
}
}
if (index == null && cacheInfo != null)
{
index = cacheInfo.Index;
}
return(new Tuple <bool, INuGetResource>(index != null, index));
}
public IPackageSearchMetadata GetPackageFromRepoWithoutVersion(string packageName, PackageMetadataResource packageMetadataResource, SourceCacheContext sourceCacheContext, SourceRepository sourceRepository)
{
IPackageSearchMetadata rootPackage = null;
var exacactsearchMetadata = packageMetadataResource.GetMetadataAsync(packageName, true, true, sourceCacheContext, Logger, CancellationToken.None)
.Result;
if (exacactsearchMetadata.Count() == 0)
{
Logger.LogDebug("GetPackageFromRepoWithoutVersion - No Package & any version found in Repo " + $"{sourceRepository.PackageSource.Source} for package : {packageName}");
}
else //select latest version
{
rootPackage = exacactsearchMetadata.OrderByDescending(x => x.Identity.Version)
.FirstOrDefault();
}
return(rootPackage);
}
/// <summary>
/// If the remote package is already determined, consider using the overload which directly takes in the remote package
/// Can avoid calls FindPackage calls to source repository. However, it should also be remembered that SourceRepository of ProjectManager
/// is an aggregate of "SharedPackageRepository" and the selected repository. So, if the package is present on the repository path (by default, the packages folder)
/// It would not result in a call to the server
/// </summary>
public virtual void UpdatePackageReference(string packageId, SemanticVersion version, bool updateDependencies, bool allowPrereleaseVersions)
{
UpdatePackageReference(packageId, () => SourceRepository.FindPackage(packageId, version, ConstraintProvider, allowPrereleaseVersions, allowUnlisted: false), updateDependencies, allowPrereleaseVersions, targetVersionSetExplicitly: version != null);
}
private SourceValidationResult(SourceValidity validity, string source, SourceRepository sourceRepository)
{
Validity = validity;
Source = source;
SourceRepository = sourceRepository;
}
public SourceResource(SourceRepository source, DependencyInfoResource resource)
{
Source = source;
Resource = resource;
}
private static async Task <Stream> GetPackageStream(this SourceRepository srcRepo, PackageIdentity identity)
{
var downloadResource = await srcRepo.GetResourceAsync <DownloadResource>();
Stream sourceStream = null;
Stream packageStream = null;
try
{
sourceStream = await downloadResource.GetStream(identity, CancellationToken.None);
if (sourceStream == null)
{
// package not exist from feed
throw new FileNotFoundException(string.Format(CultureInfo.InvariantCulture, "Package {0} - {1} not found when try to download.", identity.Id, identity.Version.ToNormalizedString()));
}
packageStream = sourceStream;
if (!sourceStream.CanSeek)
{
// V3 DownloadResource.GetStream does not support seek operations.
// https://github.com/NuGet/NuGet.Protocol/issues/15
MemoryStream memStream = new MemoryStream();
try
{
byte[] buffer = new byte[2048];
int bytesRead = 0;
do
{
bytesRead = sourceStream.Read(buffer, 0, buffer.Length);
memStream.Write(buffer, 0, bytesRead);
} while (bytesRead != 0);
await memStream.FlushAsync();
memStream.Position = 0;
packageStream = memStream;
}
catch
{
memStream.Dispose();
throw;
}
}
return(packageStream);
}
catch
{
if (packageStream != null && packageStream != sourceStream)
{
packageStream.Dispose();
}
if (sourceStream != null)
{
sourceStream.Dispose();
}
throw;
}
finally
{
if (packageStream != null && sourceStream != null && !sourceStream.CanSeek)
{
// packageStream is a copy of sourceStream, dispose sourceStream
sourceStream.Dispose();
}
}
}
public static HttpSource Create(SourceRepository source)
{
return(Create(source, NullThrottle.Instance));
}
public PackageDownloadManager(IModulesDirectory modulesDirectory, SourceRepository sourceRepository)
{
_modulesDirectory = modulesDirectory;
_sourceRepository = sourceRepository;
}
private static void TransformSequences_RemoveFalsePositiveUnvisited(IEnumerable <Method> methods, SourceRepository sourceRepository, DateTime moduleTime)
{
var sequencePointsSet = new HashSet <SequencePoint>(new SequencePointComparer());
var toRemoveMethodSequencePoint = new List <Tuple <Method, SequencePoint> >();
// Initialise sequencePointsSet
TransformSequences_RemoveFalsePositiveUnvisited(methods, sequencePointsSet);
// Check generated methods
foreach (var method in methods
.Where(m => m.FileRefUniqueId != 0 &&
m.SequencePoints.Length != 0 &&
m.IsGenerated))
{
// Select duplicate and false-positive unvisited sequence points
// (Sequence point duplicated by generated method and left unvisited)
foreach (var sp in method.SequencePoints
.Where(sp => sp.FileId == method.FileRefUniqueId &&
sp.VisitCount == 0))
{
if (sequencePointsSet.Contains(sp))
{
// Unvisited duplicate found, add to remove list
toRemoveMethodSequencePoint.Add(new Tuple <Method, SequencePoint>(method, sp));
}
}
// Get method source if availabile
var source = sourceRepository.GetCodeCoverageStringTextSource(method.FileRefUniqueId);
if (source != null && !source.IsChanged(moduleTime))
{
TransformSequences_RemoveFalsePositiveUnvisited(method, source, toRemoveMethodSequencePoint);
}
}
// Remove selected SequencePoints
foreach (var tuple in toRemoveMethodSequencePoint)
{
tuple.Item1.SequencePoints = tuple.Item1.SequencePoints.Where(sp => sp != tuple.Item2).ToArray();
}
}
/// <summary> /// Searches installed packages across this target and any sub-targets (Projects in a Solution, for example) /// </summary> /// <param name="searchText"></param> /// <param name="skip"></param> /// <param name="take"></param> /// <param name="cancelToken"></param> /// <returns></returns> public abstract Task <IEnumerable <JObject> > SearchInstalled(SourceRepository source, string searchText, int skip, int take, CancellationToken cancelToken);
/// <summary>
/// <para>1. Download package</para>
/// <para>2. Generate xdt file if not exist</para>
/// <para>3. Deploy site extension job</para>
/// <para>4. Execute install.cmd if exist</para>
/// </summary>
private async Task <UIPackageMetadata> InstallExtension(UIPackageMetadata package, string installationDirectory, string feedUrl, SiteExtensionInfo.SiteExtensionType type, ITracer tracer)
{
try
{
bool packageExisted = FileSystemHelpers.DirectoryExists(installationDirectory);
SourceRepository remoteRepo = GetRemoteRepository(feedUrl);
// package path from local repo
string packageLocalFilePath = GetNuGetPackageFile(package.Identity.Id, package.Identity.Version.ToString());
using (tracer.Step("Download site extension: {0}", package.Identity))
{
string extractPath = installationDirectory;
if (SiteExtensionInfo.SiteExtensionType.WebRoot == type)
{
extractPath = _environment.WebRootPath;
FileSystemHelpers.EnsureDirectory(extractPath);
}
// Copy/update content folder
// Copy/update nupkg file for package list/lookup
if (packageExisted)
{
await remoteRepo.UpdateLocalPackage(_localRepository, package.Identity, extractPath, packageLocalFilePath, tracer);
}
else
{
FileSystemHelpers.EnsureDirectory(installationDirectory);
await remoteRepo.DownloadPackageToFolder(package.Identity, extractPath, packageLocalFilePath);
}
if (SiteExtensionInfo.SiteExtensionType.WebRoot == type)
{
// if install to WebRoot, check if there is any xdt file come with package
// if there is one, move it to site extension folder
string xdtFile = Path.Combine(extractPath, Constants.ApplicationHostXdtFileName);
if (File.Exists(xdtFile))
{
tracer.Trace("Use xdt file from package.");
string newXdtFile = Path.Combine(installationDirectory, Constants.ApplicationHostXdtFileName);
tracer.Trace("Moving {0} to {1}", xdtFile, newXdtFile);
FileSystemHelpers.MoveFile(xdtFile, newXdtFile);
}
else
{
tracer.Trace("No xdt file come with package.");
}
}
}
// ignore below action if we install packge to wwwroot
if (SiteExtensionInfo.SiteExtensionType.WebRoot != type)
{
// If there is no xdt file, generate default.
using (tracer.Step("Check if applicationhost.xdt file existed."))
{
GenerateApplicationHostXdt(installationDirectory, '/' + package.Identity.Id, isPreInstalled: false, tracer: tracer);
}
using (tracer.Step("Trigger site extension job"))
{
OperationManager.Attempt(() => DeploySiteExtensionJobs(package.Identity.Id));
}
var externalCommandFactory = new ExternalCommandFactory(_environment, _settings, installationDirectory);
string installScript = Path.Combine(installationDirectory, _installScriptName);
if (FileSystemHelpers.FileExists(installScript))
{
using (tracer.Step("Execute install.cmd"))
{
OperationManager.Attempt(() =>
{
Executable exe = externalCommandFactory.BuildCommandExecutable(installScript,
installationDirectory,
_settings.GetCommandIdleTimeout(), NullLogger.Instance);
exe.ExecuteWithProgressWriter(NullLogger.Instance, _traceFactory.GetTracer(), String.Empty);
});
}
}
}
}
catch (Exception ex)
{
tracer.TraceError(ex);
FileSystemHelpers.DeleteDirectorySafe(installationDirectory);
throw;
}
return(await _localRepository.GetLatestPackageById(package.Identity.Id));
}
internal static async Task <RemoteV3FindPackageByIdResourceTest> CreateAsync()
{
var serviceAddress = ProtocolUtility.CreateServiceAddress();
var packageIdentity = new PackageIdentity(
id: "xunit",
version: NuGetVersion.Parse("2.2.0-beta1-build3239"));
var testDirectory = TestDirectory.Create();
var packageSource = new PackageSource(serviceAddress);
var dependencyInfoResourceProvider = new Mock <INuGetResourceProvider>();
var dependencyInfoResource = new Mock <DependencyInfoResource>();
var remoteSourceDependencyInfo = new RemoteSourceDependencyInfo(
packageIdentity,
listed: true,
dependencyGroups: Enumerable.Empty <PackageDependencyGroup>(),
contentUri: serviceAddress + "api/v2/package/xunit/2.2.0-beta1-build3239");
dependencyInfoResource.Setup(x => x.ResolvePackages(
It.Is <string>(id => id == packageIdentity.Id),
It.IsAny <SourceCacheContext>(),
It.IsNotNull <ILogger>(),
It.IsAny <CancellationToken>()))
.ReturnsAsync(new[] { remoteSourceDependencyInfo });
dependencyInfoResourceProvider.SetupGet(x => x.Before)
.Returns(Enumerable.Empty <string>());
dependencyInfoResourceProvider.SetupGet(x => x.After)
.Returns(Enumerable.Empty <string>());
dependencyInfoResourceProvider.SetupGet(x => x.ResourceType)
.Returns(typeof(DependencyInfoResource));
dependencyInfoResourceProvider.SetupGet(x => x.Name)
.Returns("DependencyInfoResourceProvider");
dependencyInfoResourceProvider.Setup(
x => x.TryCreate(It.IsNotIn <SourceRepository>(), It.IsAny <CancellationToken>()))
.ReturnsAsync(new Tuple <bool, INuGetResource>(true, dependencyInfoResource.Object));
var sourceRepository = new SourceRepository(
packageSource,
new[] { dependencyInfoResourceProvider.Object });
var package = await SimpleTestPackageUtility.CreateFullPackageAsync(
testDirectory.Path,
packageIdentity.Id,
packageIdentity.Version.ToNormalizedString());
var packageBytes = File.ReadAllBytes(package.FullName);
var responses = new Dictionary <string, Func <HttpRequestMessage, Task <HttpResponseMessage> > >
{
{
serviceAddress,
request => Task.FromResult(new HttpResponseMessage(HttpStatusCode.OK)
{
Content = new TestContent(string.Empty)
})
},
{
serviceAddress + "api/v2/package/xunit/2.2.0-beta1-build3239",
request => Task.FromResult(new HttpResponseMessage(HttpStatusCode.OK)
{
Content = new ByteArrayContent(packageBytes)
})
}
};
var httpSource = new TestHttpSource(packageSource, responses);
var resource = new RemoteV3FindPackageByIdResource(
sourceRepository,
httpSource);
return(new RemoteV3FindPackageByIdResourceTest(
resource,
sourceRepository,
package,
packageIdentity,
new SourceCacheContext(),
httpSource,
testDirectory));
}
public void UpdatePackage(string packageId, SemanticVersion version, bool updateDependencies, bool allowPrereleaseVersions)
{
UpdatePackage(packageId, () => SourceRepository.FindPackage(packageId, version, allowPrereleaseVersions, allowUnlisted: false),
updateDependencies, allowPrereleaseVersions);
}
public void Dispose()
{
this.sourceRepository = null;
this.sourceCacheContext?.Dispose();
this.sourceCacheContext = null;
}
public TestDependencyInfo(SourceRepository source, List <SourcePackageDependencyInfo> packages)
{
Source = source;
Packages = packages;
}
