public static string GetPackagesPath(string projectFullPath, ISettings settings, string packagePath)
{
if (string.IsNullOrEmpty(packagePath))
{
return(SettingsUtility.GetGlobalPackagesFolder(settings));
}
return(UriUtility.GetAbsolutePathFromFile(projectFullPath, packagePath));
}
private string[] AppendItems(string[] current, string[] additional)
{
if (additional == null || additional.Length == 0)
{
// noop
return(current);
}
var additionalAbsolute = additional.Select(e => UriUtility.GetAbsolutePathFromFile(ProjectUniqueName, e));
return(current.Concat(additionalAbsolute).ToArray());
}
public static IList <PackageSource> GetSources(string projectFullPath, ISettings settings, IEnumerable <string> sources)
{
if (ShouldReadFromSettings(sources))
{
sources = SettingsUtility.GetEnabledSources(settings).Select(e => e.Source);
}
else
{
sources = HandleClear(sources);
}
return(sources.Select(e => new PackageSource(UriUtility.GetAbsolutePathFromFile(projectFullPath, e))).ToList());
}
public static IList <string> GetFallbackFolders(string projectFullPath, ISettings settings, IEnumerable <string> fallbackFolders)
{
if (ShouldReadFromSettings(fallbackFolders))
{
fallbackFolders = SettingsUtility.GetFallbackPackageFolders(settings);
}
else
{
fallbackFolders = HandleClear(fallbackFolders);
}
return(fallbackFolders.Select(e => UriUtility.GetAbsolutePathFromFile(projectFullPath, e)).ToList());
}
protected override async Task <string> GetBaseIntermediatePathAsync()
{
var baseIntermediatePath = await ProjectServices.BuildProperties.GetPropertyValueAsync(ProjectBuildProperties.BaseIntermediateOutputPath);
if (string.IsNullOrEmpty(baseIntermediatePath))
{
throw new InvalidDataException(string.Format(
Strings.BaseIntermediateOutputPathNotFound,
MSBuildProjectPath));
}
return(UriUtility.GetAbsolutePathFromFile(MSBuildProjectPath, baseIntermediatePath));
}
private string GetPackagesPath(ISettings settings)
{
ThreadHelper.ThrowIfNotOnUIThread();
var packagePath = GetPropertySafe(_vsProjectAdapter.BuildProperties, ProjectBuildProperties.RestorePackagesPath);
if (string.IsNullOrWhiteSpace(packagePath))
{
return(SettingsUtility.GetGlobalPackagesFolder(settings));
}
return(UriUtility.GetAbsolutePathFromFile(ProjectFullPath, packagePath));
}
private string GetPackagesPath(ISettings settings)
{
ThreadHelper.ThrowIfNotOnUIThread();
var packagePath = _vsProjectAdapter.RestorePackagesPath;
if (string.IsNullOrEmpty(packagePath))
{
return(SettingsUtility.GetGlobalPackagesFolder(settings));
}
return(UriUtility.GetAbsolutePathFromFile(_projectFullPath, packagePath));
}
private static string GetPackagesPath(ISettings settings, PackageSpec project)
{
// Set from Settings if not given. Clear is not an option here.
if (string.IsNullOrEmpty(project.RestoreMetadata.PackagesPath))
{
return(SettingsUtility.GetGlobalPackagesFolder(settings));
}
// Resolve relative paths
return(UriUtility.GetAbsolutePathFromFile(
sourceFile: project.RestoreMetadata.ProjectPath,
path: project.RestoreMetadata.PackagesPath));
}
protected override async Task <string> GetMSBuildProjectExtensionsPathAsync()
{
var msbuildProjectExtensionsPath = await ProjectServices.BuildProperties.GetPropertyValueAsync(ProjectBuildProperties.MSBuildProjectExtensionsPath);
if (string.IsNullOrEmpty(msbuildProjectExtensionsPath))
{
throw new InvalidDataException(string.Format(
Strings.MSBuildPropertyNotFound,
ProjectBuildProperties.MSBuildProjectExtensionsPath,
MSBuildProjectPath));
}
return(UriUtility.GetAbsolutePathFromFile(MSBuildProjectPath, msbuildProjectExtensionsPath));
}
public static IList <PackageSource> GetSources(ISettings settings, PackageSpec project)
{
var results = ProcessEntriesWithAdditional(project.RestoreMetadata.Sources.Select(e => e.Source).ToList());
var sources = results.Item1;
var additionalSources = results.Item2;
var processedSources = (
ShouldReadFromSettings(sources) ?
SettingsUtility.GetEnabledSources(settings).Select(e => e.Source) :
HandleClear(sources))
.Concat(additionalSources);
// Resolve relative paths
return(processedSources.Select(e => new PackageSource(
UriUtility.GetAbsolutePathFromFile(
sourceFile: project.RestoreMetadata.ProjectPath,
path: e)))
.ToList());
}
private static List <PackageSource> GetSources(ISettings settings, PackageSpec project)
{
var sources = project.RestoreMetadata.Sources.Select(e => e.Source);
if (ShouldReadFromSettings(sources))
{
sources = SettingsUtility.GetEnabledSources(settings).Select(e => e.Source);
}
else
{
sources = HandleClear(sources);
}
// Resolve relative paths
return(sources.Select(e => new PackageSource(
UriUtility.GetAbsolutePathFromFile(
sourceFile: project.RestoreMetadata.ProjectPath,
path: e)))
.ToList());
}
private IList <string> GetFallbackFolders(ISettings settings, bool shouldThrow = true)
{
ThreadHelper.ThrowIfNotOnUIThread();
var fallbackFolders = MSBuildStringUtility.Split(_vsProjectAdapter.RestoreFallbackFolders).AsEnumerable();
if (ShouldReadFromSettings(fallbackFolders))
{
fallbackFolders = SettingsUtility.GetFallbackPackageFolders(settings);
}
else
{
fallbackFolders = VSRestoreSettingsUtilities.HandleClear(fallbackFolders);
}
// Add additional fallback folders
fallbackFolders = fallbackFolders.Concat(MSBuildStringUtility.Split(_vsProjectAdapter.RestoreAdditionalProjectFallbackFolders));
return(fallbackFolders.Select(e => UriUtility.GetAbsolutePathFromFile(_projectFullPath, e)).ToList());
}
private IList <PackageSource> GetSources(ISettings settings, bool shouldThrow = true)
{
ThreadHelper.ThrowIfNotOnUIThread();
var sources = MSBuildStringUtility.Split(_vsProjectAdapter.RestoreSources).AsEnumerable();
if (ShouldReadFromSettings(sources))
{
sources = SettingsUtility.GetEnabledSources(settings).Select(e => e.Source);
}
else
{
sources = VSRestoreSettingsUtilities.HandleClear(sources);
}
// Add additional sources
sources = sources.Concat(MSBuildStringUtility.Split(_vsProjectAdapter.RestoreAdditionalProjectSources));
return(sources.Select(e => new PackageSource(UriUtility.GetAbsolutePathFromFile(_projectFullPath, e))).ToList());
}
private static List <string> GetFallbackFolders(ISettings settings, PackageSpec project)
{
IEnumerable <string> fallbackFolders = project.RestoreMetadata.FallbackFolders;
if (ShouldReadFromSettings(fallbackFolders))
{
fallbackFolders = SettingsUtility.GetFallbackPackageFolders(settings);
}
else
{
fallbackFolders = HandleClear(fallbackFolders);
}
// Resolve relative paths
return(fallbackFolders.Select(e =>
UriUtility.GetAbsolutePathFromFile(
sourceFile: project.RestoreMetadata.ProjectPath,
path: e))
.ToList());
}
public static IList <string> GetFallbackFolders(ISettings settings, PackageSpec project)
{
var results = ProcessEntriesWithAdditional(project.RestoreMetadata.FallbackFolders);
var fallbackFolders = results.Item1;
var additionalFallbackFolders = results.Item2;
var processedFallbackFolders = (
ShouldReadFromSettings(fallbackFolders) ?
SettingsUtility.GetFallbackPackageFolders(settings) :
HandleClear(fallbackFolders))
.Concat(additionalFallbackFolders);
// Resolve relative paths
return(processedFallbackFolders.Select(e =>
UriUtility.GetAbsolutePathFromFile(
sourceFile: project.RestoreMetadata.ProjectPath,
path: e))
.ToList());
}
public override bool Execute()
{
// Log Inputs
var log = new MSBuildLogger(Log);
log.LogDebug($"(in) ProjectUniqueName '{ProjectUniqueName}'");
if (RestoreSources != null)
{
log.LogDebug($"(in) RestoreSources '{string.Join(";", RestoreSources.Select(p => p))}'");
}
if (RestorePackagesPath != null)
{
log.LogDebug($"(in) RestorePackagesPath '{RestorePackagesPath}'");
}
if (RestoreFallbackFolders != null)
{
log.LogDebug($"(in) RestoreFallbackFolders '{string.Join(";", RestoreFallbackFolders.Select(p => p))}'");
}
if (RestoreConfigFile != null)
{
log.LogDebug($"(in) RestoreConfigFile '{RestoreConfigFile}'");
}
if (RestoreSolutionDirectory != null)
{
log.LogDebug($"(in) RestoreSolutionDirectory '{RestoreSolutionDirectory}'");
}
if (RestoreAdditionalProjectSources != null)
{
log.LogDebug($"(in) RestoreAdditionalProjectSources '{RestoreAdditionalProjectSources}'");
}
if (RestoreAdditionalProjectFallbackFolders != null)
{
log.LogDebug($"(in) RestoreAdditionalProjectFallbackFolders '{RestoreAdditionalProjectFallbackFolders}'");
}
try
{
var settings = RestoreSettingsUtils.ReadSettings(RestoreSolutionDirectory, Path.GetDirectoryName(ProjectUniqueName), RestoreConfigFile, _machineWideSettings);
OutputPackagesPath = RestoreSettingsUtils.GetPackagesPath(ProjectUniqueName, settings, RestorePackagesPath);
if (RestoreSources == null)
{
var packageSourceProvider = new PackageSourceProvider(settings);
var packageSourcesFromProvider = packageSourceProvider.LoadPackageSources();
OutputSources = packageSourcesFromProvider.Select(e => e.Source).ToArray();
}
else if (MSBuildRestoreUtility.ContainsClearKeyword(RestoreSources))
{
if (MSBuildRestoreUtility.LogErrorForClearIfInvalid(RestoreSources, ProjectUniqueName, log))
{
// Fail due to invalid combination
return(false);
}
OutputSources = new string[] { };
}
else
{
// Relative -> Absolute paths
OutputSources = RestoreSources.Select(e => UriUtility.GetAbsolutePathFromFile(ProjectUniqueName, e)).ToArray();
}
// Append additional sources
OutputSources = AppendItems(OutputSources, RestoreAdditionalProjectSources);
if (RestoreFallbackFolders == null)
{
OutputFallbackFolders = SettingsUtility.GetFallbackPackageFolders(settings).ToArray();
}
else if (MSBuildRestoreUtility.ContainsClearKeyword(RestoreFallbackFolders))
{
if (MSBuildRestoreUtility.LogErrorForClearIfInvalid(RestoreFallbackFolders, ProjectUniqueName, log))
{
// Fail due to invalid combination
return(false);
}
OutputFallbackFolders = new string[] { };
}
else
{
// Relative -> Absolute paths
OutputFallbackFolders = RestoreFallbackFolders.Select(e => UriUtility.GetAbsolutePathFromFile(ProjectUniqueName, e)).ToArray();
}
// Append additional fallback folders
OutputFallbackFolders = AppendItems(OutputFallbackFolders, RestoreAdditionalProjectFallbackFolders);
OutputConfigFilePaths = SettingsUtility.GetConfigFilePaths(settings).ToArray();
}
catch (Exception ex)
{
// Log exceptions with error codes if they exist.
ExceptionUtilities.LogException(ex, log);
return(false);
}
// Log Outputs
log.LogDebug($"(out) OutputPackagesPath '{OutputPackagesPath}'");
log.LogDebug($"(out) OutputSources '{string.Join(";", OutputSources.Select(p => p))}'");
log.LogDebug($"(out) OutputFallbackFolders '{string.Join(";", OutputFallbackFolders.Select(p => p))}'");
log.LogDebug($"(out) OutputConfigFilePaths '{string.Join(";", OutputConfigFilePaths.Select(p => p))}'");
return(true);
}
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);
BuildTasksUtility.LogInputParam(log, nameof(MSBuildStartupDirectory), MSBuildStartupDirectory);
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
// Find the absolute path of nuget.config, this should only be set on the command line. Setting the path in project files
// is something that could happen, but it is not supported.
var absoluteConfigFilePath = GetGlobalAbsolutePath(RestoreConfigFile);
var settings = RestoreSettingsUtils.ReadSettings(RestoreSolutionDirectory, Path.GetDirectoryName(ProjectUniqueName), absoluteConfigFilePath, _machineWideSettings);
OutputConfigFilePaths = SettingsUtility.GetConfigFilePaths(settings).ToArray();
// PackagesPath
OutputPackagesPath = RestoreSettingsUtils.GetValue(
() => GetGlobalAbsolutePath(RestorePackagesPathOverride),
() => string.IsNullOrEmpty(RestorePackagesPath) ? null : UriUtility.GetAbsolutePathFromFile(ProjectUniqueName, RestorePackagesPath),
() => SettingsUtility.GetGlobalPackagesFolder(settings));
// Sources
var currentSources = RestoreSettingsUtils.GetValue(
() => RestoreSourcesOverride?.Select(MSBuildRestoreUtility.FixSourcePath).Select(e => GetGlobalAbsolutePath(e)).ToArray(),
() => MSBuildRestoreUtility.ContainsClearKeyword(RestoreSources) ? new string[0] : null,
() => RestoreSources?.Select(MSBuildRestoreUtility.FixSourcePath).Select(e => UriUtility.GetAbsolutePathFromFile(ProjectUniqueName, e)).ToArray(),
() => (new PackageSourceProvider(settings)).LoadPackageSources().Where(e => e.IsEnabled).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 => GetGlobalAbsolutePath(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);
}
public override bool Execute()
{
#if DEBUG
var debugRestoreTask = Environment.GetEnvironmentVariable("DEBUG_RESTORE_SETTINGS_TASK");
if (!string.IsNullOrEmpty(debugRestoreTask) && debugRestoreTask.Equals(bool.TrueString, StringComparison.OrdinalIgnoreCase))
{
System.Diagnostics.Debugger.Launch();
}
#endif
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(RestoreRepositoryPath), RestoreRepositoryPath);
BuildTasksUtility.LogInputParam(log, nameof(RestoreFallbackFolders), RestoreFallbackFolders);
BuildTasksUtility.LogInputParam(log, nameof(RestoreConfigFile), RestoreConfigFile);
BuildTasksUtility.LogInputParam(log, nameof(RestoreSolutionDirectory), RestoreSolutionDirectory);
BuildTasksUtility.LogInputParam(log, nameof(RestoreRootConfigDirectory), RestoreRootConfigDirectory);
BuildTasksUtility.LogInputParam(log, nameof(RestorePackagesPathOverride), RestorePackagesPathOverride);
BuildTasksUtility.LogInputParam(log, nameof(RestoreSourcesOverride), RestoreSourcesOverride);
BuildTasksUtility.LogInputParam(log, nameof(RestoreFallbackFoldersOverride), RestoreFallbackFoldersOverride);
BuildTasksUtility.LogInputParam(log, nameof(RestoreProjectStyle), RestoreProjectStyle);
BuildTasksUtility.LogInputParam(log, nameof(MSBuildStartupDirectory), MSBuildStartupDirectory);
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
// Find the absolute path of nuget.config, this should only be set on the command line. Setting the path in project files
// is something that could happen, but it is not supported.
var absoluteConfigFilePath = GetGlobalAbsolutePath(RestoreConfigFile);
string restoreDir;
// To match non-msbuild behavior, we only default the restoreDir for non-PackagesConfig scenarios.
if (string.IsNullOrEmpty(RestoreRootConfigDirectory))
{
restoreDir = Path.GetDirectoryName(ProjectUniqueName);
}
else
{
restoreDir = RestoreRootConfigDirectory;
}
var settings = RestoreSettingsUtils.ReadSettings(RestoreSolutionDirectory, restoreDir, absoluteConfigFilePath, _machineWideSettings);
OutputConfigFilePaths = settings.GetConfigFilePaths().ToArray();
// PackagesPath
OutputPackagesPath = RestoreSettingsUtils.GetValue(
() => GetGlobalAbsolutePath(RestorePackagesPathOverride),
() => string.IsNullOrEmpty(RestorePackagesPath) ? null : UriUtility.GetAbsolutePathFromFile(ProjectUniqueName, RestorePackagesPath),
() => SettingsUtility.GetGlobalPackagesFolder(settings));
OutputRepositoryPath = RestoreSettingsUtils.GetValue(
() => GetGlobalAbsolutePath(RestoreRepositoryPathOverride),
() => string.IsNullOrEmpty(RestoreRepositoryPath) ? null : UriUtility.GetAbsolutePathFromFile(ProjectUniqueName, RestoreRepositoryPath),
() => SettingsUtility.GetRepositoryPath(settings));
// Sources
OutputSources = BuildTasksUtility.GetSources(
MSBuildStartupDirectory,
Path.GetDirectoryName(ProjectUniqueName),
RestoreSources,
RestoreSourcesOverride,
GetPropertyValues(RestoreSettingsPerFramework, "RestoreAdditionalProjectSources"),
settings);
// Fallback folders
OutputFallbackFolders = BuildTasksUtility.GetFallbackFolders(
MSBuildStartupDirectory,
Path.GetDirectoryName(ProjectUniqueName),
RestoreFallbackFolders, RestoreFallbackFoldersOverride,
GetPropertyValues(RestoreSettingsPerFramework, "RestoreAdditionalProjectFallbackFolders"),
GetPropertyValues(RestoreSettingsPerFramework, "RestoreAdditionalProjectFallbackFoldersExcludes"),
settings);
}
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(OutputRepositoryPath), OutputRepositoryPath);
BuildTasksUtility.LogOutputParam(log, nameof(OutputSources), OutputSources);
BuildTasksUtility.LogOutputParam(log, nameof(OutputFallbackFolders), OutputFallbackFolders);
BuildTasksUtility.LogOutputParam(log, nameof(OutputConfigFilePaths), OutputConfigFilePaths);
return(true);
}
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(RestoreAdditionalProjectSources), RestoreAdditionalProjectSources);
BuildTasksUtility.LogInputParam(log, nameof(RestoreAdditionalProjectFallbackFolders), RestoreAdditionalProjectFallbackFolders);
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.
OutputSources = AppendItems(currentSources, RestoreAdditionalProjectSources?.Select(MSBuildRestoreUtility.FixSourcePath).ToArray());
// 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
OutputFallbackFolders = AppendItems(currentFallbackFolders, RestoreAdditionalProjectFallbackFolders);
}
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);
}
