public void GetRepositoryPath_WhenPathSolutionOrOverrideSpecified_CorrectPathDetected(string repositoryPathOverride, string restoreRepositoryPath, string solutionPath, string repositoryPath, string expected)
{
using (var testDirectory = TestDirectory.Create())
{
var project = new MockMSBuildProject(testDirectory, new Dictionary <string, string>
{
["RestoreRepositoryPath"] = restoreRepositoryPath,
["RestoreRepositoryPathOverride"] = repositoryPathOverride,
["SolutionPath"] = solutionPath == null || solutionPath == "*Undefined*" ? solutionPath : UriUtility.GetAbsolutePath(testDirectory, solutionPath)
});
var settings = new MockSettings
{
Sections = new List <SettingSection>
{
new MockSettingSection(
ConfigurationConstants.Config,
repositoryPath == null
? new SettingItem[0]
: new SettingItem[] { new AddItem(ConfigurationConstants.RepositoryPath, UriUtility.GetAbsolutePath(testDirectory, repositoryPath)) })
}
};
var actual = MSBuildStaticGraphRestore.GetRepositoryPath(project, settings);
expected = UriUtility.GetAbsolutePath(testDirectory, expected);
actual.Should().Be(expected);
}
}
/// <summary>
/// Gets a <see cref="PackageSpec" /> for the specified project.
/// </summary>
/// <param name="project">An <see cref="IMSBuildProject" /> object that represents the project.</param>
/// <param name="allInnerNodes">An <see cref="IReadOnlyDictionary{String,IMSBuildProject}" /> that represents all inner projects by their target framework.</param>
/// <returns></returns>
private PackageSpec GetPackageSpec(IMSBuildProject project, IReadOnlyDictionary <string, IMSBuildProject> allInnerNodes)
{
var settings = RestoreSettingsUtils.ReadSettings(
project.GetProperty("RestoreSolutionDirectory"),
project.GetProperty("RestoreRootConfigDirectory") ?? project.Directory,
UriUtility.GetAbsolutePath(project.Directory, project.GetProperty("RestoreConfigFile")),
MachineWideSettingsLazy,
_settingsLoadContext);
// Get the target frameworks for the project and the project instance for each framework
var projectsByTargetFramework = GetProjectTargetFrameworks(project, allInnerNodes);
var restoreMetadataAndTargetFrameworkInformation = GetProjectRestoreMetadataAndTargetFrameworkInformation(project, projectsByTargetFramework, settings);
var packageSpec = new PackageSpec(restoreMetadataAndTargetFrameworkInformation.TargetFrameworkInfos)
{
FilePath = project.FullPath,
Name = restoreMetadataAndTargetFrameworkInformation.RestoreMetadata.ProjectName,
RestoreMetadata = restoreMetadataAndTargetFrameworkInformation.RestoreMetadata,
RuntimeGraph = new RuntimeGraph(
MSBuildStringUtility.Split($"{project.GetProperty("RuntimeIdentifiers")};{project.GetProperty("RuntimeIdentifier")}")
.Concat(projectsByTargetFramework.Values.SelectMany(i => MSBuildStringUtility.Split($"{i.GetProperty("RuntimeIdentifiers")};{i.GetProperty("RuntimeIdentifier")}")))
.Distinct(StringComparer.Ordinal)
.Select(rid => new RuntimeDescription(rid))
.ToList(),
MSBuildStringUtility.Split(project.GetProperty("RuntimeSupports"))
.Distinct(StringComparer.Ordinal)
.Select(s => new CompatibilityProfile(s))
.ToList()
),
Version = GetProjectVersion(project)
};
return(packageSpec);
}
/// <summary>
/// Gets the packages path for the specified project.
/// </summary>
/// <param name="project">The <see cref="IMSBuildItem" /> representing the project.</param>
/// <param name="settings">The <see cref="ISettings" /> of the project.</param>
/// <returns>The full path to the packages directory for the specified project.</returns>
internal static string GetPackagesPath(IMSBuildProject project, ISettings settings)
{
return(RestoreSettingsUtils.GetValue(
() => UriUtility.GetAbsolutePath(project.Directory, project.GetProperty("RestorePackagesPathOverride")),
() => UriUtility.GetAbsolutePath(project.Directory, project.GetProperty("RestorePackagesPath")),
() => SettingsUtility.GetGlobalPackagesFolder(settings)));
}
internal DeepLinkViewModel(Action <DeepLink> navigate)
{
this.navigate = navigate;
HtmlLocation location = HtmlWindow.Current.Location;
string hash = location.Hash;
localStorageKey = UriUtility.GetServerRelativeUrl(UriUtility.GetAbsolutePath(location.Href)) + "?deepLink";
if (!string.IsNullOrEmpty(hash))
{
try
{
lastReceived = JsonDeserializer.Deserialize <DeepLink>(hash.Substring(1)); // ignore #
}
catch
{
}
}
if (lastReceived == null && HtmlWindow.Current.LocalStorage != null)
{
hash = HtmlWindow.Current.LocalStorage[localStorageKey];
if (!string.IsNullOrEmpty(hash))
{
try
{
lastReceived = JsonDeserializer.Deserialize <DeepLink>(hash); // ignore #
}
catch
{
}
}
}
HtmlWindow.Current.AdviseHash(HashChanged);
}
/// <summary>
/// Resolve a path against MSBuildStartupDirectory
/// </summary>
private string GetGlobalAbsolutePath(string path)
{
if (!string.IsNullOrEmpty(path))
{
return(UriUtility.GetAbsolutePath(MSBuildStartupDirectory, path));
}
return(path);
}
static PackageSource CreatePackageSource(FilePath baseDirectory, string source)
{
if (!IsClearKeyword(source))
{
source = MSBuildProjectService.UnescapePath(source);
source = UriUtility.GetAbsolutePath(baseDirectory, source);
}
return(new PackageSource(source));
}
public void UriUtility_GetAbsolutePath_VerifyUrlPathUnchanged()
{
using (var root = TestDirectory.Create())
{
var source = "https://api.nuget.org/v3/index.json";
var path = UriUtility.GetAbsolutePath(root, source);
Assert.Equal(source, path);
}
}
public void UriUtility_GetAbsolutePath_VerifyRelativePathCombined(string source, string relative)
{
using (var root = TestDirectory.Create())
{
var expected = Path.GetFullPath(Path.Combine(root, relative));
var path = UriUtility.GetAbsolutePath(root, source);
Assert.Equal(expected, path);
}
}
private static string[] AppendItems(string projectDirectory, string[] current, string[] additional)
{
if (additional == null || additional.Length == 0)
{
// noop
return(current);
}
var additionalAbsolute = additional.Select(e => UriUtility.GetAbsolutePath(projectDirectory, e));
return(current.Concat(additionalAbsolute).ToArray());
}
public void UriUtility_GetAbsolutePath_VerifyAbsolutePathUnchanged()
{
using (var root = TestDirectory.Create())
using (var root2 = TestDirectory.Create())
{
var source = root2;
var path = UriUtility.GetAbsolutePath(root, source);
Assert.Equal(source, path);
}
}
/// <summary>
/// Gets the package fallback folders for a project.
/// </summary>
/// <param name="startupDirectory">The start-up directory of the tool.</param>
/// <param name="projectDirectory">The full path to the directory of the project.</param>
/// <param name="fallbackFolders">A <see cref="T:string[]" /> containing the fallback folders for the project.</param>
/// <param name="fallbackFoldersOverride">A <see cref="T:string[]" /> containing overrides for the fallback folders for the project.</param>
/// <param name="additionalProjectFallbackFolders">An <see cref="IEnumerable{String}" /> containing additional fallback folders for the project.</param>
/// <param name="additionalProjectFallbackFoldersExcludes">An <see cref="IEnumerable{String}" /> containing fallback folders to exclude.</param>
/// <param name="settings">An <see cref="ISettings" /> object containing settings for the project.</param>
/// <returns>A <see cref="T:string[]" /> containing the package fallback folders for the project.</returns>
public static string[] GetFallbackFolders(string startupDirectory, string projectDirectory, string[] fallbackFolders, string[] fallbackFoldersOverride, IEnumerable <string> additionalProjectFallbackFolders, IEnumerable <string> additionalProjectFallbackFoldersExcludes, ISettings settings)
{
// Fallback folders
var currentFallbackFolders = RestoreSettingsUtils.GetValue(
() => fallbackFoldersOverride?.Select(e => UriUtility.GetAbsolutePath(startupDirectory, e)).ToArray(),
() => MSBuildRestoreUtility.ContainsClearKeyword(fallbackFolders) ? Array.Empty <string>() : null,
() => fallbackFolders?.Select(e => UriUtility.GetAbsolutePath(projectDirectory, e)).ToArray(),
() => SettingsUtility.GetFallbackPackageFolders(settings).ToArray());
// Append additional fallback folders after removing excluded folders
var filteredAdditionalProjectFallbackFolders = MSBuildRestoreUtility.AggregateSources(
values: additionalProjectFallbackFolders,
excludeValues: additionalProjectFallbackFoldersExcludes);
return(AppendItems(projectDirectory, currentFallbackFolders, filteredAdditionalProjectFallbackFolders));
}
/// <summary>
/// Gets the repository path for the specified project.
/// </summary>
/// <param name="project">The <see cref="IMSBuildItem" /> representing the project.</param>
/// <param name="settings">The <see cref="ISettings" /> of the specified project.</param>
/// <returns>The repository path of the specified project.</returns>
internal static string GetRepositoryPath(IMSBuildProject project, ISettings settings)
{
return(RestoreSettingsUtils.GetValue(
() => UriUtility.GetAbsolutePath(project.Directory, project.GetProperty("RestoreRepositoryPathOverride")),
() => UriUtility.GetAbsolutePath(project.Directory, project.GetProperty("RestoreRepositoryPath")),
() => SettingsUtility.GetRepositoryPath(settings),
() =>
{
string solutionDir = project.GetProperty("SolutionPath");
solutionDir = string.Equals(solutionDir, "*Undefined*", StringComparison.OrdinalIgnoreCase)
? project.Directory
: Path.GetDirectoryName(solutionDir);
return UriUtility.GetAbsolutePath(solutionDir, PackagesConfig.PackagesNodeName);
}));
}
public static string[] GetSources(string projectDirectory, string[] sources, string[] sourcesOverride, IEnumerable <string> additionalProjectSources, ISettings settings)
{
// Sources
var currentSources = RestoreSettingsUtils.GetValue(
() => sourcesOverride?.Select(MSBuildRestoreUtility.FixSourcePath).Select(e => UriUtility.GetAbsolutePath(projectDirectory, e)).ToArray(),
() => MSBuildRestoreUtility.ContainsClearKeyword(sources) ? Array.Empty <string>() : null,
() => sources?.Select(MSBuildRestoreUtility.FixSourcePath).Select(e => UriUtility.GetAbsolutePath(projectDirectory, e)).ToArray(),
() => (PackageSourceProvider.LoadPackageSources(settings)).Where(e => e.IsEnabled).Select(e => e.Source).ToArray());
// Append additional sources
// Escape strings to avoid xplat path issues with msbuild.
var filteredAdditionalProjectSources = MSBuildRestoreUtility.AggregateSources(
values: additionalProjectSources,
excludeValues: Enumerable.Empty <string>())
.Select(MSBuildRestoreUtility.FixSourcePath)
.ToArray();
return(AppendItems(projectDirectory, currentSources, filteredAdditionalProjectSources));
}
public async Task <int> ExecuteCommand(PackageReferenceArgs packageReferenceArgs, MSBuildAPIUtility msBuild)
{
packageReferenceArgs.Logger.LogInformation(string.Format(CultureInfo.CurrentCulture,
Strings.Info_AddPkgAddingReference,
packageReferenceArgs.PackageId,
packageReferenceArgs.ProjectPath));
if (packageReferenceArgs.NoRestore)
{
packageReferenceArgs.Logger.LogWarning(string.Format(CultureInfo.CurrentCulture,
Strings.Warn_AddPkgWithoutRestore));
VersionRange versionRange = default;
if (packageReferenceArgs.NoVersion)
{
versionRange = packageReferenceArgs.Prerelease ?
VersionRange.Parse("*-*") :
VersionRange.Parse("*");
}
else
{
versionRange = VersionRange.Parse(packageReferenceArgs.PackageVersion);
}
var libraryDependency = new LibraryDependency
{
LibraryRange = new LibraryRange(
name: packageReferenceArgs.PackageId,
versionRange: versionRange,
typeConstraint: LibraryDependencyTarget.Package)
};
msBuild.AddPackageReference(packageReferenceArgs.ProjectPath, libraryDependency);
return(0);
}
// 1. Get project dg file
packageReferenceArgs.Logger.LogDebug("Reading project Dependency Graph");
var dgSpec = ReadProjectDependencyGraph(packageReferenceArgs);
if (dgSpec == null)
{
// Logging non localized error on debug stream.
packageReferenceArgs.Logger.LogDebug(Strings.Error_NoDgSpec);
throw new InvalidOperationException(string.Format(CultureInfo.CurrentCulture, Strings.Error_NoDgSpec));
}
packageReferenceArgs.Logger.LogDebug("Project Dependency Graph Read");
var projectFullPath = Path.GetFullPath(packageReferenceArgs.ProjectPath);
var matchingPackageSpecs = dgSpec
.Projects
.Where(p => p.RestoreMetadata.ProjectStyle == ProjectStyle.PackageReference &&
PathUtility.GetStringComparerBasedOnOS().Equals(Path.GetFullPath(p.RestoreMetadata.ProjectPath), projectFullPath))
.ToArray();
// This ensures that the DG specs generated in previous steps contain exactly 1 project with the same path as the project requesting add package.
// Throw otherwise since we cannot proceed further.
if (matchingPackageSpecs.Length != 1)
{
throw new InvalidOperationException(string.Format(CultureInfo.CurrentCulture,
Strings.Error_UnsupportedProject,
packageReferenceArgs.PackageId,
packageReferenceArgs.ProjectPath));
}
// Parse the user specified frameworks once to avoid re-do's
var userSpecifiedFrameworks = Enumerable.Empty <NuGetFramework>();
if (packageReferenceArgs.Frameworks?.Any() == true)
{
userSpecifiedFrameworks = packageReferenceArgs
.Frameworks
.Select(f => NuGetFramework.Parse(f));
}
var originalPackageSpec = matchingPackageSpecs.FirstOrDefault();
// 2. Determine the version
// Setup the Credential Service before making any potential http calls.
DefaultCredentialServiceUtility.SetupDefaultCredentialService(packageReferenceArgs.Logger, !packageReferenceArgs.Interactive);
if (packageReferenceArgs.Sources?.Any() == true)
{
// Convert relative path to absolute path if there is any
List <string> sources = new List <string>();
foreach (string source in packageReferenceArgs.Sources)
{
sources.Add(UriUtility.GetAbsolutePath(Environment.CurrentDirectory, source));
}
originalPackageSpec.RestoreMetadata.Sources =
sources.Where(ns => !string.IsNullOrEmpty(ns))
.Select(ns => new PackageSource(ns))
.ToList();
}
PackageDependency packageDependency = default;
if (packageReferenceArgs.NoVersion)
{
var latestVersion = await GetLatestVersionAsync(originalPackageSpec, packageReferenceArgs.PackageId, packageReferenceArgs.Logger, packageReferenceArgs.Prerelease);
if (latestVersion == null)
{
if (!packageReferenceArgs.Prerelease)
{
latestVersion = await GetLatestVersionAsync(originalPackageSpec, packageReferenceArgs.PackageId, packageReferenceArgs.Logger, !packageReferenceArgs.Prerelease);
if (latestVersion != null)
{
throw new CommandException(string.Format(CultureInfo.CurrentCulture, Strings.PrereleaseVersionsAvailable, latestVersion));
}
}
throw new CommandException(string.Format(CultureInfo.CurrentCulture, Strings.Error_NoVersionsAvailable, packageReferenceArgs.PackageId));
}
packageDependency = new PackageDependency(packageReferenceArgs.PackageId, new VersionRange(minVersion: latestVersion, includeMinVersion: true));
}
else
{
packageDependency = new PackageDependency(packageReferenceArgs.PackageId, VersionRange.Parse(packageReferenceArgs.PackageVersion));
}
// Create a copy to avoid modifying the original spec which may be shared.
var updatedPackageSpec = originalPackageSpec.Clone();
if (packageReferenceArgs.Frameworks?.Any() == true)
{
// If user specified frameworks then just use them to add the dependency
PackageSpecOperations.AddOrUpdateDependency(updatedPackageSpec,
packageDependency,
userSpecifiedFrameworks);
}
else
{
// If the user has not specified a framework, then just add it to all frameworks
PackageSpecOperations.AddOrUpdateDependency(updatedPackageSpec, packageDependency, updatedPackageSpec.TargetFrameworks.Select(e => e.FrameworkName));
}
var updatedDgSpec = dgSpec.WithReplacedSpec(updatedPackageSpec).WithoutRestores();
updatedDgSpec.AddRestore(updatedPackageSpec.RestoreMetadata.ProjectUniqueName);
// 3. Run Restore Preview
packageReferenceArgs.Logger.LogDebug("Running Restore preview");
var restorePreviewResult = await PreviewAddPackageReferenceAsync(packageReferenceArgs,
updatedDgSpec);
packageReferenceArgs.Logger.LogDebug("Restore Review completed");
// 4. Process Restore Result
var compatibleFrameworks = new HashSet <NuGetFramework>(
restorePreviewResult
.Result
.CompatibilityCheckResults
.Where(t => t.Success)
.Select(t => t.Graph.Framework), new NuGetFrameworkFullComparer());
if (packageReferenceArgs.Frameworks?.Any() == true)
{
// If the user has specified frameworks then we intersect that with the compatible frameworks.
var userSpecifiedFrameworkSet = new HashSet <NuGetFramework>(
userSpecifiedFrameworks,
new NuGetFrameworkFullComparer());
compatibleFrameworks.IntersectWith(userSpecifiedFrameworkSet);
}
// 5. Write to Project
if (compatibleFrameworks.Count == 0)
{
// Package is compatible with none of the project TFMs
// Do not add a package reference, throw appropriate error
packageReferenceArgs.Logger.LogError(string.Format(CultureInfo.CurrentCulture,
Strings.Error_AddPkgIncompatibleWithAllFrameworks,
packageReferenceArgs.PackageId,
packageReferenceArgs.Frameworks?.Any() == true ? Strings.AddPkg_UserSpecified : Strings.AddPkg_All,
packageReferenceArgs.ProjectPath));
return(1);
}
// Ignore the graphs with RID
else if (compatibleFrameworks.Count ==
restorePreviewResult.Result.CompatibilityCheckResults.Where(r => string.IsNullOrEmpty(r.Graph.RuntimeIdentifier)).Count())
{
// Package is compatible with all the project TFMs
// Add an unconditional package reference to the project
packageReferenceArgs.Logger.LogInformation(string.Format(CultureInfo.CurrentCulture,
Strings.Info_AddPkgCompatibleWithAllFrameworks,
packageReferenceArgs.PackageId,
packageReferenceArgs.ProjectPath));
// generate a library dependency with all the metadata like Include, Exlude and SuppressParent
var libraryDependency = GenerateLibraryDependency(updatedPackageSpec, packageReferenceArgs, restorePreviewResult, userSpecifiedFrameworks, packageDependency);
msBuild.AddPackageReference(packageReferenceArgs.ProjectPath, libraryDependency);
}
else
{
// Package is compatible with some of the project TFMs
// Add conditional package references to the project for the compatible TFMs
packageReferenceArgs.Logger.LogInformation(string.Format(CultureInfo.CurrentCulture,
Strings.Info_AddPkgCompatibleWithSubsetFrameworks,
packageReferenceArgs.PackageId,
packageReferenceArgs.ProjectPath));
var compatibleOriginalFrameworks = compatibleFrameworks
.Select(e => GetAliasForFramework(originalPackageSpec, e))
.Where(originalFramework => originalFramework != null);
// generate a library dependency with all the metadata like Include, Exlude and SuppressParent
var libraryDependency = GenerateLibraryDependency(updatedPackageSpec, packageReferenceArgs, restorePreviewResult, userSpecifiedFrameworks, packageDependency);
msBuild.AddPackageReferencePerTFM(packageReferenceArgs.ProjectPath,
libraryDependency,
compatibleOriginalFrameworks);
}
// 6. Commit restore result
await RestoreRunner.CommitAsync(restorePreviewResult, CancellationToken.None);
return(0);
}
public override bool Execute()
{
var log = new MSBuildLogger(Log);
// Log Inputs
BuildTasksUtility.LogInputParam(log, nameof(ProjectUniqueName), ProjectUniqueName);
BuildTasksUtility.LogInputParam(log, nameof(RestoreSources), RestoreSources);
BuildTasksUtility.LogInputParam(log, nameof(RestorePackagesPath), RestorePackagesPath);
BuildTasksUtility.LogInputParam(log, nameof(RestoreFallbackFolders), RestoreFallbackFolders);
BuildTasksUtility.LogInputParam(log, nameof(RestoreConfigFile), RestoreConfigFile);
BuildTasksUtility.LogInputParam(log, nameof(RestoreSolutionDirectory), RestoreSolutionDirectory);
BuildTasksUtility.LogInputParam(log, nameof(RestorePackagesPathOverride), RestorePackagesPathOverride);
BuildTasksUtility.LogInputParam(log, nameof(RestoreSourcesOverride), RestoreSourcesOverride);
BuildTasksUtility.LogInputParam(log, nameof(RestoreFallbackFoldersOverride), RestoreFallbackFoldersOverride);
try
{
// Validate inputs
if (RestoreSourcesOverride == null &&
MSBuildRestoreUtility.LogErrorForClearIfInvalid(RestoreSources, ProjectUniqueName, log))
{
// Fail due to invalid source combination
return(false);
}
if (RestoreFallbackFoldersOverride == null &&
MSBuildRestoreUtility.LogErrorForClearIfInvalid(RestoreFallbackFolders, ProjectUniqueName, log))
{
// Fail due to invalid fallback combination
return(false);
}
// Settings
var settings = RestoreSettingsUtils.ReadSettings(RestoreSolutionDirectory, Path.GetDirectoryName(ProjectUniqueName), RestoreConfigFile, _machineWideSettings);
OutputConfigFilePaths = SettingsUtility.GetConfigFilePaths(settings).ToArray();
// PackagesPath
OutputPackagesPath = RestoreSettingsUtils.GetValue(
() => string.IsNullOrEmpty(RestorePackagesPathOverride) ? null : UriUtility.GetAbsolutePath(MSBuildStartupDirectory, RestorePackagesPathOverride),
() => string.IsNullOrEmpty(RestorePackagesPath) ? null : UriUtility.GetAbsolutePathFromFile(ProjectUniqueName, RestorePackagesPath),
() => SettingsUtility.GetGlobalPackagesFolder(settings));
// Sources
var currentSources = RestoreSettingsUtils.GetValue(
() => RestoreSourcesOverride?.Select(MSBuildRestoreUtility.FixSourcePath).Select(e => UriUtility.GetAbsolutePath(MSBuildStartupDirectory, e)).ToArray(),
() => MSBuildRestoreUtility.ContainsClearKeyword(RestoreSources) ? new string[0] : null,
() => RestoreSources?.Select(MSBuildRestoreUtility.FixSourcePath).Select(e => UriUtility.GetAbsolutePathFromFile(ProjectUniqueName, e)).ToArray(),
() => (new PackageSourceProvider(settings)).LoadPackageSources().Select(e => e.Source).ToArray());
// Append additional sources
// Escape strings to avoid xplat path issues with msbuild.
var additionalProjectSources = MSBuildRestoreUtility.AggregateSources(
values: GetPropertyValues(RestoreSettingsPerFramework, "RestoreAdditionalProjectSources"),
excludeValues: Enumerable.Empty <string>())
.Select(MSBuildRestoreUtility.FixSourcePath)
.ToArray();
OutputSources = AppendItems(currentSources, additionalProjectSources);
// Fallback folders
var currentFallbackFolders = RestoreSettingsUtils.GetValue(
() => RestoreFallbackFoldersOverride?.Select(e => UriUtility.GetAbsolutePath(MSBuildStartupDirectory, e)).ToArray(),
() => MSBuildRestoreUtility.ContainsClearKeyword(RestoreFallbackFolders) ? new string[0] : null,
() => RestoreFallbackFolders?.Select(e => UriUtility.GetAbsolutePathFromFile(ProjectUniqueName, e)).ToArray(),
() => SettingsUtility.GetFallbackPackageFolders(settings).ToArray());
// Append additional fallback folders after removing excluded folders
var additionalProjectFallbackFolders = MSBuildRestoreUtility.AggregateSources(
values: GetPropertyValues(RestoreSettingsPerFramework, "RestoreAdditionalProjectFallbackFolders"),
excludeValues: GetPropertyValues(RestoreSettingsPerFramework, "RestoreAdditionalProjectFallbackFoldersExcludes"))
.ToArray();
OutputFallbackFolders = AppendItems(currentFallbackFolders, additionalProjectFallbackFolders);
}
catch (Exception ex)
{
// Log exceptions with error codes if they exist.
ExceptionUtilities.LogException(ex, log);
return(false);
}
// Log Outputs
BuildTasksUtility.LogOutputParam(log, nameof(OutputPackagesPath), OutputPackagesPath);
BuildTasksUtility.LogOutputParam(log, nameof(OutputSources), OutputSources);
BuildTasksUtility.LogOutputParam(log, nameof(OutputFallbackFolders), OutputFallbackFolders);
BuildTasksUtility.LogOutputParam(log, nameof(OutputConfigFilePaths), OutputConfigFilePaths);
return(true);
}
