public bool Equals(SnapshotMapEntry sme)
{
if (!Metadata.Equals(sme.Metadata)) return false;
if (Position != sme.Position) return false;
if (Length != sme.Length) return false;
if (Deleted != sme.Deleted) return false;
return true;
}
private void WriteSME(FileStream stream, SnapshotMapEntry sme)
{
//lock (_smeLock) {
try {
var pos = stream.Position;
// Convert the PersistenceId to bytes and store them in the buffer, leaving space at the beginning to store its length
var temp = Encoding.ASCII.GetBytes(sme.Metadata.PersistenceId);
var length = temp.Length;
var buffer = new byte[length + SIZE_OF_PERSISTENCE_ID_LENGTH + SIZE_OF_SEQ_NUM + SIZE_OF_DATE_TIME +
SIZE_OF_SNAPSHOT_LENGTH + SIZE_OF_SNAPSHOT_POSITION + SIZE_OF_DELETED];
// Convert and store the length of the persistence ID
var bits = BitConverter.GetBytes(length);
bits.CopyTo(buffer, 0);
// This is slower than the original code that placed the bytes from the persistence Id straight into the buffer
// Copy the bytes into the main buffer
temp.CopyTo(buffer, SIZE_OF_PERSISTENCE_ID_LENGTH);
// Convert the sequence number of the snapshot
var offset = length + SIZE_OF_PERSISTENCE_ID_LENGTH;
var bits1 = BitConverter.GetBytes(sme.Metadata.SequenceNr);
bits1.CopyTo(buffer, offset);
// Convert and store the timestamp of the snapshot
var datetime = sme.Metadata.Timestamp.ToBinary();
offset += SIZE_OF_SEQ_NUM;
var bits2 = BitConverter.GetBytes(datetime);
bits2.CopyTo(buffer, offset);
// Convert and store the position of the snapshot in the snapshot file
var position = sme.Position;
offset += SIZE_OF_DATE_TIME;
var bits3 = BitConverter.GetBytes(position);
bits3.CopyTo(buffer, offset);
// Convert and store the length of the snapshot
var snapLength = sme.Length;
offset += SIZE_OF_SNAPSHOT_POSITION;
var bits4 = BitConverter.GetBytes(snapLength);
bits4.CopyTo(buffer, offset);
// Convert and store the deleted marker that denotes if this snapshot is deleted
offset += SIZE_OF_SNAPSHOT_LENGTH;
buffer[offset] = (byte)(sme.Deleted ? 1 : 0);
// Write to stream
stream.Write(buffer, 0, offset + 1);
} catch (Exception e) {
_log.Error("Error writing SME, msg = {0}, location = {1}", e.Message, e.StackTrace);
throw e;
}
//}
}
/// <summary>
/// Saves the snapshot to the end of the file.
/// </summary>
/// <param name="metadata">TBD</param>
/// <param name="snapshot">TBD</param>
// [MethodImpl(MethodImplOptions.Synchronized)]
protected virtual void Save(SnapshotMetadata metadata, object snapshot)
{
_save++;
if (_save % 10000 == 0)
{
_log.Info("Save() - count of calls={0}", _saveasync);
}
lock (_smeLock)
{
try
{
// Serialize the object that describes the snapshot
var serializer = _serialization.FindSerializerFor(snapshot, _defaultSerializer);
var bytes = serializer.ToBinary(snapshot);
// Get the current location of the file stream so we know where the object is stored on the disk
var pos = _writeStream.Position;
// Write the Snapshot to disk
_writeStream.Write(bytes, 0, bytes.Length);
// Save the information about the snapshot and where it is located in the file to the map
// Create a snapshot map entry to describe the snapshot
var sme = new SnapshotMapEntry(metadata, pos, bytes.Length, false);
// _log.Debug("Save() - persitenceId={0}\tposition={1}\tlength={2}", metadata.PersistenceId, pos, bytes.Length);
// Write the SME to disk
WriteSME(_writeSMEStream, sme);
// Save the SME in the map
if (!SnapshotMap.TryGetValue(metadata.PersistenceId, out var currentValue))
{
SnapshotMap.TryAdd(sme.Metadata.PersistenceId, sme);
}
else
{
SnapshotMap.TryUpdate(sme.Metadata.PersistenceId, sme, currentValue);
}
}
catch (SerializationException e)
{
_log.Error("Failed to serialize. Reason: {0}\n{1}", e.Message, e.StackTrace);
throw e;
}
catch (Exception e)
{
_log.Error("ERROR in Save. Message={0}\n StackTrace={1}", e.Message, e.StackTrace);
throw e;
}
}
}
/// <summary>
/// Saves the snapshot to the end of the file.
/// </summary>
/// <param name="metadata">TBD</param>
/// <param name="snapshot">TBD</param>
// [MethodImpl(MethodImplOptions.Synchronized)]
protected void Save(SnapshotMetadata metadata, object original_snapshot)
{
if (!(original_snapshot is ICloneable))
{
throw new ObjectDoesNotImplementICloneable($"Type {original_snapshot.GetType()} does not implement ICloneable. It Must to be snapshotted.");
}
lock (_smeLock) {
try {
// Serialize the object that describes the snapshot
object snapshot = original_snapshot; //relegated fix to snapshot called
var serializer = _serialization.FindSerializerFor(snapshot, _defaultSerializer);
byte[] bytes = null;
try {
bytes = serializer.ToBinary(snapshot);
} catch (Exception x) {
_log.Error("ERROR Failed to serialize. {0}\n{1}", x.Message, x.StackTrace);
throw x; //debugging here
}
// Get the current location of the file stream so we know where the object is stored on the disk
var pos = _writeStream.Position;
// Write the Snapshot to disk
_writeStream.Write(bytes, 0, bytes.Length);
// Save the information about the snapshot and where it is located in the file to the map
// Create a snapshot map entry to describe the snapshot
var sme = new SnapshotMapEntry(metadata, pos, bytes.Length, false);
// Write the SME to disk
WriteSME(_writeSMEStream, sme);
// Save the SME in the map
if (SnapshotMap.TryGetValue(sme.Metadata.PersistenceId, out var currentValue))
{
SnapshotMap.TryUpdate(sme.Metadata.PersistenceId, sme, currentValue);
}
else
{
SnapshotMap.TryAdd(sme.Metadata.PersistenceId, sme);
}
} catch (SerializationException e) {
_log.Error("Failed to serialize. Reason: {0}\n{1}", e.Message, e.StackTrace);
throw e;
} catch (Exception e) {
_log.Error("ERROR in Save. Message={0}\n StackTrace={1}", e.Message, e.StackTrace);
throw e;
}
}
}