/// <summary>
/// Encode and write to the memory stream.
///
/// PartitionType + ServiceInstanceName + PartitionName(/range).
///
/// TODO:Check if there is enough room in the stream
/// </summary>
/// <param name="writer">BinaryWriter to serialize to.</param>
internal void Encode(BinaryWriter writer)
{
// write kind field
writer.Write((int)this.Kind);
// write the service instance name size and content
var encoder = new StringEncoder(this.serviceInstanceString);
encoder.Encode(writer);
switch (this.Kind)
{
case PartitionKind.Singleton:
break;
case PartitionKind.Numbered:
// write partition number
writer.Write(this.partitionRange.IntegerKeyLow);
writer.Write(this.partitionRange.IntegerKeyHigh);
break;
case PartitionKind.Named:
encoder = new StringEncoder(this.PartitionName);
encoder.Encode(writer);
break;
}
}
/// <summary>
/// Assembles the stream name key object from byte array
/// </summary>
/// <param name="reader">BinaryReader to deserialize from</param>
/// <returns>Stream name key object</returns>
public StreamNameKey Read(BinaryReader reader)
{
var encoder = new StringEncoder();
// Decode Service stream name
var streamName = new Uri(encoder.Decode(reader));
// Decode Partner info
var partnerId = PartitionKey.Decode(reader);
return(new StreamNameKey(streamName, partnerId));
}
/// <summary>
/// Set the BaseStreamMetadataBody properties
/// </summary>
/// <param name="metadataKind">Kind of StreamMetadata</param>
/// <param name="streamName">Name of the stream </param>
/// <param name="partnerId">Partner Id</param>
/// <param name="currentState">Current persistent state of the stream</param>
/// <param name="closeMessageSequenceNumber">Closing sequence number of the message</param>
protected void InitializeBaseParameters(
StreamMetadataKind metadataKind, Uri streamName, PartitionKey partnerId, PersistentStreamState currentState, long closeMessageSequenceNumber)
{
this.MetadataKind = metadataKind;
this.StreamName = streamName;
this.PartnerId = partnerId;
this.CurrentState = currentState;
this.CloseMessageSequenceNumber = closeMessageSequenceNumber;
var encoder = new StringEncoder(this.StreamName.OriginalString);
this.BaseEncodeLength = (sizeof(int) * 2) + (sizeof(long) * 2) + encoder.EncodingByteCount + this.PartnerId.EncodingByteCount;
}
/// <summary>
/// Write BaseStreamMetadataBody to Memory Stream
/// </summary>
/// <param name="writer">BinaryWriter to serialize to.</param>
protected void WriteBaseParameters(BinaryWriter writer)
{
writer.Write((int)this.MetadataKind);
writer.Write((int)this.CurrentState);
writer.Write(this.CurrentStateDate.Ticks);
writer.Write(this.CloseMessageSequenceNumber);
var encoder = new StringEncoder(this.StreamName.OriginalString);
encoder.Encode(writer);
this.PartnerId.Encode(writer);
}
internal InboundOpenStreamName(InboundBaseStreamWireMessage inboundBaseMessage)
{
Diagnostics.Assert(
inboundBaseMessage.Kind == StreamWireProtocolMessageKind.OpenStream,
"Wrong kind of InboundBaseStreamWireMessage used to construct InboundOpenStreamName");
Diagnostics.Assert(
inboundBaseMessage.Payload != null,
"null streamName payload in InboundBaseStreamWireMessage used to construct InboundOpenStreamName");
var encoder = new StringEncoder();
var reader = new BinaryReader(new MemoryStream(inboundBaseMessage.Payload));
this.StreamName = new Uri(encoder.Decode(reader));
Diagnostics.Assert(reader.PeekChar() == -1, "streamName payload in InboundBaseStreamWireMessage contains more than streamName");
}
/// <summary>
/// Read BaseStreamMetadataBody from Memory Stream
/// </summary>
/// <param name="reader">BinaryReader to deserialize from</param>
protected void ReadBaseParameters(BinaryReader reader)
{
this.MetadataKind = (StreamMetadataKind)reader.ReadInt32();
this.CurrentState = (PersistentStreamState)reader.ReadInt32();
this.CurrentStateDate = DateTime.FromBinary(reader.ReadInt64());
this.CloseMessageSequenceNumber = reader.ReadInt64();
var encoder = new StringEncoder();
this.StreamName = new Uri(encoder.Decode(reader));
this.PartnerId = PartitionKey.Decode(reader);
this.BaseEncodeLength = (sizeof(int) * 2) + (sizeof(long) * 2) + encoder.EncodingByteCount + this.PartnerId.EncodingByteCount;
}
// outbound ctor
internal OutboundOpenStreamWireMessage(Guid streamId, Uri streamName)
: base(StreamWireProtocolMessageKind.OpenStream, streamId, 0)
{
this.streamName = streamName;
// TODO: Check if we need to throw instead, as this replica
Diagnostics.Assert((streamId != Guid.Empty), "Stream Id in Outbound Open stream wire message is empty.");
Diagnostics.Assert((streamName != null), "Stream Name in Open stream wire message is null.");
// Stream name
var encoder = new StringEncoder(streamName.OriginalString);
var streamNameByteLength = encoder.EncodingByteCount;
// Payload
this.Payload = new byte[streamNameByteLength];
var writer = new BinaryWriter(new MemoryStream());
encoder.Encode(writer);
}
