private void AddMessage(IAssetsLogMessage message)
{
var logToMsBuild = true;
var targetGraphs = message.GetTargetGraphs(LockFile);
targetGraphs = targetGraphs.Any() ? targetGraphs : new LockFileTarget[] { null };
foreach (var target in targetGraphs)
{
var targetLib = message.LibraryId == null ? null : target?.GetTargetLibrary(message.LibraryId);
Diagnostics.Add(
message.Code.ToString(),
message.Message,
message.FilePath,
FromLogLevel(message.Level),
message.StartLineNumber,
message.StartColumnNumber,
message.EndLineNumber,
message.EndColumnNumber,
target?.Name,
targetLib == null ? null : $"{targetLib.Name}/{targetLib.Version.ToNormalizedString()}",
logToMsBuild);
logToMsBuild = false; // only write first instance of this diagnostic to msbuild
}
}
/// <summary>
/// Converts the <code>IAssetsLogMessage</code> object into a <code>JObject</code> that can be written into the assets file.
/// </summary>
/// <param name="logMessage"><code>IAssetsLogMessage</code> representing the log message.</param>
/// <returns><code>JObject</code> containg the json representation of the log message.</returns>
private static JObject WriteLogMessage(IAssetsLogMessage logMessage, string projectPath)
{
var logJObject = new JObject()
{
[LogMessageProperties.CODE] = Enum.GetName(typeof(NuGetLogCode), logMessage.Code),
[LogMessageProperties.LEVEL] = Enum.GetName(typeof(LogLevel), logMessage.Level)
};
if (logMessage.Level == LogLevel.Warning)
{
logJObject[LogMessageProperties.WARNING_LEVEL] = (int)logMessage.WarningLevel;
}
if (logMessage.FilePath != null &&
(projectPath == null || !PathUtility.GetStringComparerBasedOnOS().Equals(logMessage.FilePath, projectPath)))
{
// Do not write the file path if it is the same as the project path.
// This prevents duplicate information in the lock file.
logJObject[LogMessageProperties.FILE_PATH] = logMessage.FilePath;
}
if (logMessage.StartLineNumber > 0)
{
logJObject[LogMessageProperties.START_LINE_NUMBER] = logMessage.StartLineNumber;
}
if (logMessage.StartColumnNumber > 0)
{
logJObject[LogMessageProperties.START_COLUMN_NUMBER] = logMessage.StartColumnNumber;
}
if (logMessage.EndLineNumber > 0)
{
logJObject[LogMessageProperties.END_LINE_NUMBER] = logMessage.EndLineNumber;
}
if (logMessage.EndColumnNumber > 0)
{
logJObject[LogMessageProperties.END_COLUMN_NUMBER] = logMessage.EndColumnNumber;
}
if (logMessage.Message != null)
{
logJObject[LogMessageProperties.MESSAGE] = logMessage.Message;
}
if (logMessage.LibraryId != null)
{
logJObject[LogMessageProperties.LIBRARY_ID] = logMessage.LibraryId;
}
if (logMessage.TargetGraphs != null &&
logMessage.TargetGraphs.Any() &&
logMessage.TargetGraphs.All(l => !string.IsNullOrEmpty(l)))
{
logJObject[LogMessageProperties.TARGET_GRAPHS] = new JArray(logMessage.TargetGraphs);
}
return(logJObject);
}
public bool Equals(IAssetsLogMessage other)
{
return(other.Code == Code &&
other.Level == Level &&
other.WarningLevel == WarningLevel &&
other.Message == Message &&
other.LibraryId == LibraryName);
}
public AssetsFileLogMessage(IAssetsLogMessage logMessage)
{
Code = logMessage.Code;
Level = logMessage.Level;
WarningLevel = logMessage.WarningLevel;
Message = logMessage.Message;
LibraryName = logMessage.LibraryId;
}
/// <summary>
/// Get the library from each target graph it exists in.
/// </summary>
public static IEnumerable <LockFileTargetLibrary> GetTargetLibraries(this IAssetsLogMessage message, LockFile assetsFile)
{
if (message == null)
{
throw new ArgumentNullException(nameof(message));
}
if (assetsFile == null)
{
throw new ArgumentNullException(nameof(assetsFile));
}
return(message.GetTargetGraphs(assetsFile).Select(target => target.GetTargetLibrary(message.LibraryId)));
}
/// <summary>
/// Get target graphs for the current log message.
/// </summary>
public static IEnumerable <LockFileTarget> GetTargetGraphs(this IAssetsLogMessage message, LockFile assetsFile)
{
if (message == null)
{
throw new ArgumentNullException(nameof(message));
}
if (assetsFile == null)
{
throw new ArgumentNullException(nameof(assetsFile));
}
return(assetsFile.Targets.Where(target => message.TargetGraphs.Contains(target.Name, StringComparer.OrdinalIgnoreCase)));
}
/// <summary>
/// Converts an IAssetsLogMessage into a RestoreLogMessage.
/// This is needed when an IAssetsLogMessage needs to be logged and loggers do not have visibility to IAssetsLogMessage.
/// </summary>
/// <param name="logMessage">IAssetsLogMessage to be converted.</param>
/// <returns>RestoreLogMessage equivalent to the IAssetsLogMessage.</returns>
public static RestoreLogMessage AsRestoreLogMessage(this IAssetsLogMessage logMessage)
{
return(new RestoreLogMessage(logMessage.Level, logMessage.Code, logMessage.Message)
{
ProjectPath = logMessage.ProjectPath,
WarningLevel = logMessage.WarningLevel,
FilePath = logMessage.FilePath,
LibraryId = logMessage.LibraryId,
TargetGraphs = logMessage.TargetGraphs,
StartLineNumber = logMessage.StartLineNumber,
StartColumnNumber = logMessage.StartColumnNumber,
EndLineNumber = logMessage.EndLineNumber,
EndColumnNumber = logMessage.EndColumnNumber
});
}
/// <summary>
/// Get target graphs for the current log message.
/// </summary>
/// <remarks>If the message does not contain target graphs all graphs in the file
/// will be returned.</remarks>
public static IEnumerable <LockFileTarget> GetTargetGraphs(this IAssetsLogMessage message, LockFile assetsFile)
{
if (message == null)
{
throw new ArgumentNullException(nameof(message));
}
if (assetsFile == null)
{
throw new ArgumentNullException(nameof(assetsFile));
}
// If the message does not contain any target graph it should apply to all graphs.
if (message.TargetGraphs == null || message.TargetGraphs.Count == 0)
{
return(assetsFile.Targets);
}
return(assetsFile.Targets.Where(target => message.TargetGraphs.Contains(target.Name, StringComparer.OrdinalIgnoreCase)));
}
private void AddMessage(IAssetsLogMessage message)
{
var targetGraphs = message.GetTargetGraphs(LockFile);
targetGraphs = targetGraphs.Any() ? targetGraphs : new LockFileTarget[] { null };
foreach (var target in targetGraphs)
{
var targetLib = message.LibraryId == null ? null : target?.GetTargetLibrary(message.LibraryId);
_diagnostics.Add(
message.Code.ToString(),
message.Message,
message.FilePath,
FromLogLevel(message.Level),
message.StartLineNumber,
message.StartColumnNumber,
message.EndLineNumber,
message.EndColumnNumber,
target?.Name,
targetLib == null ? null : $"{targetLib.Name}/{targetLib.Version.ToNormalizedString()}");
}
}
public async Task RestoreAsync_WithMinimalProjectAndAdditionalErrorMessage_WritesErrorsToAssetsFile()
{
// Arrange
var projectName = "testproj";
var logger = new TestLogger();
using (var rootFolder = TestDirectory.Create())
{
var projectFolder = new DirectoryInfo(Path.Combine(rootFolder, projectName));
projectFolder.Create();
var objFolder = projectFolder.CreateSubdirectory("obj");
var msbuildProjectPath = new FileInfo(Path.Combine(projectFolder.FullName, $"{projectName}.csproj"));
var globalPackagesFolder = Path.Combine(rootFolder, "gpf");
var sources = new SourceRepository[0];
var restoreContext = new DependencyGraphCacheContext(logger, NullSettings.Instance);
var solutionManager = new Mock <ISolutionManager>();
var restoreCommandProvidersCache = new RestoreCommandProvidersCache();
// When a VS nomination results in an exception, we use this minimal DGSpec to do a restore.
var dgSpec = DependencyGraphSpecTestUtilities.CreateMinimalDependencyGraphSpec(msbuildProjectPath.FullName, objFolder.FullName);
dgSpec.AddRestore(dgSpec.Projects[0].FilePath);
// CpsPackageReferenceProject sets some additional properties, from settings, in GetPackageSpecsAndAdditionalMessages(...)
dgSpec.Projects[0].RestoreMetadata.PackagesPath = globalPackagesFolder;
// Having an "additional" error message is also critical
var restoreLogMessage = new RestoreLogMessage(LogLevel.Error, NuGetLogCode.NU1000, "Test error")
{
FilePath = msbuildProjectPath.FullName,
ProjectPath = msbuildProjectPath.FullName
};
var additionalMessages = new List <IAssetsLogMessage>()
{
AssetsLogMessage.Create(restoreLogMessage)
};
// Act
await DependencyGraphRestoreUtility.RestoreAsync(
dgSpec,
restoreContext,
restoreCommandProvidersCache,
cacheContextModifier : _ => { },
sources,
parentId : Guid.Empty,
forceRestore : false,
isRestoreOriginalAction : true,
additionalMessages,
progressReporter : null,
logger,
CancellationToken.None);
// Assert
var assetsFilePath = Path.Combine(objFolder.FullName, "project.assets.json");
Assert.True(File.Exists(assetsFilePath), "Assets file does not exist");
LockFile assetsFile = new LockFileFormat().Read(assetsFilePath);
IAssetsLogMessage actualMessage = Assert.Single(assetsFile.LogMessages);
Assert.Equal(restoreLogMessage.Level, actualMessage.Level);
Assert.Equal(restoreLogMessage.Code, actualMessage.Code);
Assert.Equal(restoreLogMessage.Message, actualMessage.Message);
}
}
/// <summary>
/// Writes the <see cref="IAssetsLogMessage"/> object to the <see cref="JsonWriter"/>.
/// </summary>
/// <param name="logMessage"><code>IAssetsLogMessage</code> representing the log message.</param>
private static void WriteLogMessage(JsonWriter writer, IAssetsLogMessage logMessage, string projectPath)
{
writer.WriteStartObject();
writer.WritePropertyName(LogMessageProperties.CODE);
writer.WriteValue(Enum.GetName(typeof(NuGetLogCode), logMessage.Code));
writer.WritePropertyName(LogMessageProperties.LEVEL);
writer.WriteValue(Enum.GetName(typeof(LogLevel), logMessage.Level));
if (logMessage.Level == LogLevel.Warning)
{
writer.WritePropertyName(LogMessageProperties.WARNING_LEVEL);
writer.WriteValue((int)logMessage.WarningLevel);
}
if (logMessage.FilePath != null &&
(projectPath == null || !PathUtility.GetStringComparerBasedOnOS().Equals(logMessage.FilePath, projectPath)))
{
// Do not write the file path if it is the same as the project path.
// This prevents duplicate information in the lock file.
writer.WritePropertyName(LogMessageProperties.FILE_PATH);
writer.WriteValue(logMessage.FilePath);
}
if (logMessage.StartLineNumber > 0)
{
writer.WritePropertyName(LogMessageProperties.START_LINE_NUMBER);
writer.WriteValue(logMessage.StartLineNumber);
}
if (logMessage.StartColumnNumber > 0)
{
writer.WritePropertyName(LogMessageProperties.START_COLUMN_NUMBER);
writer.WriteValue(logMessage.StartColumnNumber);
}
if (logMessage.EndLineNumber > 0)
{
writer.WritePropertyName(LogMessageProperties.END_LINE_NUMBER);
writer.WriteValue(logMessage.EndLineNumber);
}
if (logMessage.EndColumnNumber > 0)
{
writer.WritePropertyName(LogMessageProperties.END_COLUMN_NUMBER);
writer.WriteValue(logMessage.EndColumnNumber);
}
if (logMessage.Message != null)
{
writer.WritePropertyName(LogMessageProperties.MESSAGE);
writer.WriteValue(logMessage.Message);
}
if (logMessage.LibraryId != null)
{
writer.WritePropertyName(LogMessageProperties.LIBRARY_ID);
writer.WriteValue(logMessage.LibraryId);
}
if (logMessage.TargetGraphs != null &&
logMessage.TargetGraphs.Any() &&
logMessage.TargetGraphs.All(l => !string.IsNullOrEmpty(l)))
{
writer.WritePropertyName(LogMessageProperties.TARGET_GRAPHS);
WriteArray(writer, logMessage.TargetGraphs);
}
writer.WriteEndObject();
}
