/// <summary>
/// Polymorphic instantiation from template function
/// </summary>
/// <remarks>
/// Each time we add a resolver, we'll have to add the instance here.
/// </remarks>
public static ResolverSettings CreateFromTemplate(IResolverSettings resolverSettings, PathRemapper pathRemapper)
{
Contract.Requires(resolverSettings != null);
Contract.Requires(pathRemapper != null);
switch (resolverSettings)
{
case IDScriptResolverSettings sourceResolver:
return(new SourceResolverSettings(sourceResolver, pathRemapper));
case IDefaultSourceResolverSettings defaultResolver:
return(new DefaultSourceResolverSettings(defaultResolver, pathRemapper));
case INugetResolverSettings nugetResolver:
return(new NugetResolverSettings(nugetResolver, pathRemapper));
case IDownloadResolverSettings downloadResolver:
return(new DownloadResolverSettings(downloadResolver, pathRemapper));
case IMsBuildResolverSettings msBuildResolver:
return(new MsBuildResolverSettings(msBuildResolver, pathRemapper));
case INinjaResolverSettings ninjaResolver:
return(new NinjaResolverSettings(ninjaResolver, pathRemapper));
case ICMakeResolverSettings cmakeResolver:
return(new CMakeResolverSettings(cmakeResolver, pathRemapper));
default:
Contract.Assume(false, "Unexpected type of resolver settings.");
return(null);
}
}
/// <nodoc/>
public virtual async Task <bool> InitResolverAsync(IResolverSettings resolverSettings, object workspaceResolver)
{
Contract.Requires(resolverSettings != null);
Contract.Assert(m_resolverState == State.Created);
var sourceResolverSettings = resolverSettings as IDScriptResolverSettings;
Contract.Assert(sourceResolverSettings != null, "Wrong type for resolver");
Name = resolverSettings.Name;
m_resolverState = State.ResolverInitializing;
m_workspaceSourceModuleResolver = workspaceResolver as WorkspaceSourceModuleResolver;
Contract.Assert(m_workspaceSourceModuleResolver != null, "Workspace module resolver is expected to be of source type");
var moduleResolutionResult = await m_workspaceSourceModuleResolver.ResolveModuleAsyncIfNeeded();
if (!moduleResolutionResult.Succeeded)
{
// Error should have been reported.
return(false);
}
m_packageDirectories = moduleResolutionResult.PackageDirectories;
m_packages = moduleResolutionResult.Packages;
m_owningModules = moduleResolutionResult.Packages.ToDictionary(p => p.Value.ModuleId, p => p.Value);
m_resolverState = State.ResolverInitialized;
return(true);
}
/// <inheritdoc/>
public bool TryCreateWorkspaceResolver(IResolverSettings resolverSettings, out IWorkspaceModuleResolver workspaceResolver)
{
workspaceResolver = m_workspaceResolverCache.GetOrAdd(
resolverSettings,
(settings) =>
{
IWorkspaceModuleResolver resolver;
if (string.Equals(resolverSettings.Kind, KnownResolverKind.DefaultSourceResolverKind, System.StringComparison.Ordinal))
{
resolver = new WorkspaceDefaultSourceModuleResolver(Context.StringTable, FrontEndStatistics, logger: m_customLogger);
}
else
{
resolver = new WorkspaceSourceModuleResolver(Context.StringTable, FrontEndStatistics, logger: m_customLogger);
}
if (resolver.TryInitialize(FrontEndHost, Context, Configuration, settings))
{
return(resolver);
}
return(null);
});
return(workspaceResolver != null);
}
/// <summary>
/// To avoid re-computations, the factory keeps track of resolvers already instantiated for a given <param name="resolverSettings"/>.
/// An existing resolver is returned (instead of creating a new one) if it has been previously instantiated.
/// </summary>
/// <remarks>
/// This method is not thread safe.
/// </remarks>
public Possible <IWorkspaceModuleResolver> TryGetResolver(IResolverSettings resolverSettings)
{
Contract.Requires(resolverSettings != null);
if (!IsRegistered(resolverSettings.Kind))
{
Contract.Assert(false, "Kind '" + resolverSettings.Kind + "' is not registered.");
}
Contract.Assert(IsInitialized);
// Check if there is an already instantiated resolver for this settings
if (m_instantiatedResolvers.TryGetValue(resolverSettings, out var resolver))
{
return(new Possible <IWorkspaceModuleResolver>(resolver));
}
// There is not, so we need to create and instantiate one.
resolver = m_registeredKinds[resolverSettings.Kind]();
if (!resolver.TryInitialize(m_frontEndHost, m_frontEndContext, m_configuration, resolverSettings, m_requestedQualifiers))
{
return(new WorkspaceModuleResolverGenericInitializationFailure(resolverSettings.Kind));
}
m_instantiatedResolvers[resolverSettings] = resolver;
return(new Possible <IWorkspaceModuleResolver>(resolver));
}
/// <nodoc />
public UntrackingResolverSettings(IResolverSettings template, IUntrackingSettings untrackingTemplate, PathRemapper pathRemapper) : base(template, pathRemapper)
{
UntrackedDirectoryScopes = untrackingTemplate.UntrackedDirectoryScopes;
UntrackedFiles = untrackingTemplate.UntrackedFiles;
UntrackedDirectories = untrackingTemplate.UntrackedDirectories;
UntrackedGlobalDirectoryScopes = untrackingTemplate.UntrackedGlobalDirectoryScopes;
ChildProcessesToBreakawayFromSandbox = untrackingTemplate.ChildProcessesToBreakawayFromSandbox;
}
/// <inheritdoc />
public bool TryInitialize(
[NotNull] FrontEndHost host,
[NotNull] FrontEndContext context,
[NotNull] IConfiguration configuration,
[NotNull] IResolverSettings resolverSettings,
[NotNull] QualifierId[] requestedQualifiers)
{
return(true);
}
/// <nodoc/>
public SimpleWorkspaceSourceModuleResolver(IResolverSettings resolverSettings)
{
var sourceResolverSettings = resolverSettings as SimpleSourceResolverSettings;
Contract.Assert(sourceResolverSettings != null);
Name = resolverSettings.Name;
m_moduleDefinitions = sourceResolverSettings.ModuleDefinitions;
m_fileSystem = sourceResolverSettings.FileSystem;
}
/// <inheritdoc />
/// <summary>
/// Initializes the workspace resolver
/// </summary>
public bool TryInitialize(
FrontEndHost host,
FrontEndContext context,
IConfiguration configuration,
IResolverSettings resolverSettings,
QualifierId[] requestedQualifiers)
{
m_host = host;
m_context = context;
m_resolverSettings = resolverSettings as INinjaResolverSettings;
Contract.Assert(m_resolverSettings != null);
var relativePathToGraphConstructionTool = RelativePath.Create(context.StringTable, NinjaGraphBuilderRelativePath);
m_pathToTool = configuration.Layout.BuildEngineDirectory.Combine(m_context.PathTable, relativePathToGraphConstructionTool);
if (!m_resolverSettings.ProjectRoot.IsValid)
{
if (!m_resolverSettings.SpecFile.IsValid)
{
Tracing.Logger.Log.InvalidResolverSettings(m_context.LoggingContext, m_resolverSettings.Location(m_context.PathTable), "Either a project root or a spec file location (or both) must be specified.");
return(false);
}
ProjectRoot = m_resolverSettings.SpecFile.GetParent(m_context.PathTable);
SpecFile = m_resolverSettings.SpecFile;
}
else
{
ProjectRoot = m_resolverSettings.ProjectRoot;
SpecFile = m_resolverSettings.SpecFile;
if (!m_resolverSettings.SpecFile.IsValid)
{
SpecFile = ProjectRoot.Combine(m_context.PathTable, "build.ninja");
}
}
string path;
if (!Directory.Exists(path = ProjectRoot.ToString(m_context.PathTable)))
{
Tracing.Logger.Log.ProjectRootDirectoryDoesNotExist(m_context.LoggingContext, m_resolverSettings.Location(m_context.PathTable), path);
return(false);
}
if (!File.Exists(path = SpecFile.ToString(m_context.PathTable)))
{
Tracing.Logger.Log.NinjaSpecFileDoesNotExist(m_context.LoggingContext, m_resolverSettings.Location(m_context.PathTable), path);
return(false);
}
m_targets = m_resolverSettings.Targets != null?m_resolverSettings.Targets.AsArray() : CollectionUtilities.EmptyArray <string>();
return(true);
}
/// <inheritdoc/>
public Task <bool> InitResolverAsync(IResolverSettings resolverSettings, object workspaceResolver)
{
Contract.Requires(resolverSettings != null);
Name = resolverSettings.Name;
m_cMakeResolverSettings = resolverSettings as ICMakeResolverSettings;
m_cMakeWorkspaceResolver = workspaceResolver as CMakeWorkspaceResolver;
// TODO: Failure cases, logging
return(Task.FromResult <bool>(true));
}
/// <nodoc />
public ResolverSettings(IResolverSettings template, PathRemapper pathRemapper)
{
Contract.Requires(template != null);
Contract.Requires(pathRemapper != null);
Kind = template.Kind;
Name = template.Name;
File = pathRemapper.Remap(template.File);
Location = template.Location;
AllowWritableSourceDirectory = template.AllowWritableSourceDirectory;
}
/// <inheritdoc />
public Task <bool> InitResolverAsync([NotNull] IResolverSettings resolverSettings, object workspaceResolver)
{
m_workspaceResolver = workspaceResolver as DownloadWorkspaceResolver;
Contract.Assert(
m_workspaceResolver != null,
I($"Wrong type for resolver, expected {nameof(DownloadWorkspaceResolver)} but got {nameof(workspaceResolver.GetType)}"));
Name = resolverSettings.Name;
return(Task.FromResult(true));
}
/// <inheritdoc/>
public bool TryInitialize(
FrontEndHost host,
FrontEndContext context,
IConfiguration configuration,
IResolverSettings resolverSettings)
{
InitializeInterpreter(host, context, configuration);
m_resolverSettings = resolverSettings as IMsBuildResolverSettings;
Contract.Assert(m_resolverSettings != null);
return(true);
}
/// <inheritdoc />
public bool TryInitialize(
[NotNull] FrontEndHost host,
[NotNull] FrontEndContext context,
[NotNull] IConfiguration configuration,
[NotNull] IResolverSettings resolverSettings)
{
var sourceResolverSettings = resolverSettings as SimpleSourceResolverSettings;
Contract.Assert(sourceResolverSettings != null);
Name = resolverSettings.Name;
m_moduleDefinitions = sourceResolverSettings.ModuleDefinitions;
m_fileSystem = sourceResolverSettings.FileSystem;
return(true);
}
/// <inheritdoc/>
public virtual bool TryInitialize(
FrontEndHost host,
FrontEndContext context,
IConfiguration configuration,
IResolverSettings resolverSettings)
{
m_host = host;
m_context = context;
m_configuration = configuration;
m_resolverSettings = resolverSettings as TResolverSettings;
Contract.Assert(m_resolverSettings != null);
m_resolverSettings.ComputeEnvironment(out m_userDefinedEnvironment, out m_passthroughVariables, out m_processEnvironmentUsed);
return(true);
}
/// <inheritdoc/>
public bool TryCreateWorkspaceResolver(IResolverSettings resolverSettings, out IWorkspaceModuleResolver workspaceResolver)
{
workspaceResolver = m_workspaceResolverCache.GetOrAdd(
resolverSettings,
(settings) =>
{
var resolver = new WorkspaceNugetModuleResolver(Context.StringTable, FrontEndStatistics);
if (resolver.TryInitialize(FrontEndHost, Context, Configuration, settings))
{
return(resolver);
}
return(null);
});
return(workspaceResolver != null);
}
/// <inheritdoc/>
public Task <bool> InitResolverAsync(IResolverSettings resolverSettings, object workspaceResolver)
{
Name = resolverSettings.Name;
m_msBuildResolverSettings = resolverSettings as IMsBuildResolverSettings;
Contract.Assert(
m_msBuildResolverSettings != null,
I($"Wrong type for resolver settings, expected {nameof(IMsBuildResolverSettings)} but got {nameof(resolverSettings.GetType)}"));
m_msBuildWorkspaceResolver = workspaceResolver as MsBuildWorkspaceResolver;
Contract.Assert(m_msBuildWorkspaceResolver != null, I($"Wrong type for resolver, expected {nameof(MsBuildWorkspaceResolver)} but got {nameof(workspaceResolver.GetType)}"));
if (!ValidateResolverSettings(m_msBuildResolverSettings))
{
return(Task.FromResult(false));
}
return(Task.FromResult(true));
}
/// <inheritdoc/>
public bool TryInitialize(
FrontEndHost host,
FrontEndContext context,
IConfiguration configuration,
IResolverSettings resolverSettings,
QualifierId[] requestedQualifiers)
{
Contract.Requires(requestedQualifiers?.Length > 0);
InitializeInterpreter(host, context, configuration);
m_resolverSettings = resolverSettings as IMsBuildResolverSettings;
Contract.Assert(m_resolverSettings != null);
m_requestedQualifiers = requestedQualifiers;
return(true);
}
/// <inheritdoc />
public virtual bool TryCreateWorkspaceResolver(
[NotNull] IResolverSettings resolverSettings,
[NotNull] out IWorkspaceModuleResolver workspaceResolver)
{
workspaceResolver = m_workspaceResolverCache.GetOrAdd(
resolverSettings,
(settings) =>
{
var resolver = new TWorkspaceResolver();
if (resolver.TryInitialize(Host, Context, Configuration, settings))
{
return(resolver);
}
return(default(TWorkspaceResolver));
});
return(workspaceResolver != default(TWorkspaceResolver));
}
/// <inheritdoc/>
public Task <bool> InitResolverAsync(IResolverSettings resolverSettings, object workspaceResolver)
{
Name = resolverSettings.Name;
m_resolverSettings = resolverSettings as TResolverSettings;
Contract.Assert(
m_resolverSettings != null,
I($"Wrong type for resolver settings, expected {nameof(TResolverSettings)} but got {nameof(resolverSettings.GetType)}"));
m_javaScriptWorkspaceResolver = workspaceResolver as JavaScriptWorkspaceResolver <TGraphConfiguration, TResolverSettings>;
if (m_javaScriptWorkspaceResolver == null)
{
Contract.Assert(false, I($"Wrong type for resolver, expected {nameof(JavaScriptWorkspaceResolver<TGraphConfiguration, TResolverSettings>)} but got {nameof(workspaceResolver.GetType)}"));
}
if (!ValidateResolverSettings(m_resolverSettings))
{
return(Task.FromResult(false));
}
return(Task.FromResult(true));
}
/// <inheritdoc/>
public override async Task <bool> InitResolverAsync(IResolverSettings resolverSettings, object workspaceResolver)
{
Contract.Requires(resolverSettings != null);
Contract.Assert(m_resolverState == State.Created);
Contract.Assert(
resolverSettings is INugetResolverSettings,
I($"Wrong type for resolver settings, expected {nameof(INugetResolverSettings)} but got {nameof(resolverSettings.GetType)}"));
Name = resolverSettings.Name;
m_resolverState = State.ResolverInitializing;
m_nugetWorkspaceResolver = workspaceResolver as WorkspaceNugetModuleResolver;
Contract.Assert(m_nugetWorkspaceResolver != null, "Workspace module resolver is expected to be of source type");
// TODO: We could do something smarter in the future and just download/generate what is needed
// Use this result to populate the dictionaries that are used for package retrieval (m_packageDirectories, m_packages and m_owningModules)
var maybePackages = await m_nugetWorkspaceResolver.GetAllKnownPackagesAsync();
if (!maybePackages.Succeeded)
{
// Error should have been reported.
return(false);
}
m_owningModules = new Dictionary <ModuleId, Package>();
foreach (var package in maybePackages.Result)
{
m_packageDirectories[package.Path.GetParent(Context.PathTable)] = new List <Package> {
package
};
m_packages[package.Id] = package;
m_owningModules[package.ModuleId] = package;
}
m_resolverState = State.ResolverInitialized;
return(true);
}
/// <inheritdoc/>
public bool TryInitialize(
FrontEndHost host,
FrontEndContext context,
IConfiguration configuration,
IResolverSettings resolverSettings,
QualifierId[] requestedQualifiers)
{
Contract.Requires(requestedQualifiers?.Length > 0);
m_host = host;
m_context = context;
m_configuration = configuration;
m_resolverSettings = resolverSettings as IMsBuildResolverSettings;
m_resolverSettings.ComputeEnvironment(out m_userDefinedEnvironment, out m_passthroughVariables);
Contract.Assert(m_resolverSettings != null);
m_requestedQualifiers = requestedQualifiers;
return(true);
}
/// <summary>
/// Returns the resolver setting <see cref="BuildXL.Utilities.Instrumentation.Common.Location"/>
/// </summary>
public static Location Location(this IResolverSettings resolverSettings, PathTable pathTable)
{
return(new Location {
File = resolverSettings.File.ToString(pathTable), Line = resolverSettings.Location.Line, Position = resolverSettings.Location.Position
});
}
/// <summary>
/// If both <see cref="IResolverSettings.File"/> and <see cref="IResolverSettings.Location"/> information
/// are present, it returns in the format of $"{file}:({line}, {position}): "; else, returns empty string.
/// </summary>
public static string GetLocationInfo(this IResolverSettings resolver, PathTable pathTable)
{
return(resolver.File.IsValid && resolver.Location.IsValid
? I($"{resolver.File.ToString(pathTable)}:({resolver.Location.Line}, {resolver.Location.Position}): ")
: string.Empty);
}
/// <inheritdoc />
public bool TryInitialize([NotNull] FrontEndHost host, [NotNull] FrontEndContext context, [NotNull] IConfiguration configuration, [NotNull] IResolverSettings resolverSettings)
{
Contract.Requires(context != null);
Contract.Requires(host != null);
Contract.Requires(configuration != null);
Contract.Requires(resolverSettings != null);
var settings = resolverSettings as IDownloadResolverSettings;
Contract.Assert(settings != null);
m_context = context;
Name = resolverSettings.Name;
var resolverFolder = host.GetFolderForFrontEnd(resolverSettings.Name ?? Kind);
var downloads = new Dictionary <string, DownloadData>(StringComparer.Ordinal);
foreach (var downloadSettings in settings.Downloads)
{
if (!ValidateAndExtractDownloadData(context, downloadSettings, downloads, resolverFolder, out var downloadData))
{
return(false);
}
downloads.Add(downloadSettings.ModuleName, downloadData);
UpdateDataForDownloadData(downloadData);
}
Downloads = downloads;
return(true);
}
/// <inheritdoc/>
public override async Task <bool> InitResolverAsync(IResolverSettings resolverSettings, object workspaceResolver)
{
Contract.Requires(resolverSettings != null);
Contract.Assert(m_resolverState == State.Created);
Contract.Assert(
resolverSettings is INugetResolverSettings,
I($"Wrong type for resolver settings, expected {nameof(INugetResolverSettings)} but got {nameof(resolverSettings.GetType)}"));
Name = resolverSettings.Name;
m_resolverState = State.ResolverInitializing;
m_nugetWorkspaceResolver = workspaceResolver as WorkspaceNugetModuleResolver;
Contract.Assert(m_nugetWorkspaceResolver != null, "Workspace module resolver is expected to be of source type");
// TODO: We could do something smarter in the future and just download/generate what is needed
// Use this result to populate the dictionaries that are used for package retrieval (m_packageDirectories, m_packages and m_owningModules)
var maybePackages = await m_nugetWorkspaceResolver.GetAllKnownPackagesAsync();
if (!maybePackages.Succeeded)
{
// Error should have been reported.
return(false);
}
m_owningModules = new Dictionary <ModuleId, Package>();
foreach (var package in maybePackages.Result.Values.SelectMany(v => v))
{
m_packages[package.Id] = package;
m_owningModules[package.ModuleId] = package;
}
if (Configuration.FrontEnd.GenerateCgManifestForNugets.IsValid ||
Configuration.FrontEnd.ValidateCgManifestForNugets.IsValid)
{
var cgManfiestGenerator = new NugetCgManifestGenerator(Context);
string generatedCgManifest = cgManfiestGenerator.GenerateCgManifestForPackages(maybePackages.Result);
if (Configuration.FrontEnd.ValidateCgManifestForNugets.IsValid)
{
// Validate existing CG Manifest with newly generated CG Manifest
if (!ValidateCgManifestFile(generatedCgManifest))
{
return(false);
}
}
if (Configuration.FrontEnd.GenerateCgManifestForNugets.IsValid &&
!Configuration.FrontEnd.GenerateCgManifestForNugets.Equals(Configuration.FrontEnd.ValidateCgManifestForNugets))
{
// Save the generated CG Manifets to File
if (!(await SaveCgManifetsFileAsync(generatedCgManifest)))
{
return(false);
}
}
}
m_resolverState = State.ResolverInitialized;
return(true);
}
/// <inheritdoc/>
public virtual Possible <T> TryGetResolver(IResolverSettings resolverSettings)
{
Contract.Requires(resolverSettings != null);
Contract.Assert(IsRegistered(resolverSettings.Kind));
return(RegisteredKinds[resolverSettings.Kind](resolverSettings));
}
/// <inheritdoc/>
public override bool TryInitialize(FrontEndHost host, FrontEndContext context, IConfiguration configuration, IResolverSettings resolverSettings)
{
var success = base.TryInitialize(host, context, configuration, resolverSettings);
if (!success)
{
return(false);
}
if (!JavaScriptCommandsInterpreter.TryComputeAndValidateCommands(
m_context.LoggingContext,
resolverSettings.Location(m_context.PathTable),
((IJavaScriptResolverSettings)resolverSettings).Execute,
out IReadOnlyDictionary <string, IReadOnlyList <IJavaScriptCommandDependency> > computedCommands))
{
// Error has been logged
return(false);
}
m_computedCommands = computedCommands;
ExportsFile = m_resolverSettings.Root.Combine(m_context.PathTable, "exports.dsc");
AllProjectsSymbol = FullSymbol.Create(m_context.SymbolTable, "all");
return(true);
}
/// <inheritdoc/>
public override bool TryInitialize(FrontEndHost host, FrontEndContext context, IConfiguration configuration, IResolverSettings resolverSettings, QualifierId[] requestedQualifiers)
{
Contract.Requires(context != null);
Contract.Requires(host != null);
Contract.Requires(configuration != null);
Contract.Requires(resolverSettings != null);
Contract.Requires(requestedQualifiers?.Length > 0);
if (!base.TryInitialize(host, context, configuration, resolverSettings, requestedQualifiers))
{
return(false);
}
var defaultSourceResolverSettings = resolverSettings as IInternalDefaultDScriptResolverSettings;
Contract.Assert(defaultSourceResolverSettings != null);
m_defaultDScriptResolverSettings = defaultSourceResolverSettings;
return(true);
}
/// <inheritdoc cref="IDScriptWorkspaceModuleResolver" />
public bool TryInitialize([NotNull] FrontEndHost host, [NotNull] FrontEndContext context, [NotNull] IConfiguration configuration, [NotNull] IResolverSettings resolverSettings, [NotNull] QualifierId[] requestedQualifiers)
{
InitializeInterpreter(host, context, configuration);
m_resolverSettings = resolverSettings as INinjaResolverSettings;
Contract.Assert(m_resolverSettings != null);
return(TryInitializeWorkspaceValues());
}
public override async Task <bool> InitResolverAsync(IResolverSettings resolverSettings, object workspaceResolver)
{
Contract.Requires(resolverSettings != null);
Contract.Assert(m_resolverState == State.Created);
Contract.Assert(
resolverSettings is INugetResolverSettings,
I($"Wrong type for resolver settings, expected {nameof(INugetResolverSettings)} but got {nameof(resolverSettings.GetType)}"));
Name = resolverSettings.Name;
m_resolverState = State.ResolverInitializing;
m_nugetWorkspaceResolver = workspaceResolver as WorkspaceNugetModuleResolver;
Contract.Assert(m_nugetWorkspaceResolver != null, "Workspace module resolver is expected to be of source type");
// TODO: We could do something smarter in the future and just download/generate what is needed
// Use this result to populate the dictionaries that are used for package retrieval (m_packageDirectories, m_packages and m_owningModules)
var maybePackages = await m_nugetWorkspaceResolver.GetAllKnownPackagesAsync();
if (!maybePackages.Succeeded)
{
// Error should have been reported.
return(false);
}
m_owningModules = new Dictionary <ModuleId, Package>();
foreach (var package in maybePackages.Result.Values.SelectMany(v => v))
{
m_packages[package.Id] = package;
m_owningModules[package.ModuleId] = package;
}
if (Configuration.FrontEnd.GenerateCgManifestForNugets.IsValid ||
Configuration.FrontEnd.ValidateCgManifestForNugets.IsValid)
{
var cgManfiestGenerator = new NugetCgManifestGenerator(Context);
string generatedCgManifest = cgManfiestGenerator.GenerateCgManifestForPackages(maybePackages.Result);
string existingCgManifest = "INVALID";
if (!Configuration.FrontEnd.GenerateCgManifestForNugets.IsValid &&
Configuration.FrontEnd.ValidateCgManifestForNugets.IsValid)
{
// Validation of existing cgmainfest.json results in failure due to mismatch. Should fail the build in this case.
try
{
existingCgManifest = File.ReadAllText(Configuration.FrontEnd.ValidateCgManifestForNugets.ToString(Context.PathTable));
FrontEndHost.Engine.RecordFrontEndFile(
Configuration.FrontEnd.ValidateCgManifestForNugets,
CGManifestResolverName);
}
// CgManifest FileNotFound, log error and fail build
catch (DirectoryNotFoundException e)
{
Logger.ReportComponentGovernanceValidationError(Context.LoggingContext, "Cannot read Component Governance Manifest file from disk\n" + e.ToString());
return(false);
}
catch (FileNotFoundException e)
{
Logger.ReportComponentGovernanceValidationError(Context.LoggingContext, "Cannot read Component Governance Manifest file from disk\n" + e.ToString());
return(false);
}
if (!cgManfiestGenerator.CompareForEquality(generatedCgManifest, existingCgManifest))
{
Logger.ReportComponentGovernanceValidationError(Context.LoggingContext, @"Existing Component Governance Manifest file is outdated, please generate a new one using the argument /generateCgManifestForNugets:<path>");
return(false);
}
m_resolverState = State.ResolverInitialized;
return(true);
}
// GenerateCgManifestForNugets writes a new file when the old file does not match, hence it will always be valid and does not need validation
try
{
// We are calling FrontEndHost.Engine.RecordFrontEndFile towards the end of this function because we may update this file after the read below
// Updating the file will cause a hash mismatch and the build to fail if this file is read again downstream
existingCgManifest = File.ReadAllText(Configuration.FrontEnd.GenerateCgManifestForNugets.ToString(Context.PathTable));
}
// CgManifest FileNotFound, continue to write the new file
// No operations required as the empty existingCgManifest will not match with the newly generated cgManifest
catch (DirectoryNotFoundException) { }
catch (FileNotFoundException) { }
if (!cgManfiestGenerator.CompareForEquality(generatedCgManifest, existingCgManifest))
{
if (Configuration.FrontEnd.GenerateCgManifestForNugets.IsValid)
{
// Overwrite or create new cgmanifest.json file with updated nuget package and version info
string targetFilePath = Configuration.FrontEnd.GenerateCgManifestForNugets.ToString(Context.PathTable);
try
{
FileUtilities.CreateDirectory(Path.GetDirectoryName(targetFilePath));
await FileUtilities.WriteAllTextAsync(targetFilePath, generatedCgManifest, Encoding.UTF8);
}
catch (BuildXLException e)
{
Logger.ReportComponentGovernanceGenerationError(Context.LoggingContext, "Could not write Component Governance Manifest file to disk\n" + e.ToString());
return(false);
}
}
}
FrontEndHost.Engine.RecordFrontEndFile(
Configuration.FrontEnd.GenerateCgManifestForNugets,
CGManifestResolverName);
}
m_resolverState = State.ResolverInitialized;
return(true);
}