/// <summary>
/// Gets operation data from state providers.
/// </summary>
public async Task <OperationData> GetNextAsync(CancellationToken cancellationToken)
{
try
{
while (this.currentIndex < this.operationDataStreamCollection.Count)
{
StateProviderIdentifier stateProviderIdentifier = this.operationDataStreamCollection[this.currentIndex].Item1;
IOperationDataStream operationDataStream = this.operationDataStreamCollection[this.currentIndex].Item2;
OperationData operationData = await operationDataStream.GetNextAsync(cancellationToken).ConfigureAwait(false);
if (operationData == null)
{
++this.currentIndex;
continue;
}
// Reserve the List space with expected size: Version, ID, OperationData
List <ArraySegment <byte> > namedBytes = new List <ArraySegment <byte> >(2 + operationData.Count);
byte[] versionAsBytes = BitConverter.GetBytes(this.version);
namedBytes.Add(new ArraySegment <byte>(versionAsBytes));
long stateProviderId = stateProviderIdentifier.StateProviderId;
byte[] idAsBytes = BitConverter.GetBytes(stateProviderId);
namedBytes.Add(new ArraySegment <byte>(idAsBytes));
foreach (ArraySegment <byte> roll in operationData)
{
namedBytes.Add(roll);
}
return(new OperationData(namedBytes));
}
FabricEvents.Events.NamedOperationDataCollectionGetNext(this.traceType);
return(null);
}
catch (Exception e)
{
string msg = string.Format(
CultureInfo.InvariantCulture,
"OperationDataStreamCollection Count: {0}, CurrentIndex: {1}.",
this.operationDataStreamCollection.Count,
this.currentIndex);
StateManagerStructuredEvents.TraceException(
this.traceType,
"NamedOperationDataCollection.GetNextAsync.",
msg,
e);
throw;
}
}
public static void SerializeRedoData(
ReplicationMetadata replicationMetadata,
string traceType,
InMemoryBinaryWriter writer)
{
try
{
writer.Write(replicationMetadata.Type);
writer.WriteNullable(replicationMetadata.InitializationContext);
writer.Write(replicationMetadata.ParentStateProviderId);
}
catch (Exception e)
{
StateManagerStructuredEvents.TraceException(traceType, "ReplicationMetadata.Serialize", string.Empty, e);
throw;
}
}
/// <summary>
/// Serializes replication metadata.
/// </summary>
public static void SerializeMetaData(
ReplicationMetadata replicationMetadata,
string traceType,
InMemoryBinaryWriter writer)
{
try
{
writer.Write(replicationMetadata.Version);
writer.Write(replicationMetadata.StateProviderId);
writer.Write(replicationMetadata.Name);
writer.Write((byte)replicationMetadata.StateManagerApplyType);
}
catch (Exception e)
{
StateManagerStructuredEvents.TraceException(traceType, "ReplicationMetadata.Serialize", string.Empty, e);
throw;
}
}
/// <summary>
/// Deserializes replication metadata.
/// </summary>
public static void DeserializeMetadataForUndoOperation(
InMemoryBinaryReader metaDataReader,
string traceType,
int currentVersion,
out long stateProviderId,
out Uri stateProviderName,
out StateManagerApplyType applyType)
{
try
{
// Read meta data.
int version;
DeserializeMetadata(
metaDataReader,
traceType,
currentVersion,
out stateProviderId,
out stateProviderName,
out applyType,
out version);
Utility.Assert(applyType != StateManagerApplyType.Invalid, "Invalid apply type");
if (applyType == StateManagerApplyType.Delete)
{
applyType = StateManagerApplyType.Insert;
}
else
{
applyType = StateManagerApplyType.Delete;
}
}
catch (Exception e)
{
StateManagerStructuredEvents.TraceException(
traceType,
"ReplicationMetadata.Deserialize",
string.Empty,
e);
throw;
}
}
/// <summary>
/// Gets named operation data from operation data.
/// </summary>
public static NamedOperationData Deserialize(
OperationData operationData,
string traceType,
int currentVersion)
{
try
{
List <ArraySegment <byte> > copiedBytes = new List <ArraySegment <byte> >();
int deserializedVersion = BitConverter.ToInt32(operationData[0].Array, 0);
if (deserializedVersion != currentVersion)
{
string errorMessage = string.Format(
CultureInfo.InvariantCulture,
SR.Error_Unsupported_Version_Deserialization,
deserializedVersion,
currentVersion);
FabricEvents.Events.NamedOperationDataDeserializeError(traceType, errorMessage);
throw new NotSupportedException(errorMessage);
}
// state provider id
long stateProviderId = BitConverter.ToInt64(operationData[1].Array, 0);
for (int i = 2; i < operationData.Count; i++)
{
copiedBytes.Add(operationData[i]);
}
return(new NamedOperationData(new OperationData(copiedBytes), stateProviderId, traceType));
}
catch (Exception e)
{
StateManagerStructuredEvents.TraceException(
traceType,
"NamedOperationData.Deserialize",
string.Empty,
e);
throw;
}
}
/// <summary>
/// Deserializes replication metadata.
/// </summary>
private static void DeserializeMetadata(
InMemoryBinaryReader metaDataReader,
string traceType,
int currentVersion,
out long stateProviderId,
out Uri stateProviderName,
out StateManagerApplyType applyType,
out int version)
{
try
{
version = metaDataReader.ReadInt32();
if (version != currentVersion)
{
var errorMessage = string.Format(
CultureInfo.InvariantCulture,
SR.Error_Unsupported_Version_Deserialization,
version,
currentVersion);
FabricEvents.Events.ReplicationMetadataDeserializeError(traceType, errorMessage);
throw new NotSupportedException(errorMessage);
}
stateProviderId = metaDataReader.ReadInt64();
stateProviderName = metaDataReader.ReadUri();
applyType = (StateManagerApplyType)metaDataReader.ReadByte();
Utility.Assert(applyType != StateManagerApplyType.Invalid, "Invalid apply type");
}
catch (Exception e)
{
StateManagerStructuredEvents.TraceException(
traceType,
"ReplicationMetadata.Deserialize",
string.Empty,
e);
throw;
}
}
/// <summary>
/// Deserializes replication metadata and the redodata.
/// </summary>
public static ReplicationMetadata Deserialize(
InMemoryBinaryReader metaDataReader,
InMemoryBinaryReader redoDataReader,
string traceType,
int currentVersion)
{
try
{
// Read meta data first
long stateProviderId;
Uri name;
StateManagerApplyType operationType;
int version;
DeserializeMetadata(
metaDataReader,
traceType,
currentVersion,
out stateProviderId,
out name,
out operationType,
out version);
if (redoDataReader == null)
{
return(new ReplicationMetadata(
name,
stateProviderId,
DynamicStateManager.StateManagerId,
version,
operationType));
}
// Read Data Next
string typeName;
Type type = redoDataReader.ReadType(out typeName);
Utility.Assert(type != null, SR.Assert_SM_TypeNotFound, traceType, typeName, name.ToString());
byte[] initializationParameters = redoDataReader.ReadNullableBytes();
long parentStateProviderId = redoDataReader.ReadInt64();
// Since this is used in redo only scenarios, it is safe to assuem apply type is same as the original opeartion type.
ReplicationMetadata replicationMetadata = new ReplicationMetadata(
name,
type,
initializationParameters,
stateProviderId,
parentStateProviderId,
version,
operationType);
return(replicationMetadata);
}
catch (Exception e)
{
StateManagerStructuredEvents.TraceException(
traceType,
"ReplicationMetadata.Deserialize",
string.Empty,
e);
throw;
}
}
