public OutboundMessage(IOperationData data)
{
this.data = data;
var sizes = data.Select(elem => elem.Count).ToArray();
var segmentCount = sizes.Length;
this.headerBuffer = new byte[sizeof(Int32) + segmentCount * sizeof(Int32)];
var ms = new MemoryStream(this.headerBuffer);
ms.Write(BitConverter.GetBytes(segmentCount), 0, sizeof(Int32));
foreach (var i in sizes)
{
ms.Write(BitConverter.GetBytes(i), 0, sizeof(Int32));
}
}
public unsafe NativeRuntime.IFabricOperationData CreateOperationData(IOperationData data)
{
if (data == null)
{
return(null);
}
uint[] sizes = data.Select(element => (uint)element.Count).ToArray();
if (sizes.Length == 0)
{
return(null);
}
return(CreateNativeOperationData(data, sizes));
}
/// <summary>
/// Receive and record the message (used for verification)
/// </summary>
/// <returns></returns>
private bool ReceiveAndRecordMessages()
{
bool sessionClosed = false;
bool sessionAborted = false;
int messageSequence = 0;
int messageNumber;
LogHelper.Log("SessionId: {0}; Entering ReceiveAndRecordMessages", this.SessionId);
while (!sessionClosed && !sessionAborted)
{
try
{
byte[][] dataReceived;
Task <IOperationData> receiveTask = this.InboundSession.ReceiveAsync(new CancellationToken());
receiveTask.Wait();
IOperationData receivedMessageData = receiveTask.Result;
dataReceived = receivedMessageData.Select(element => element.Array).ToArray();
byte[] flatReceivedMessage = Flatten(dataReceived);
int[] parsedReceivedMessage = ParseMessage(flatReceivedMessage);
messageNumber = parsedReceivedMessage[0];
// ordered delivery check
Assert.AreEqual(messageNumber, messageSequence, "Message# {0} received out of order", messageNumber);
Assert.IsNull(this.flatMessagesReceived[messageNumber],
"flatMessagesReceived[{0}] non-null while being initialized", messageNumber);
this.flatMessagesReceived[messageNumber] = flatReceivedMessage;
this.actualMessagesReceived[messageNumber] = dataReceived;
int messageLength = this.flatMessagesReceived[messageNumber].Length;
this.totalBytesReceived += messageLength;
LogHelper.Log("SessionId: {0}; received message# {1} size {2}", this.SessionId, messageNumber, messageLength);
}
catch (AggregateException e)
{
Exception inner = e.InnerException.InnerException;
Assert.AreEqual(inner.GetType(), typeof(COMException),
"Unexpected AggregateException {0} from ReceiveAsync", inner.GetType().ToString());
COMException realException = (COMException)inner;
uint hresult = (uint)realException.ErrorCode;
// Normal close scenario
uint expectedCloseError = (uint)NativeTypes.FABRIC_ERROR_CODE.FABRIC_E_OBJECT_CLOSED;
// If a session abort happened after DequeueOperation was started but before it completed
uint expectedCancelError = (uint)NativeTypes.FABRIC_ERROR_CODE.E_ABORT;
Assert.IsTrue(expectedCloseError == hresult || expectedCancelError == hresult,
"Unexpected error HRESULT code {0} from ReceiveAsync", hresult);
sessionClosed = true;
}
catch (System.Fabric.FabricObjectClosedException e)
{
LogHelper.Log("SessionId: {0}; standard exception {1} from ReceiveAsync", this.SessionId, e.GetType());
sessionAborted = true;
}
catch (Exception e)
{
Assert.AreEqual(e.GetType(), typeof(InvalidOperationException),
"Unexpected standard exception {0} from ReceiveAsync", e.GetType().ToString());
sessionAborted = true;
}
messageSequence++;
}
LogHelper.Log("SessionId: {0}; Exiting ReceiveAndRecordMessages", this.SessionId);
return(sessionAborted);
}
