private async Task CommitLockFileAsync(ILogger log, bool toolCommit)
{
// write packages lock file if it's not tool commit
if (!toolCommit && _newPackagesLockFile != null && !string.IsNullOrEmpty(_newPackagesLockFilePath))
{
log.LogInformation(string.Format(CultureInfo.CurrentCulture,
Strings.Log_WritingPackagesLockFile,
_newPackagesLockFilePath));
await FileUtility.ReplaceWithLock(
(outputPath) => PackagesLockFileFormat.Write(outputPath, _newPackagesLockFile),
_newPackagesLockFilePath);
}
}
internal static void UpdateLockFile(
MSBuildNuGetProject msbuildProject,
List <NuGetProjectAction> actionsList,
CancellationToken token)
{
if (msbuildProject == null)
{
// probably a `nuget.exe install` command, which doesn't support lock files until lock file arguments are implemented
return;
}
var lockFileName = GetPackagesLockFilePath(msbuildProject);
var lockFileExists = File.Exists(lockFileName);
var enableLockFile = IsRestorePackagesWithLockFileEnabled(msbuildProject);
if (enableLockFile == false && lockFileExists)
{
var message = string.Format(CultureInfo.CurrentCulture, Strings.Error_InvalidLockFileInput, lockFileName);
throw new InvalidOperationException(message);
}
else if (enableLockFile == true || lockFileExists)
{
var lockFile = GetLockFile(lockFileExists, lockFileName);
lockFile.Targets[0].TargetFramework = msbuildProject.ProjectSystem.TargetFramework;
var contentHashUtil = new PackagesConfigContentHashProvider(msbuildProject.FolderNuGetProject);
ApplyChanges(lockFile, actionsList, contentHashUtil, token);
PackagesLockFileFormat.Write(lockFileName, lockFile);
// Add lock file to msbuild project, so it appears in solution explorer and is added to TFS source control.
if (msbuildProject != null)
{
var projectUri = new Uri(msbuildProject.MSBuildProjectPath);
var lockFileUri = new Uri(lockFileName);
var lockFileRelativePath = projectUri.MakeRelativeUri(lockFileUri).OriginalString;
if (Path.DirectorySeparatorChar != '/')
{
lockFileRelativePath.Replace('/', Path.DirectorySeparatorChar);
}
msbuildProject.ProjectSystem.AddExistingFile(lockFileRelativePath);
}
}
}
public static IReadOnlyList <IRestoreLogMessage> ValidatePackagesConfigLockFiles(
string projectFile,
string packagesConfigFile,
string projectName,
string nuGetLockFilePath,
string restorePackagesWithLockFile,
NuGetFramework projectTfm,
string packagesFolderPath,
bool restoreLockedMode,
CancellationToken token)
{
var lockFilePath = GetPackagesLockFilePath(Path.GetDirectoryName(packagesConfigFile), nuGetLockFilePath, projectName);
var lockFileExists = File.Exists(lockFilePath);
var lockFileOptIn = MSBuildStringUtility.GetBooleanOrNull(restorePackagesWithLockFile);
var useLockFile = lockFileOptIn == true || lockFileExists;
if (lockFileOptIn == false && lockFileExists)
{
var message = string.Format(CultureInfo.CurrentCulture, Strings.Error_InvalidLockFileInput, lockFilePath);
var errors = new List <IRestoreLogMessage>();
var log = RestoreLogMessage.CreateError(NuGetLogCode.NU1005, message, packagesConfigFile);
log.ProjectPath = projectFile ?? packagesConfigFile;
errors.Add(log);
return(errors);
}
if (useLockFile)
{
PackagesLockFile projectLockFileEquivalent = PackagesConfigLockFileUtility.FromPackagesConfigFile(packagesConfigFile,
projectTfm,
packagesFolderPath,
token);
if (!lockFileExists)
{
PackagesLockFileFormat.Write(lockFilePath, projectLockFileEquivalent);
return(null);
}
else
{
PackagesLockFile lockFile = PackagesLockFileFormat.Read(lockFilePath);
PackagesLockFileUtilities.LockFileValidityWithMatchedResults comparisonResult = PackagesLockFileUtilities.IsLockFileStillValid(projectLockFileEquivalent, lockFile);
if (comparisonResult.IsValid)
{
// check sha hashes
bool allContentHashesMatch = comparisonResult.MatchedDependencies.All(pair => pair.Key.ContentHash == pair.Value.ContentHash);
if (allContentHashesMatch)
{
return(null);
}
else
{
var errors = new List <IRestoreLogMessage>();
foreach (var difference in comparisonResult.MatchedDependencies.Where(kvp => kvp.Key.ContentHash != kvp.Value.ContentHash))
{
var message = string.Format(CultureInfo.CurrentCulture, Strings.Error_PackageValidationFailed, difference.Key.Id + "." + difference.Key.ResolvedVersion);
var log = RestoreLogMessage.CreateError(NuGetLogCode.NU1403, message, packagesConfigFile);
log.ProjectPath = projectFile ?? packagesConfigFile;
errors.Add(log);
}
return(errors);
}
}
else
{
if (restoreLockedMode)
{
var errors = new List <IRestoreLogMessage>();
var log = RestoreLogMessage.CreateError(NuGetLogCode.NU1004, Strings.Error_RestoreInLockedModePackagesConfig, packagesConfigFile);
log.ProjectPath = projectFile ?? packagesConfigFile;
errors.Add(log);
return(errors);
}
else
{
PackagesLockFileFormat.Write(lockFilePath, projectLockFileEquivalent);
return(null);
}
}
}
}
else
{
return(null);
}
}
private async Task CommitAssetsFileAsync(
LockFileFormat lockFileFormat,
IRestoreResult result,
ILogger log,
bool toolCommit,
CancellationToken token)
{
// Commit targets/props to disk before the assets file.
// Visual Studio typically watches the assets file for changes
// and begins a reload when that file changes.
var buildFilesToWrite = result.MSBuildOutputFiles
.Where(e => BuildAssetsUtils.HasChanges(e.Content, e.Path, log));
BuildAssetsUtils.WriteFiles(buildFilesToWrite, log);
if (result.LockFile == null || result.LockFilePath == null)
{
// there is no assets file to be written so just return
return;
}
// Avoid writing out the lock file if it is the same to avoid triggering an intellisense
// update on a restore with no actual changes.
if (result.PreviousLockFile == null ||
!result.PreviousLockFile.Equals(result.LockFile))
{
if (toolCommit)
{
log.LogInformation(string.Format(CultureInfo.CurrentCulture,
Strings.Log_ToolWritingLockFile,
result.LockFilePath));
await FileUtility.ReplaceWithLock(
(outputPath) => lockFileFormat.Write(outputPath, result.LockFile),
result.LockFilePath);
}
else
{
log.LogInformation(string.Format(CultureInfo.CurrentCulture,
Strings.Log_WritingLockFile,
result.LockFilePath));
FileUtility.Replace(
(outputPath) => lockFileFormat.Write(outputPath, result.LockFile),
result.LockFilePath);
if (NewPackagesLockFile != null && !string.IsNullOrEmpty(NewPackagesLockFilePath))
{
log.LogInformation(string.Format(CultureInfo.CurrentCulture,
Strings.Log_WritingPackagesLockFile,
NewPackagesLockFilePath));
FileUtility.Replace(
(outputPath) => PackagesLockFileFormat.Write(outputPath, NewPackagesLockFile),
NewPackagesLockFilePath);
}
}
}
else
{
if (toolCommit)
{
log.LogInformation(string.Format(CultureInfo.CurrentCulture,
Strings.Log_ToolSkippingAssetsFile,
result.LockFilePath));
}
else
{
log.LogInformation(string.Format(CultureInfo.CurrentCulture,
Strings.Log_SkippingAssetsFile,
result.LockFilePath));
}
}
}