internal CatalogEntry( string[] urlParts, string type, string commitId, DateTimeOffset commitTs, string id, NuGetVersion version, ServiceIndexResourceV3 serviceIndex, Func <Uri, CancellationToken, Task <JObject> > getJson, Func <Uri, CancellationToken, Task <NuspecReader> > getNuspec, Func <Uri, CancellationToken, Task <HttpSourceResult> > getNupkg) { _urlParts = urlParts; Types = new List <string>() { type }; CommitId = commitId; CommitTimeStamp = commitTs; Id = id; Version = version; _getJson = getJson; _serviceIndex = serviceIndex; _getNuspec = getNuspec; _getNupkg = getNupkg; }
public PSAutoCompleteResourceV3(DataClient client, ServiceIndexResourceV3 serviceIndex, RegistrationResourceV3 regResource) : base() { _regResource = regResource; _serviceIndex = serviceIndex; _client = client; }
internal NuGetPackProvider(string name, string query, DirectoryInfo packageTempBasePath, int pageSize, bool runOnlyOnePage, bool includePreviewPacks) { Name = name; _pageSize = pageSize; _runOnlyOnePage = runOnlyOnePage; _packageTempPath = Path.GetFullPath(Path.Combine(packageTempBasePath.FullName, DownloadedPacksDir, Name)); _repository = Repository.Factory.GetCoreV3(NuGetOrgFeed); ServiceIndexResourceV3 indexResource = _repository.GetResource <ServiceIndexResourceV3>(); IReadOnlyList <ServiceIndexEntry> searchResources = indexResource.GetServiceEntries("SearchQueryService"); _downloadResource = _repository.GetResource <FindPackageByIdResource>(); _includePreview = includePreviewPacks; if (!searchResources.Any()) { throw new Exception($"{NuGetOrgFeed} does not support search API (SearchQueryService)"); } _searchUriFormat = $"{searchResources[0].Uri}?{query}&skip={{0}}&take={{1}}&prerelease={includePreviewPacks}&semVerLevel=2.0.0"; if (Directory.Exists(_packageTempPath)) { throw new Exception($"temp storage path for NuGet packages already exists: {_packageTempPath}"); } else { Directory.CreateDirectory(_packageTempPath); } }
internal static Uri GetCatalogServiceUri(this ServiceIndexResourceV3 serviceIndex, string[] types) { var uris = serviceIndex.GetServiceEntryUris(types); if (uris.Count < 1) { throw new InvalidDataException($"Unable to find a service of type: {string.Join(", ", types)} Verify the index.json file contains this entry."); } return(uris[0]); }
public void Constructor_InitializesProperties() { var serviceIndex = CreateServiceIndex(); var expectedJson = serviceIndex.ToString(); var expectedRequestTime = DateTime.UtcNow; var resource = new ServiceIndexResourceV3(serviceIndex, expectedRequestTime); Assert.Equal(expectedJson, resource.Json); Assert.Equal(expectedRequestTime, resource.RequestTime); Assert.Equal(1, resource.Entries.Count); Assert.Equal("a", resource.Entries[0].Type); Assert.Equal("http://unit.test/b", resource.Entries[0].Uri.ToString()); }
public async Task <string> GetPackageUrl(PackageId packageId, NuGetVersion packageVersion = null, PackageSourceLocation packageSourceLocation = null, bool includePreview = false) { (var source, var resolvedPackageVersion) = await GetPackageSourceAndVerion(packageId, packageVersion, packageSourceLocation, includePreview); SourceRepository repository = GetSourceRepository(source); ServiceIndexResourceV3 serviceIndexResource = repository.GetResourceAsync <ServiceIndexResourceV3>().Result; IReadOnlyList <Uri> packageBaseAddress = serviceIndexResource?.GetServiceEntryUris(ServiceTypes.PackageBaseAddress); return(GetNupkgUrl(packageBaseAddress.First().ToString(), packageId, resolvedPackageVersion)); }
internal PackageEntry( string id, NuGetVersion version, ServiceIndexResourceV3 serviceIndex, Func <Uri, CancellationToken, Task <JObject> > getJson, Func <Uri, CancellationToken, Task <NuspecReader> > getNuspec, Func <Uri, CancellationToken, Task <HttpSourceResult> > getNupkg) { Id = id; Version = version; _getJson = getJson; _serviceIndex = serviceIndex; _getNuspec = getNuspec; _getNupkg = getNupkg; }
public override async Task <Tuple <bool, INuGetResource> > TryCreate(SourceRepository source, CancellationToken token) { UISearchResourceV3 curResource = null; ServiceIndexResourceV3 serviceIndex = await source.GetResourceAsync <ServiceIndexResourceV3>(token); if (serviceIndex != null) { var rawSearch = await source.GetResourceAsync <RawSearchResourceV3>(token); var metadataResource = await source.GetResourceAsync <UIMetadataResource>(token); curResource = new UISearchResourceV3(rawSearch, metadataResource); } return(new Tuple <bool, INuGetResource>(curResource != null, curResource)); }
public async Task HandleResponseAsync_ReturnsSuccessIfServiceIndexIsFound() { using (var provider = new GetServiceIndexRequestHandler(Mock.Of <IPlugin>())) { var packageSource = new PackageSource("https://unit.test"); var serviceIndex = JObject.Parse("{}"); var serviceIndexResource = new ServiceIndexResourceV3(serviceIndex, DateTime.UtcNow); var serviceIndexResourceProvider = new Mock <INuGetResourceProvider>(); serviceIndexResourceProvider.SetupGet(x => x.ResourceType) .Returns(typeof(ServiceIndexResourceV3)); serviceIndexResourceProvider.SetupGet(x => x.Name) .Returns(nameof(ServiceIndexResourceV3Provider)); serviceIndexResourceProvider.Setup(x => x.TryCreate( It.IsNotNull <SourceRepository>(), It.IsAny <CancellationToken>())) .ReturnsAsync(new Tuple <bool, INuGetResource>(true, serviceIndexResource)); var sourceRepository = new SourceRepository( packageSource, new INuGetResourceProvider[] { serviceIndexResourceProvider.Object }); provider.AddOrUpdateSourceRepository(sourceRepository); var request = CreateRequest( MessageType.Request, new GetServiceIndexRequest(packageSource.Source)); var responseHandler = new Mock <IResponseHandler>(MockBehavior.Strict); responseHandler.Setup(x => x.SendResponseAsync( It.Is <Message>(r => r == request), It.Is <GetServiceIndexResponse>(r => r.ResponseCode == MessageResponseCode.Success && r.ServiceIndex.ToString(Formatting.None) == serviceIndex.ToString(Formatting.None)), It.IsAny <CancellationToken>())) .Returns(Task.FromResult(0)); await provider.HandleResponseAsync( Mock.Of <IConnection>(), request, responseHandler.Object, CancellationToken.None); responseHandler.Verify(); } }
/// <summary> /// Asynchronously handles responding to a request. /// </summary> /// <param name="connection">The connection.</param> /// <param name="request">A request message.</param> /// <param name="responseHandler">A response handler.</param> /// <param name="cancellationToken">A cancellation token.</param> /// <returns>A task that represents the asynchronous operation.</returns> /// <exception cref="ArgumentNullException">Thrown if <paramref name="connection" /> /// is <c>null</c>.</exception> /// <exception cref="ArgumentNullException">Thrown if <paramref name="request" /> is <c>null</c>.</exception> /// <exception cref="ArgumentNullException">Thrown if <paramref name="responseHandler" /> /// is <c>null</c>.</exception> /// <exception cref="OperationCanceledException">Thrown if <paramref name="cancellationToken" /> /// is cancelled.</exception> public async Task HandleResponseAsync( IConnection connection, Message request, IResponseHandler responseHandler, CancellationToken cancellationToken) { if (connection == null) { throw new ArgumentNullException(nameof(connection)); } if (request == null) { throw new ArgumentNullException(nameof(request)); } if (responseHandler == null) { throw new ArgumentNullException(nameof(responseHandler)); } cancellationToken.ThrowIfCancellationRequested(); var getRequest = MessageUtilities.DeserializePayload <GetServiceIndexRequest>(request); SourceRepository sourceRepository; ServiceIndexResourceV3 serviceIndex = null; GetServiceIndexResponse responsePayload; if (_repositories.TryGetValue(getRequest.PackageSourceRepository, out sourceRepository)) { serviceIndex = await sourceRepository.GetResourceAsync <ServiceIndexResourceV3>(cancellationToken) .ConfigureAwait(false); } if (serviceIndex == null) { responsePayload = new GetServiceIndexResponse(MessageResponseCode.NotFound, serviceIndex: null); } else { var serviceIndexJson = JObject.Parse(serviceIndex.Json); responsePayload = new GetServiceIndexResponse(MessageResponseCode.Success, serviceIndexJson); } await responseHandler.SendResponseAsync(request, responsePayload, cancellationToken).ConfigureAwait(false); }
/// <summary> /// Ensure index.json has been loaded. /// </summary> private async Task EnsureServiceIndexAsync(Uri uri, CancellationToken token) { if (_serviceIndex == null) { await EnsureHttpSourceAsync(); var index = await _httpSource.GetJObjectAsync(_indexUri, _cacheContext, _log, token); var resources = (index["resources"] as JArray); if (resources == null) { throw new InvalidOperationException($"{uri.AbsoluteUri} does not contain a 'resources' property. Use the root service index.json for the nuget v3 feed."); } _serviceIndex = new ServiceIndexResourceV3(index, DateTime.UtcNow); } }
private static SourceRepository CreateSourceRepository( ServiceIndexResourceV3 serviceIndexResource, string sourceUri) { var packageSource = new PackageSource(sourceUri); var provider = new Mock <ServiceIndexResourceV3Provider>(); provider.Setup(x => x.Name) .Returns(nameof(ServiceIndexResourceV3Provider)); provider.Setup(x => x.ResourceType) .Returns(typeof(ServiceIndexResourceV3)); var tryCreateResult = new Tuple <bool, INuGetResource>(serviceIndexResource != null, serviceIndexResource); provider.Setup(x => x.TryCreate(It.IsAny <SourceRepository>(), It.IsAny <CancellationToken>())) .Returns(Task.FromResult(tryCreateResult)); return(new SourceRepository(packageSource, new[] { provider.Object })); }
public override int Execute() { if (_printDownloadLinkOnly || !string.IsNullOrWhiteSpace(_fromCacheOption)) { SourceRepository source = Repository.Factory.GetCoreV3("https://www.myget.org/F/mockworkloadfeed/api/v3/index.json"); ServiceIndexResourceV3 serviceIndexResource = source.GetResourceAsync <ServiceIndexResourceV3>().Result; IReadOnlyList <Uri> packageBaseAddress = serviceIndexResource?.GetServiceEntryUris(ServiceTypes.PackageBaseAddress); List <string> allPackageUrl = new List <string>(); if (_printDownloadLinkOnly) { allPackageUrl.Add(nupkgUrl(packageBaseAddress.First().ToString(), "Microsoft.iOS.Bundle", NuGetVersion.Parse("6.0.100"))); allPackageUrl.Add(nupkgUrl(packageBaseAddress.First().ToString(), "Microsoft.NET.Workload.Android", NuGetVersion.Parse("6.0.100"))); Reporter.Output.WriteLine("==allPackageLinksJsonOutputStart=="); Reporter.Output.WriteLine(JsonSerializer.Serialize(allPackageUrl)); Reporter.Output.WriteLine("==allPackageLinksJsonOutputEnd=="); } if (!string.IsNullOrWhiteSpace(_fromCacheOption)) { Directory.CreateDirectory(MockUpdateDirectory); File.Copy(Path.Combine(_fromCacheOption, "Microsoft.NET.Workload.Android.6.0.100.nupkg"), Path.Combine(MockUpdateDirectory, "Microsoft.NET.Workload.Android.6.0.100.nupkg")); File.Copy(Path.Combine(_fromCacheOption, "Microsoft.iOS.Bundle.6.0.100.nupkg"), Path.Combine(MockUpdateDirectory, "Microsoft.iOS.Bundle.6.0.100.nupkg")); } } else { UpdateWorkloads(_includePreviews); } return(0); }
public override async Task <Tuple <bool, INuGetResource> > TryCreate(SourceRepository source, CancellationToken token) { ApiAppSearchResource resource = null; var messageHandlerResource = await source.GetResourceAsync <HttpHandlerResource>(token); ServiceIndexResourceV3 serviceIndex = await source.GetResourceAsync <ServiceIndexResourceV3>(); if (messageHandlerResource != null && serviceIndex != null) { var endpoints = serviceIndex["ApiAppSearchQueryService"]; if (endpoints.Any()) { RawSearchResourceV3 rawSearch = new RawSearchResourceV3(messageHandlerResource.MessageHandler, endpoints); resource = new ApiAppSearchResource(rawSearch); } } return(new Tuple <bool, INuGetResource>(resource != null, resource)); }
public async Task CanReadPackageInfo() { string nuGetOrgFeed = "https://api.nuget.org/v3/index.json"; var repository = Repository.Factory.GetCoreV3(nuGetOrgFeed); ServiceIndexResourceV3 indexResource = repository.GetResource <ServiceIndexResourceV3>(); IReadOnlyList <ServiceIndexEntry> searchResources = indexResource.GetServiceEntries("SearchQueryService"); string queryString = $"{searchResources[0].Uri}?q=Microsoft.DotNet.Common.ProjectTemplates.5.0&skip=0&take=10&prerelease=true&semVerLevel=2.0.0"; Uri queryUri = new Uri(queryString); using (HttpClient client = new HttpClient()) using (HttpResponseMessage response = await client.GetAsync(queryUri, CancellationToken.None).ConfigureAwait(false)) { if (response.IsSuccessStatusCode) { string responseText = await response.Content.ReadAsStringAsync(CancellationToken.None).ConfigureAwait(false); NuGetPackageSearchResult resultsForPage = NuGetPackageSearchResult.FromJObject(JObject.Parse(responseText)); Assert.Equal(1, resultsForPage.TotalHits); Assert.Equal(1, resultsForPage.Data.Count); var packageInfo = resultsForPage.Data[0]; Assert.Equal("Microsoft.DotNet.Common.ProjectTemplates.5.0", packageInfo.Name); Assert.NotEmpty(packageInfo.Version); Assert.True(packageInfo.TotalDownloads > 0); Assert.True(packageInfo.Verified); Assert.Contains("Microsoft", packageInfo.Owners); Assert.NotEmpty(packageInfo.Description); Assert.NotEmpty(packageInfo.IconUrl); } else { Assert.True(false, "HTTP request failed."); } } }
private static ServiceIndexResourceV3Provider CreateServiceIndexResourceV3Provider(params ServiceIndexEntry[] entries) { var provider = new Mock <ServiceIndexResourceV3Provider>(); provider.Setup(x => x.Name) .Returns(nameof(ServiceIndexResourceV3Provider)); provider.Setup(x => x.ResourceType) .Returns(typeof(ServiceIndexResourceV3)); var resources = new JArray(); foreach (var entry in entries) { resources.Add( new JObject( new JProperty("@id", entry.Uri.AbsoluteUri), new JProperty("@type", entry.Type))); } var index = new JObject(); index.Add("version", "3.0.0"); index.Add("resources", resources); index.Add("@context", new JObject( new JProperty("@vocab", "http://schema.nuget.org/schema#"), new JProperty("comment", "http://www.w3.org/2000/01/rdf-schema#comment"))); var serviceIndexResource = new ServiceIndexResourceV3(index, DateTime.UtcNow); var tryCreateResult = new Tuple <bool, INuGetResource>(true, serviceIndexResource); provider.Setup(x => x.TryCreate(It.IsAny <SourceRepository>(), It.IsAny <CancellationToken>())) .Returns(Task.FromResult(tryCreateResult)); return(provider.Object); }
private async Task <IEnumerable <PluginCreationResult> > GetPluginsForPackageSourceAsync( string packageSourceRepository, ServiceIndexResourceV3 serviceIndex, IEnumerable <PluginDiscoveryResult> results, CancellationToken cancellationToken) { var pluginCreationResults = new List <PluginCreationResult>(); var serviceIndexJson = JObject.Parse(serviceIndex.Json); foreach (var result in results) { PluginCreationResult pluginCreationResult = null; if (result.PluginFile.State == PluginFileState.Valid) { var plugin = await _pluginFactory.GetOrCreateAsync( result.PluginFile.Path, PluginConstants.PluginArguments, new RequestHandlers(), _connectionOptions, cancellationToken); var utilities = _pluginUtilities.GetOrAdd( plugin.Id, path => new Lazy <IPluginMulticlientUtilities>( () => new PluginMulticlientUtilities())); await utilities.Value.DoOncePerPluginLifetimeAsync( MessageMethod.MonitorNuGetProcessExit.ToString(), () => plugin.Connection.SendRequestAndReceiveResponseAsync <MonitorNuGetProcessExitRequest, MonitorNuGetProcessExitResponse>( MessageMethod.MonitorNuGetProcessExit, new MonitorNuGetProcessExitRequest(_currentProcessId.Value), cancellationToken), cancellationToken); await utilities.Value.DoOncePerPluginLifetimeAsync( MessageMethod.Initialize.ToString(), () => InitializePluginAsync(plugin, _connectionOptions.RequestTimeout, cancellationToken), cancellationToken); var lazyOperationClaims = _pluginOperationClaims.GetOrAdd( new PluginPackageSourceKey(result.PluginFile.Path, packageSourceRepository), key => new Lazy <Task <IReadOnlyList <OperationClaim> > >(() => GetPluginOperationClaimsAsync( plugin, packageSourceRepository, serviceIndexJson, cancellationToken))); await lazyOperationClaims.Value; pluginCreationResult = new PluginCreationResult( plugin, utilities.Value, lazyOperationClaims.Value.Result); } else { pluginCreationResult = new PluginCreationResult(result.Message); } pluginCreationResults.Add(pluginCreationResult); } return(pluginCreationResults); }
/// <summary> /// Determine the NuGet package sources configured for the current project and create clients for them. /// </summary> /// <param name="cancellationToken"> /// An optional <see cref="CancellationToken"/> that can be used to cancel the operation. /// </param> /// <returns> /// <c>true</c>, if the package sources were loaded; otherwise, <c>false</c>. /// </returns> public virtual async Task <bool> ConfigurePackageSources(CancellationToken cancellationToken = default(CancellationToken)) { try { _configuredPackageSources.Clear(); _autoCompleteResources.Clear(); bool includeLocalSources = Workspace.Configuration.NuGet.IncludeLocalSources; HashSet <string> ignoredPackageSources = Workspace.Configuration.NuGet.IgnorePackageSources; foreach (PackageSource packageSource in NuGetHelper.GetWorkspacePackageSources(ProjectFile.Directory.FullName)) { // Exclude package sources explicitly ignored by name. string packageSourceName = packageSource.Name ?? "<unknown>"; if (ignoredPackageSources.Contains(packageSourceName)) { Log.Verbose("Ignoring package source named {PackageSourceName} (the language server has been explicitly configured to ignore it).", packageSourceName); continue; } // Exclude package sources explicitly ignored by URI. Uri packageSourceUri = packageSource.TrySourceAsUri ?? new Uri("unknown:/", UriKind.Absolute); if (ignoredPackageSources.Contains(packageSourceUri.AbsoluteUri)) { Log.Verbose("Ignoring package source with URI {PackageSourceURI} (the language server has been explicitly configured to ignore it).", packageSourceUri.AbsoluteUri); continue; } // Exclude unsupported package-source types. if (!packageSource.IsHttp) { if (packageSourceUri.Scheme == Uri.UriSchemeFile) { if (!includeLocalSources) { Log.Verbose("Ignoring local package source {PackageSourceName} ({PackageSourcePath}) (the language server has not been configured to use local package sources).", packageSourceName, packageSourceUri.AbsolutePath ); continue; } } else { Log.Verbose("Ignoring local package source {PackageSourceName} ({PackageSourceUri}) (the language server only supports local and HTTP-based package sources).", packageSourceName, packageSourceUri.AbsolutePath ); continue; } } _configuredPackageSources.Add(packageSource); } Log.Information("{PackageSourceCount} package sources configured for project {ProjectFile}.", _configuredPackageSources.Count, VSCodeDocumentUri.GetFileSystemPath(DocumentUri) ); foreach (PackageSource packageSource in _configuredPackageSources) { if (packageSource.IsMachineWide) { Log.Information(" Globally-configured package source {PackageSourceName} (v{PackageSourceProtocolVersion}) => {PackageSourceUri}", packageSource.Name, packageSource.ProtocolVersion, packageSource.SourceUri ); } else { Log.Information(" Locally-configured package source {PackageSourceName} (v{PackageSourceProtocolVersion}) => {PackageSourceUri}", packageSource.Name, packageSource.ProtocolVersion, packageSource.SourceUri ); } } List <SourceRepository> sourceRepositories = _configuredPackageSources.CreateResourceRepositories(); foreach (SourceRepository sourceRepository in sourceRepositories) { ServiceIndexResourceV3 serviceIndex = await sourceRepository.GetResourceAsync <ServiceIndexResourceV3>(cancellationToken); if (serviceIndex == null) { Log.Warning(" Ignoring configured package source {PackageSourceName} ({PackageSourceUri}) because the v3 service index cannot be found for this package source.", sourceRepository.PackageSource.Name ?? "<unknown>", sourceRepository.PackageSource.TrySourceAsUri?.AbsoluteUri ?? "unknown:/" ); continue; } IReadOnlyList <ServiceIndexEntry> autoCompleteServices = serviceIndex.GetServiceEntries(ServiceTypes.SearchAutocompleteService); if (autoCompleteServices.Count == 0) { Log.Warning(" Ignoring configured package source {PackageSourceName} ({PackageSourceUri}) because it does not appear to support a compatible version of the NuGet auto-complete API.", sourceRepository.PackageSource.Name ?? "<unknown>", sourceRepository.PackageSource.TrySourceAsUri?.AbsoluteUri ?? "unknown:/" ); continue; } AutoCompleteResource autoCompleteResource = await sourceRepository.GetResourceAsync <AutoCompleteResource>(cancellationToken); if (autoCompleteResource == null) { // Should not happen. Log.Error("Failed to retrieve {ServiceName} service instance for configured package source {PackageSourceName} ({PackageSourceUri}).", "AutoComplete", sourceRepository.PackageSource.Name ?? "<unknown>", sourceRepository.PackageSource.TrySourceAsUri?.AbsoluteUri ?? "unknown:/" ); continue; } _autoCompleteResources.Add(autoCompleteResource); } return(true); } catch (Exception packageSourceLoadError) { Log.Error(packageSourceLoadError, "Error configuring NuGet package sources for MSBuild project '{ProjectFileName}'.", ProjectFile.FullName); return(false); } }
internal static Uri GetSleetPackageIndexUrl(this ServiceIndexResourceV3 serviceIndex) { return(serviceIndex.GetServiceUri(SleetPackageIndexUrl)); }
public override int Execute() { // TODO stub Reporter.Output.WriteLine($"WIP workload install {string.Join("; ", _workloadIds)}"); List <string> allowedMockWorkloads = new List <string> { "mobile-ios", "mobile-android" }; if (!_printDownloadLinkOnly && string.IsNullOrWhiteSpace(_fromCacheOption)) { Reporter.Output.WriteLine( "mock currently does not support normal install. Need --print-download-link-only or --from-cache"); } if (_workloadIds.Except(allowedMockWorkloads).Any()) { Reporter.Output.WriteLine("Only support \"mobile-ios\", \"mobile-android\" in the mock"); } SourceRepository source = Repository.Factory.GetCoreV3("https://www.myget.org/F/mockworkloadfeed/api/v3/index.json"); ServiceIndexResourceV3 serviceIndexResource = source.GetResourceAsync <ServiceIndexResourceV3>().Result; IReadOnlyList <Uri> packageBaseAddress = serviceIndexResource?.GetServiceEntryUris(ServiceTypes.PackageBaseAddress); List <string> allPackageUrl = new List <string>(); if (_printDownloadLinkOnly) { if (_workloadIds.Contains("mobile-ios")) { allPackageUrl.Add(nupkgUrl(packageBaseAddress.First().ToString(), "Microsoft.iOS.Bundle", NuGetVersion.Parse("6.0.100"))); AddNewtonsoftJson(allPackageUrl); } if (_workloadIds.Contains("mobile-android")) { allPackageUrl.Add(nupkgUrl(packageBaseAddress.First().ToString(), "Microsoft.NET.Workload.Android", NuGetVersion.Parse("6.0.100"))); AddNewtonsoftJson(allPackageUrl); } Reporter.Output.WriteLine("==allPackageLinksJsonOutputStart=="); Reporter.Output.WriteLine(JsonSerializer.Serialize(allPackageUrl)); Reporter.Output.WriteLine("==allPackageLinksJsonOutputEnd=="); } if (!string.IsNullOrWhiteSpace(_fromCacheOption)) { Directory.CreateDirectory(MockInstallDirectory); if (_workloadIds.Contains("mobile-android")) { File.Copy(Path.Combine(_fromCacheOption, "Microsoft.NET.Workload.Android.6.0.100.nupkg"), Path.Combine(MockInstallDirectory, "Microsoft.NET.Workload.Android.6.0.100.nupkg")); } if (_workloadIds.Contains("mobile-ios")) { File.Copy(Path.Combine(_fromCacheOption, "Microsoft.iOS.Bundle.6.0.100.nupkg"), Path.Combine(MockInstallDirectory, "Microsoft.iOS.Bundle.6.0.100.nupkg")); } } return(0); }
internal static Uri GetPackageBaseAddressUri(this ServiceIndexResourceV3 serviceIndex) { return(serviceIndex.GetCatalogServiceUri(PackageBaseAddressUrl)); }
internal static Uri GetCatalogServiceUri(this ServiceIndexResourceV3 serviceIndex) { return(serviceIndex.GetCatalogServiceUri(CatalogServiceUrl)); }
internal static Uri GetRegistrationBaseUri(this ServiceIndexResourceV3 serviceIndex) { return(serviceIndex.GetCatalogServiceUri(RegistrationsBaseUrl)); }