internal virtual void SerializeCache(string stateFile, TaskLoggingHelper log)
{
try
{
if (!string.IsNullOrEmpty(stateFile))
{
if (FileSystems.Default.FileExists(stateFile))
{
File.Delete(stateFile);
}
using (var s = new FileStream(stateFile, FileMode.CreateNew))
{
var translator = BinaryTranslator.GetWriteTranslator(s);
translator.Translate(ref _serializedVersion);
Translate(translator);
}
}
}
// If there was a problem writing the file (like it's read-only or locked on disk, for
// example), then eat the exception and log a warning. Otherwise, rethrow.
catch (Exception e) when(!ExceptionHandling.NotExpectedSerializationException(e))
{
// Not being able to serialize the cache is not an error, but we let the user know anyway.
// Don't want to hold up processing just because we couldn't read the file.
log.LogWarningWithCodeFromResources("General.CouldNotWriteStateFile", stateFile, e.Message);
}
}
/// <summary>
/// Writes the contents of this object out to the specified file.
/// TODO: once all derived classes from StateFileBase adopt new serialization, we shall consider to mode this into base class
/// </summary>
internal void SerializeCacheByTranslator(string stateFile, TaskLoggingHelper log)
{
try
{
if (!string.IsNullOrEmpty(stateFile))
{
if (FileSystems.Default.FileExists(stateFile))
{
File.Delete(stateFile);
}
using var s = new FileStream(stateFile, FileMode.CreateNew);
var translator = BinaryTranslator.GetWriteTranslator(s);
// write file signature
translator.Writer.Write(TranslateContractSignature);
translator.Writer.Write(TranslateContractVersion);
Translate(translator);
isDirty = false;
}
}
catch (Exception e) when(!ExceptionHandling.NotExpectedSerializationException(e))
{
// Not being able to serialize the cache is not an error, but we let the user know anyway.
// Don't want to hold up processing just because we couldn't read the file.
log.LogWarningWithCodeFromResources("General.CouldNotWriteStateFile", stateFile, e.Message);
}
}
public static (IConfigCache ConfigCache, IResultsCache ResultsCache, Exception exception) DeserializeCaches(string inputCacheFile)
{
try
{
ConfigCache configCache = null;
ResultsCache resultsCache = null;
using (var fileStream = File.OpenRead(inputCacheFile))
{
using var translator = BinaryTranslator.GetReadTranslator(fileStream, null);
translator.Translate(ref configCache);
translator.Translate(ref resultsCache);
}
ErrorUtilities.VerifyThrowInternalNull(configCache, nameof(configCache));
ErrorUtilities.VerifyThrowInternalNull(resultsCache, nameof(resultsCache));
return(configCache, resultsCache, null);
}
catch (Exception e)
{
return(null, null, e);
}
}
public void VerifyAssemblyNameExSerializationWithRemappedFromByTranslator()
{
AssemblyNameExtension assemblyNameOriginal = new AssemblyNameExtension("System.Xml, Version=10.0.0.0, Culture=en, PublicKeyToken=b03f5f7f11d50a3a");
AssemblyNameExtension assemblyRemappedFrom = new AssemblyNameExtension("System.Xml, Version=9.0.0.0, Culture=en, PublicKeyToken=b03f5f7f11d50a3a");
assemblyRemappedFrom.MarkImmutable();
assemblyNameOriginal.AddRemappedAssemblyName(assemblyRemappedFrom);
assemblyNameOriginal.RemappedFromEnumerator.Count().ShouldBe(1);
AssemblyNameExtension assemblyNameDeserialized = null;
MemoryStream serializationStream = new MemoryStream();
ITranslator writeTranslator = BinaryTranslator.GetWriteTranslator(serializationStream);
writeTranslator.Translate(ref assemblyNameOriginal, (ITranslator t) => new AssemblyNameExtension(t));
serializationStream.Seek(0, SeekOrigin.Begin);
ITranslator readTranslator = BinaryTranslator.GetReadTranslator(serializationStream, null);
readTranslator.Translate(ref assemblyNameDeserialized, (ITranslator t) => new AssemblyNameExtension(t));
assemblyNameDeserialized.Equals(assemblyNameOriginal).ShouldBeTrue();
assemblyNameDeserialized.RemappedFromEnumerator.Count().ShouldBe(1);
assemblyNameDeserialized.RemappedFromEnumerator.First().ShouldBe(assemblyRemappedFrom);
}
public void TestSerializationMode()
{
MemoryStream stream = new MemoryStream();
ITranslator translator = BinaryTranslator.GetReadTranslator(stream, null);
Assert.Equal(TranslationDirection.ReadFromStream, translator.Mode);
translator = BinaryTranslator.GetWriteTranslator(stream);
Assert.Equal(TranslationDirection.WriteToStream, translator.Mode);
}
private ITranslator GetReadTranslator()
{
if (_serializationStream == null)
{
throw new InvalidOperationException("GetWriteTranslator has to be called before GetReadTranslator");
}
_serializationStream.Seek(0, SeekOrigin.Begin);
return(BinaryTranslator.GetReadTranslator(_serializationStream, null));
}
/// <summary>
/// Reads the specified file from disk into a StateFileBase derived object.
/// </summary>
internal static StateFileBase DeserializeCache(string stateFile, TaskLoggingHelper log, Type requiredReturnType)
{
StateFileBase retVal = null;
// First, we read the cache from disk if one exists, or if one does not exist, we create one.
try
{
if (!string.IsNullOrEmpty(stateFile) && FileSystems.Default.FileExists(stateFile))
{
using (FileStream s = File.OpenRead(stateFile))
{
var translator = BinaryTranslator.GetReadTranslator(s, buffer: null);
byte version = 0;
translator.Translate(ref version);
var constructors = requiredReturnType.GetConstructors();
foreach (var constructor in constructors)
{
var parameters = constructor.GetParameters();
if (parameters.Length == 1 && parameters[0].ParameterType == typeof(ITranslator))
{
retVal = constructor.Invoke(new object[] { translator }) as StateFileBase;
}
}
// If retVal is still null or the version is wrong, log a message not a warning. This could be a valid cache with the wrong version preventing correct deserialization.
// For the latter case, internals may be unexpectedly null.
if (retVal == null || version != CurrentSerializationVersion)
{
// When upgrading to Visual Studio 2008 and running the build for the first time the resource cache files are replaced which causes a cast error due
// to a new version number on the tasks class. "Unable to cast object of type 'Microsoft.Build.Tasks.SystemState' to type 'Microsoft.Build.Tasks.StateFileBase".
// If there is an invalid cast, a message rather than a warning should be emitted.
log.LogMessageFromResources("General.CouldNotReadStateFileMessage", stateFile, log.FormatResourceString("General.IncompatibleStateFileType"));
return(null);
}
else if (!requiredReturnType.IsInstanceOfType(retVal))
{
log.LogMessageFromResources("General.CouldNotReadStateFileMessage", stateFile,
log.FormatResourceString("General.IncompatibleStateFileType"));
retVal = null;
}
}
}
}
catch (Exception e) when(!ExceptionHandling.IsCriticalException(e))
{
// The deserialization process seems like it can throw just about
// any exception imaginable. Catch them all here.
// Not being able to deserialize the cache is not an error, but we let the user know anyway.
// Don't want to hold up processing just because we couldn't read the file.
log.LogMessageFromResources("General.CouldNotReadStateFileMessage", stateFile, e.Message);
}
return(retVal);
}
public void VerifyAssemblyNameExSerializationByTranslator(string assemblyName)
{
AssemblyNameExtension assemblyNameOriginal = new AssemblyNameExtension(assemblyName);
AssemblyNameExtension assemblyNameDeserialized = null;
MemoryStream serializationStream = new MemoryStream();
ITranslator writeTranslator = BinaryTranslator.GetWriteTranslator(serializationStream);
writeTranslator.Translate(ref assemblyNameOriginal, (ITranslator t) => new AssemblyNameExtension(t));
serializationStream.Seek(0, SeekOrigin.Begin);
ITranslator readTranslator = BinaryTranslator.GetReadTranslator(serializationStream, null);
readTranslator.Translate(ref assemblyNameDeserialized, (ITranslator t) => new AssemblyNameExtension(t));
assemblyNameDeserialized.ShouldBe(assemblyNameOriginal);
}
public static void Accept(Stream input, Stream output)
{
var jsonStreamReader = new JsonStreamReader(input);
using (var binaryStream = new MemoryStream())
using (var binaryWriter = new BinaryWriter(binaryStream))
{
var commandStreamWriter = new BinaryWriter(output);
var c = jsonStreamReader.ReadChar(); // '['
Assert.IsTrue(c == '[', $"FlatJson.FrontEnd.Accept expected '[' but found '{c}' as the first character of the stream. Line=[1]");
var fileInfo = new JsonObjectFileInfo();
// Read the next full json object from '{' to '}
JsonObjectReader objectReader;
while (jsonStreamReader.TryReadObject(out objectReader, ref fileInfo))
{
objectReader.ReadBeginObject();
// Unpack the typeId
var property = objectReader.ReadPropertyNameSegment();
Assert.IsTrue(property.Array[property.Offset] == '$');
var typeId = (UTinyTypeId)objectReader.ReadUInt16();
objectReader.Position = 0;
commandStreamWriter.Write(CommandType.GetCreateCommandType(typeId));
// Translate the json object to binary
BinaryTranslator.TranslateObject(ref objectReader, binaryWriter);
// Write the command payload as binary
commandStreamWriter.Write((uint)binaryStream.Position);
commandStreamWriter.Write(binaryStream.GetBuffer(), 0, (int)binaryStream.Position);
binaryStream.Position = 0;
c = jsonStreamReader.ReadChar(); // ',' or ']'
if (!(c == ',' || c == ']'))
{
throw new Exception($"FlatJson.FrontEnd.Accept expected ',' or ']' but found '{Escape(c)}' as the next character in the stream. Line=[{objectReader.Line}]");
}
}
}
}
/// <summary>
/// Read the contents of this object out to the specified file.
/// TODO: once all classes derived from StateFileBase adopt the new serialization, we should consider moving this into the base class
/// </summary>
internal static SystemState DeserializeCacheByTranslator(string stateFile, TaskLoggingHelper log)
{
// First, we read the cache from disk if one exists, or if one does not exist, we create one.
try
{
if (!string.IsNullOrEmpty(stateFile) && FileSystems.Default.FileExists(stateFile))
{
using FileStream s = File.OpenRead(stateFile);
var translator = BinaryTranslator.GetReadTranslator(s, buffer: null); // TODO: shared buffering?
// verify file signature
var contractSignature = translator.Reader.ReadBytes(TranslateContractSignature.Length);
var contractVersion = translator.Reader.ReadByte();
if (!contractSignature.SequenceEqual(TranslateContractSignature) || contractVersion != TranslateContractVersion)
{
log.LogMessageFromResources("General.CouldNotReadStateFileMessage", stateFile, log.FormatResourceString("General.IncompatibleStateFileType"));
return(null);
}
SystemState systemState = new SystemState();
systemState.Translate(translator);
systemState.isDirty = false;
return(systemState);
}
}
catch (Exception e) when(!ExceptionHandling.IsCriticalException(e))
{
// The deserialization process seems like it can throw just about
// any exception imaginable. Catch them all here.
// Not being able to deserialize the cache is not an error, but we let the user know anyway.
// Don't want to hold up processing just because we couldn't read the file.
log.LogMessageFromResources("General.CouldNotReadStateFileMessage", stateFile, e.Message);
}
return(null);
}
public static string SerializeCaches(IConfigCache configCache, IResultsCache resultsCache, string outputCacheFile)
{
ErrorUtilities.VerifyThrowInternalNull(outputCacheFile, nameof(outputCacheFile));
try
{
if (string.IsNullOrWhiteSpace(outputCacheFile))
{
return(ResourceUtilities.FormatResourceStringIgnoreCodeAndKeyword("EmptyOutputCacheFile"));
}
var fullPath = FileUtilities.NormalizePath(outputCacheFile);
Directory.CreateDirectory(Path.GetDirectoryName(fullPath));
// Use FileStream constructor (File.OpenWrite should not be used as it doesn't reset the length of the file!)
using (var fileStream = new FileStream(fullPath, FileMode.Create, FileAccess.Write, FileShare.None))
{
var translator = BinaryTranslator.GetWriteTranslator(fileStream);
ConfigCache configCacheToSerialize = null;
ResultsCache resultsCacheToSerialize = null;
switch (configCache)
{
case ConfigCache asConfigCache:
configCacheToSerialize = asConfigCache;
break;
case ConfigCacheWithOverride configCacheWithOverride:
configCacheToSerialize = configCacheWithOverride.CurrentCache;
break;
default:
ErrorUtilities.ThrowInternalErrorUnreachable();
break;
}
switch (resultsCache)
{
case ResultsCache asResultsCache:
resultsCacheToSerialize = asResultsCache;
break;
case ResultsCacheWithOverride resultsCacheWithOverride:
resultsCacheToSerialize = resultsCacheWithOverride.CurrentCache;
break;
default:
ErrorUtilities.ThrowInternalErrorUnreachable();
break;
}
translator.Translate(ref configCacheToSerialize);
translator.Translate(ref resultsCacheToSerialize);
}
}
catch (Exception e)
{
return(ResourceUtilities.FormatResourceStringIgnoreCodeAndKeyword("ErrorWritingCacheFile", outputCacheFile, e.Message));
}
return(null);
}
/// <summary>
/// Gets a serializer used to read data. Note that only one such serializer may be used from this class at a time,
/// and this must be called after GetWriteTranslator() has been called.
/// </summary>
internal static ITranslator GetReadTranslator()
{
s_serializationStream.Seek(0, SeekOrigin.Begin);
return(BinaryTranslator.GetReadTranslator(s_serializationStream, null));
}
/// <summary>
/// Gets a serializer used to write data. Note that only one such serializer may be used from this class at a time.
/// </summary>
internal static ITranslator GetWriteTranslator()
{
s_serializationStream = new MemoryStream();
return(BinaryTranslator.GetWriteTranslator(s_serializationStream));
}
private ITranslator GetWriteTranslator()
{
_serializationStream = new MemoryStream();
return(BinaryTranslator.GetWriteTranslator(_serializationStream));
}
