public async Task <IReadOnlyList <(ITemplatePackageInfo PackageInfo, IReadOnlyList <ITemplateInfo> MatchedTemplates)> > SearchForTemplatePackagesAsync(
Func <TemplatePackageSearchData, bool> packFilter,
Func <TemplatePackageSearchData, IReadOnlyList <ITemplateInfo> > matchingTemplatesFilter,
CancellationToken cancellationToken)
{
cancellationToken.ThrowIfCancellationRequested();
if (_searchCache == null)
{
_logger.LogDebug("Initializing search cache...");
string metadataLocation = await GetSearchFileAsync(cancellationToken).ConfigureAwait(false);
_searchCache = TemplateSearchCache.FromJObject(_environmentSettings.Host.FileSystem.ReadObject(metadataLocation), _logger, _additionalDataReaders);
_logger.LogDebug("Search cache was successfully setup.");
}
IEnumerable <TemplatePackageSearchData> filteredPackages = _searchCache.TemplatePackages.Where(package => packFilter(package));
_logger.LogDebug("Retrieved {0} packages matching package search criteria.", filteredPackages.Count());
List <(ITemplatePackageInfo PackageInfo, IReadOnlyList <ITemplateInfo> MatchedTemplates)> matchingTemplates = filteredPackages
.Select <TemplatePackageSearchData, (ITemplatePackageInfo PackageInfo, IReadOnlyList <ITemplateInfo> MatchedTemplates)>(package => (package, matchingTemplatesFilter(package)))
.Where(result => result.MatchedTemplates.Any())
.ToList();
_logger.LogDebug("Retrieved {0} packages matching template search criteria.", matchingTemplates.Count);
return(matchingTemplates);
}
private static void WriteSearchMetadata(PackSourceCheckResult packSourceCheckResults, string outputFileName)
{
TemplateSearchCache searchMetadata = packSourceCheckResults.SearchCache;
File.WriteAllText(outputFileName, searchMetadata.ToJObject().ToString(Formatting.None));
Console.WriteLine($"Search cache file created: {outputFileName}");
}
private static string SetupInvalidTemplateCache(string fileLocation)
{
var packOne = new TemplatePackageSearchData(new MockTemplatePackageInfo("PackOne", "1.0.0"), new[] { new TemplateSearchData(new MockTemplateInfo("foo", "foo", "foo").WithParameters("Config type", "Main type", "unknown")) });
var cache = new TemplateSearchCache(new[] { packOne });
JObject toSerialize = JObject.FromObject(cache);
string targetPath = Path.Combine(fileLocation, "searchCacheV2.json");
File.WriteAllText(targetPath, toSerialize.ToString());
return(targetPath);
}
public void CanSkipInvalidEntriesSearchMetadata()
{
var environmentSettings = _environmentSettingsHelper.CreateEnvironment(virtualize: true);
string content = File.ReadAllText("NuGetTemplateSearchInfoWithInvalidData.json");
JObject cache = JObject.Parse(content);
var parsedCache = TemplateSearchCache.FromJObject(cache, environmentSettings.Host.Logger);
Assert.Equal(1, parsedCache.TemplatePackages.Count);
Assert.Equal(1, parsedCache.TemplatePackages.Sum(p => p.Templates.Count));
Assert.IsAssignableFrom <ITemplateInfo>(parsedCache.TemplatePackages[0].Templates[0]);
Assert.Equal("Microsoft.AzureFunctions.ProjectTemplate.CSharp.3.x", ((ITemplateInfo)parsedCache.TemplatePackages[0].Templates[0]).Identity);
}
private string GenerateLocalCache()
{
ITemplatePackageInfo packOneInfo = new MockTemplatePackageInfo("PackOne", "1.0.0");
ITemplatePackageInfo packTwoInfo = new MockTemplatePackageInfo("PackTwo", "1.6.0");
ITemplatePackageInfo packThreeInfo = new MockTemplatePackageInfo("PackThree", "2.1");
ITemplateInfo fooOneTemplate =
new MockTemplateInfo("foo1", name: "MockFooTemplateOne", identity: "Mock.Foo.1", groupIdentity: "Mock.Foo", author: "TestAuthor")
.WithClassifications("CSharp", "Library")
.WithDescription("Mock Foo template one")
.WithChoiceParameter("Framework", "netcoreapp3.0", "netcoreapp3.1")
.WithTag("language", "C#")
.WithTag("type", "project");
ITemplateInfo fooTwoTemplate =
new MockTemplateInfo("foo2", name: "MockFooTemplateTwo", identity: "Mock.Foo.2", groupIdentity: "Mock.Foo")
.WithClassifications("CSharp", "Console")
.WithDescription("Mock Foo template two")
.WithChoiceParameter("Framework", "netcoreapp2.0", "netcoreapp2.1", "netcoreapp3.1")
.WithTag("language", "C#");
ITemplateInfo barCSharpTemplate =
new MockTemplateInfo("barC", name: "MockBarCsharpTemplate", identity: "Mock.Bar.1.Csharp", groupIdentity: "Mock.Bar")
.WithClassifications("CSharp")
.WithDescription("Mock Bar CSharp template")
.WithTag("language", "C#");
ITemplateInfo barFSharpTemplate =
new MockTemplateInfo("barF", name: "MockBarFSharpTemplate", identity: "Mock.Bar.1.FSharp", groupIdentity: "Mock.Bar")
.WithClassifications("FSharp")
.WithDescription("Mock Bar FSharp template")
.WithTag("language", "F#");
var fooOneTemplateData = new TemplateSearchData(fooOneTemplate);
var fooTwoTemplateData = new TemplateSearchData(fooTwoTemplate);
var barCSharpTemplateData = new TemplateSearchData(barCSharpTemplate);
var barFSharpTemplateData = new TemplateSearchData(barFSharpTemplate);
var packOne = new TemplatePackageSearchData(packOneInfo, new[] { fooOneTemplateData });
var packTwo = new TemplatePackageSearchData(packTwoInfo, new[] { fooTwoTemplateData });
var packThree = new TemplatePackageSearchData(packThreeInfo, new[] { barCSharpTemplateData, barFSharpTemplateData });
var cache = new TemplateSearchCache(new[] { packOne, packTwo, packThree });
string targetPath = Path.Combine(TestUtils.CreateTemporaryFolder(), "searchCacheV2.json");
File.WriteAllText(targetPath, cache.ToJObject().ToString());
return(targetPath);
}
#pragma warning restore CS0618 // Type or member is obsolete
private static string SetupTemplateCache(string fileLocation, bool includehostData = false)
{
Dictionary <string, string> frameworkParamSymbolInfo = new Dictionary <string, string>()
{
{ "longName", "framework" },
{ "shortName", "f" }
};
HostSpecificTemplateData fooTemplateHostData = new MockHostSpecificTemplateData(
new Dictionary <string, IReadOnlyDictionary <string, string> >()
{
{ "Framework", frameworkParamSymbolInfo }
}
);
Dictionary <string, object> additionalData = new Dictionary <string, object>()
{
{ CliHostSearchCacheData.DataName, fooTemplateHostData }
};
List <ITemplateInfo> templateCache = new List <ITemplateInfo>();
templateCache.Add(_fooOneTemplate);
templateCache.Add(_fooTwoTemplate);
templateCache.Add(_barCSharpTemplate);
templateCache.Add(_barFSharpTemplate);
var fooOneTemplateData = new TemplateSearchData(_fooOneTemplate, includehostData ? additionalData : null);
var fooTwoTemplateData = new TemplateSearchData(_fooTwoTemplate, includehostData ? additionalData : null);
var barCSharpTemplateData = new TemplateSearchData(_barCSharpTemplate, null);
var barFSharpTemplateData = new TemplateSearchData(_barFSharpTemplate, null);
var packOne = new TemplatePackageSearchData(_packOneInfo, new[] { fooOneTemplateData });
var packTwo = new TemplatePackageSearchData(_packTwoInfo, new[] { fooTwoTemplateData });
var packThree = new TemplatePackageSearchData(_packThreeInfo, new[] { barCSharpTemplateData, barFSharpTemplateData });
var cache = new TemplateSearchCache(new[] { packOne, packTwo, packThree });
JObject toSerialize = JObject.FromObject(cache);
string targetPath = Path.Combine(fileLocation, "searchCacheV2.json");
File.WriteAllText(targetPath, toSerialize.ToString());
return(targetPath);
}
public void CanReadSearchMetadata()
{
var environmentSettings = _environmentSettingsHelper.CreateEnvironment(virtualize: true);
string content = File.ReadAllText("NuGetTemplateSearchInfo.json");
JObject cache = JObject.Parse(content);
var parsedCache = TemplateSearchCache.FromJObject(cache, environmentSettings.Host.Logger);
Assert.Equal(1, parsedCache.TemplatePackages.Count);
Assert.Equal(2, parsedCache.TemplatePackages.Sum(p => p.Templates.Count));
Assert.IsAssignableFrom <ITemplateInfo>(parsedCache.TemplatePackages[0].Templates[0]);
//can read tags
Assert.Equal(2, ((ITemplateInfo)parsedCache.TemplatePackages[0].Templates[0]).TagsCollection.Count);
//can read parameters
Assert.Equal(5, ((ITemplateInfo)parsedCache.TemplatePackages[0].Templates[0]).Parameters.Count);
}
private static TemplateSearchCache?LoadExistingCache(CommandArgs config)
{
if (!config.DiffMode || config.DiffOverrideSearchCacheLocation == null)
{
return(null);
}
FileInfo?cacheFileLocation = config.DiffOverrideSearchCacheLocation;
Verbose.WriteLine($"Opening {cacheFileLocation.FullName}");
using (var fileStream = cacheFileLocation.OpenRead())
using (var textReader = new StreamReader(fileStream, System.Text.Encoding.UTF8, true))
using (var jsonReader = new JsonTextReader(textReader))
{
return(TemplateSearchCache.FromJObject(JObject.Load(jsonReader), NullLogger.Instance, new Dictionary <string, Func <object, object> >()
{
{ CliHostSearchCacheData.DataName, CliHostSearchCacheData.Reader }
}));
}
}
private static async Task <TemplateSearchCache?> LoadExistingCacheAsync(CommandArgs config, CancellationToken cancellationToken)
{
Verbose.WriteLine($"Loading existing cache information.");
const string uri = "https://dotnet-templating.azureedge.net/search/NuGetTemplateSearchInfoVer2.json";
FileInfo?cacheFileLocation = config.DiffOverrideSearchCacheLocation;
if (cacheFileLocation == null)
{
await DownloadUriToFileAsync(uri, "currentSearchCache.json", cancellationToken).ConfigureAwait(false);
cacheFileLocation = new FileInfo("currentSearchCache.json");
}
Verbose.WriteLine($"Opening {cacheFileLocation.FullName}");
using (var fileStream = cacheFileLocation.OpenRead())
using (var textReader = new StreamReader(fileStream, System.Text.Encoding.UTF8, true))
using (var jsonReader = new JsonTextReader(textReader))
{
return(TemplateSearchCache.FromJObject(JObject.Load(jsonReader), NullLogger.Instance, new Dictionary <string, Func <object, object> >()
{
{ CliHostSearchCacheData.DataName, CliHostSearchCacheData.Reader }
}));
}
}
internal PackSourceCheckResult(TemplateSearchCache generatedSearchCache, IReadOnlyList <FilteredPackageInfo> filteredPackages, IReadOnlyList <IAdditionalDataProducer> additionalDataHandlers)
{
SearchCache = generatedSearchCache;
FilteredPackages = filteredPackages;
AdditionalDataProducers = additionalDataHandlers;
}
