public void TransitionExpectEpoxyHeaders_Valid()
{
EpoxyHeaders headers = null;
ProtocolErrorCode?errorCode = null;
var after = EpoxyProtocol.TransitionExpectEpoxyHeaders(
EpoxyProtocol.ClassifyState.ExpectEpoxyHeaders, goodRequestFrame, ref headers, ref errorCode, LoggerTests.BlackHole);
Assert.AreEqual(EpoxyProtocol.ClassifyState.ExpectOptionalLayerData, after);
Assert.NotNull(headers);
Assert.AreEqual(GoodRequestId, headers.conversation_id);
Assert.AreEqual(GoodService, headers.service_name);
Assert.AreEqual(GoodMethod, headers.method_name);
Assert.AreEqual(EpoxyMessageType.REQUEST, headers.message_type);
Assert.Null(errorCode);
after = EpoxyProtocol.TransitionExpectEpoxyHeaders(
EpoxyProtocol.ClassifyState.ExpectEpoxyHeaders, goodRequestLayerDataFrame,
ref headers, ref errorCode, LoggerTests.BlackHole);
Assert.AreEqual(EpoxyProtocol.ClassifyState.ExpectOptionalLayerData, after);
Assert.NotNull(headers);
Assert.AreEqual(GoodRequestId, headers.conversation_id);
Assert.AreEqual(GoodService, headers.service_name);
Assert.AreEqual(GoodMethod, headers.method_name);
Assert.AreEqual(EpoxyMessageType.REQUEST, headers.message_type);
Assert.Null(errorCode);
}
internal static ClassifyState TransitionExpectOptionalLayerData(
ClassifyState state, Frame frame, EpoxyHeaders headers, ref ArraySegment <byte> layerData,
ref ProtocolErrorCode?errorCode, Logger logger)
{
Debug.Assert(state == ClassifyState.ExpectOptionalLayerData);
Debug.Assert(frame != null);
if (headers == null)
{
return(ClassifyState.InternalStateError);
}
if (frame.Count < 2)
{
logger.Site().Error("Frame had headers but no message data.");
errorCode = ProtocolErrorCode.MALFORMED_DATA;
return(ClassifyState.MalformedFrame);
}
var framelet = frame.Framelets[1];
if (framelet.Type == FrameletType.LayerData)
{
layerData = framelet.Contents;
logger.Site().Debug("Extracted {0}-byte layer data in conversation ID {1}.",
layerData.Count, headers.conversation_id);
}
return(ClassifyState.ExpectMessageData);
}
public void TransitionExpectPayloadOrError_MalformedFrame()
{
var message = default(EpoxyProtocol.MessageData);
ProtocolErrorCode?errorCode = null;
var after = EpoxyProtocol.TransitionExpectMessageData(
EpoxyProtocol.ClassifyState.ExpectMessageData, emptyFrame, goodRequestHeaders, emptyLayerData,
ref message, ref errorCode, LoggerTests.BlackHole);
Assert.AreEqual(EpoxyProtocol.ClassifyState.MalformedFrame, after);
Assert.Null(message.Data.Array);
Assert.AreEqual(ProtocolErrorCode.MALFORMED_DATA, errorCode);
after = EpoxyProtocol.TransitionExpectMessageData(
EpoxyProtocol.ClassifyState.ExpectMessageData, shortRequestFrame, goodRequestHeaders, emptyLayerData,
ref message, ref errorCode, LoggerTests.BlackHole);
Assert.AreEqual(EpoxyProtocol.ClassifyState.MalformedFrame, after);
Assert.Null(message.Data.Array);
Assert.AreEqual(ProtocolErrorCode.MALFORMED_DATA, errorCode);
after = EpoxyProtocol.TransitionExpectMessageData(
EpoxyProtocol.ClassifyState.ExpectMessageData, goodRequestLayerDataFrame, goodRequestHeaders, emptyLayerData,
ref message, ref errorCode, LoggerTests.BlackHole);
Assert.AreEqual(EpoxyProtocol.ClassifyState.MalformedFrame, after);
Assert.Null(message.Data.Array);
Assert.AreEqual(ProtocolErrorCode.MALFORMED_DATA, errorCode);
after = EpoxyProtocol.TransitionExpectMessageData(
EpoxyProtocol.ClassifyState.ExpectMessageData, goodRequestFrame, goodRequestHeaders, goodLayerData,
ref message, ref errorCode, LoggerTests.BlackHole);
Assert.AreEqual(EpoxyProtocol.ClassifyState.MalformedFrame, after);
Assert.Null(message.Data.Array);
Assert.AreEqual(ProtocolErrorCode.MALFORMED_DATA, errorCode);
}
internal static ClassifyState TransitionExpectFirstFramelet(
ClassifyState state, Frame frame, ref ProtocolErrorCode?errorCode, Logger logger)
{
Debug.Assert(state == ClassifyState.ExpectFirstFramelet);
Debug.Assert(frame != null);
if (frame.Framelets.Count == 0)
{
logger.Site().Error("Frame was empty.");
errorCode = ProtocolErrorCode.MALFORMED_DATA;
return(ClassifyState.MalformedFrame);
}
switch (frame.Framelets[0].Type)
{
case FrameletType.EpoxyHeaders:
return(ClassifyState.ExpectEpoxyHeaders);
case FrameletType.EpoxyConfig:
return(ClassifyState.ExpectConfig);
case FrameletType.ProtocolError:
return(ClassifyState.ExpectProtocolError);
default:
logger.Site().Error("Frame began with invalid FrameletType {0}.", frame.Framelets[0].Type);
errorCode = ProtocolErrorCode.MALFORMED_DATA;
return(ClassifyState.MalformedFrame);
}
}
internal static ClassifyState TransitionExpectPayload(
ClassifyState state, Frame frame, EpoxyHeaders headers, ArraySegment <byte> layerData,
ref ArraySegment <byte> payload, ref ProtocolErrorCode?errorCode, Logger logger)
{
Debug.Assert(state == ClassifyState.ExpectPayload);
Debug.Assert(frame != null);
if (headers == null)
{
return(ClassifyState.InternalStateError);
}
int payloadDataIndex = (layerData.Array == null ? 1 : 2);
if (payloadDataIndex >= frame.Count)
{
logger.Site().Error("Frame had headers but no payload.");
errorCode = ProtocolErrorCode.MALFORMED_DATA;
return(ClassifyState.MalformedFrame);
}
var framelet = frame.Framelets[payloadDataIndex];
if (framelet.Type != FrameletType.PayloadData)
{
logger.Site().Error("Frame had headers but no payload.");
errorCode = ProtocolErrorCode.MALFORMED_DATA;
return(ClassifyState.MalformedFrame);
}
payload = framelet.Contents;
logger.Site().Debug("Extracted {0}-byte payload in conversation ID {1}.",
payload.Count, headers.conversation_id);
return(ClassifyState.ExpectEndOfFrame);
}
public void TransitionExpectEpoxyHeaders_Valid()
{
EpoxyHeaders headers = null;
ProtocolErrorCode?errorCode = null;
var after = EpoxyProtocol.TransitionExpectEpoxyHeaders(
EpoxyProtocol.ClassifyState.ExpectEpoxyHeaders, goodRequestFrame, ref headers, ref errorCode);
Assert.AreEqual(EpoxyProtocol.ClassifyState.ExpectOptionalLayerData, after);
Assert.NotNull(headers);
Assert.AreEqual(GoodRequestId, headers.conversation_id);
Assert.AreEqual(0, headers.error_code);
Assert.AreEqual(GoodMethod, headers.method_name);
Assert.AreEqual(PayloadType.Request, headers.payload_type);
Assert.Null(errorCode);
after = EpoxyProtocol.TransitionExpectEpoxyHeaders(
EpoxyProtocol.ClassifyState.ExpectEpoxyHeaders, goodRequestLayerDataFrame,
ref headers, ref errorCode);
Assert.AreEqual(EpoxyProtocol.ClassifyState.ExpectOptionalLayerData, after);
Assert.NotNull(headers);
Assert.AreEqual(GoodRequestId, headers.conversation_id);
Assert.AreEqual(0, headers.error_code);
Assert.AreEqual(GoodMethod, headers.method_name);
Assert.AreEqual(PayloadType.Request, headers.payload_type);
Assert.Null(errorCode);
}
public void TransitionExpectPayload_MalformedFrame()
{
var payload = new ArraySegment <byte>();
ProtocolErrorCode?errorCode = null;
var after = EpoxyProtocol.TransitionExpectPayload(
EpoxyProtocol.ClassifyState.ExpectPayload, emptyFrame, goodRequestHeaders, emptyLayerData,
ref payload, ref errorCode, LoggerTests.BlackHole);
Assert.AreEqual(EpoxyProtocol.ClassifyState.MalformedFrame, after);
Assert.Null(payload.Array);
Assert.AreEqual(ProtocolErrorCode.MALFORMED_DATA, errorCode);
after = EpoxyProtocol.TransitionExpectPayload(
EpoxyProtocol.ClassifyState.ExpectPayload, shortRequestFrame, goodRequestHeaders, emptyLayerData,
ref payload, ref errorCode, LoggerTests.BlackHole);
Assert.AreEqual(EpoxyProtocol.ClassifyState.MalformedFrame, after);
Assert.Null(payload.Array);
Assert.AreEqual(ProtocolErrorCode.MALFORMED_DATA, errorCode);
after = EpoxyProtocol.TransitionExpectPayload(
EpoxyProtocol.ClassifyState.ExpectPayload, goodRequestLayerDataFrame, goodRequestHeaders, emptyLayerData,
ref payload, ref errorCode, LoggerTests.BlackHole);
Assert.AreEqual(EpoxyProtocol.ClassifyState.MalformedFrame, after);
Assert.Null(payload.Array);
Assert.AreEqual(ProtocolErrorCode.MALFORMED_DATA, errorCode);
after = EpoxyProtocol.TransitionExpectPayload(
EpoxyProtocol.ClassifyState.ExpectPayload, goodRequestFrame, goodRequestHeaders, nonEmptyLayerData,
ref payload, ref errorCode, LoggerTests.BlackHole);
Assert.AreEqual(EpoxyProtocol.ClassifyState.MalformedFrame, after);
Assert.Null(payload.Array);
Assert.AreEqual(ProtocolErrorCode.MALFORMED_DATA, errorCode);
}
internal static ClassifyState TransitionExpectEpoxyHeaders(
ClassifyState state, Frame frame, ref EpoxyHeaders headers, ref ProtocolErrorCode?errorCode, Logger logger)
{
Debug.Assert(state == ClassifyState.ExpectEpoxyHeaders);
Debug.Assert(frame != null);
if (frame.Count == 0 || frame.Framelets[0].Type != FrameletType.EpoxyHeaders)
{
return(ClassifyState.InternalStateError);
}
var framelet = frame.Framelets[0];
var inputBuffer = new InputBuffer(framelet.Contents);
var fastBinaryReader = new FastBinaryReader <InputBuffer>(inputBuffer, version: 1);
switch (headersDeserializer.TryDeserialize(fastBinaryReader, out headers))
{
case Deserialize.Result.Success:
break;
default:
logger.Site().Error("Didn't get a valid {0}.", nameof(EpoxyHeaders));
errorCode = ProtocolErrorCode.MALFORMED_DATA;
return(ClassifyState.MalformedFrame);
}
logger.Site().Debug("Deserialized {0} with conversation ID {1} and message type {2}.",
nameof(EpoxyHeaders), headers.conversation_id, headers.message_type);
return(ClassifyState.ExpectOptionalLayerData);
}
public void TransitionExpectEndOfFrame_MalformedFrame()
{
ProtocolErrorCode?errorCode = null;
var after = EpoxyProtocol.TransitionExpectEndOfFrame(
EpoxyProtocol.ClassifyState.ExpectEndOfFrame, doublePayloadRequestFrame, emptyLayerData, ref errorCode, LoggerTests.BlackHole);
Assert.AreEqual(EpoxyProtocol.ClassifyState.MalformedFrame, after);
Assert.AreEqual(ProtocolErrorCode.MALFORMED_DATA, errorCode);
}
public void TransitionFrameComplete_MalformedFrame()
{
ProtocolErrorCode?errorCode = null;
var after = EpoxyProtocol.TransitionFrameComplete(
EpoxyProtocol.ClassifyState.FrameComplete, unknownTypeHeaders, ref errorCode, LoggerTests.BlackHole);
Assert.AreEqual(EpoxyProtocol.ClassifyState.MalformedFrame, after);
Assert.AreEqual(ProtocolErrorCode.NOT_SUPPORTED, errorCode);
}
public void TransitionExpectConfig_Valid()
{
ProtocolErrorCode?errorCode = null;
var disposition = EpoxyProtocol.FrameDisposition.Indeterminate;
var after = EpoxyProtocol.TransitionExpectConfig(
EpoxyProtocol.ClassifyState.ExpectConfig, configFrame, ref errorCode, ref disposition, LoggerTests.BlackHole);
Assert.AreEqual(EpoxyProtocol.ClassifyState.ClassifiedValidFrame, after);
Assert.AreEqual(EpoxyProtocol.FrameDisposition.ProcessConfig, disposition);
Assert.IsNull(errorCode);
}
public void TransitionExpectConfig_MalformedConfigData()
{
ProtocolErrorCode?errorCode = null;
var disposition = EpoxyProtocol.FrameDisposition.Indeterminate;
var after = EpoxyProtocol.TransitionExpectConfig(
EpoxyProtocol.ClassifyState.ExpectConfig, configFrameBadConfigData, ref errorCode, ref disposition, LoggerTests.BlackHole);
Assert.AreEqual(EpoxyProtocol.ClassifyState.MalformedFrame, after);
Assert.AreEqual(ProtocolErrorCode.MALFORMED_DATA, errorCode);
Assert.AreEqual(EpoxyProtocol.FrameDisposition.Indeterminate, disposition);
}
public void TransitionExpectOptionalLayerData_InvalidPreconditions()
{
var layerData = new ArraySegment <byte>();
ProtocolErrorCode?errorCode = null;
var after = EpoxyProtocol.TransitionExpectOptionalLayerData(
EpoxyProtocol.ClassifyState.ExpectOptionalLayerData, goodRequestFrame, null,
ref layerData, ref errorCode, LoggerTests.BlackHole);
Assert.AreEqual(EpoxyProtocol.ClassifyState.InternalStateError, after);
Assert.Null(layerData.Array);
Assert.Null(errorCode);
}
public void TransitionExpectPayload_InvalidPreconditions()
{
var payload = new ArraySegment <byte>();
ProtocolErrorCode?errorCode = null;
var after = EpoxyProtocol.TransitionExpectPayload(
EpoxyProtocol.ClassifyState.ExpectPayload, goodRequestFrame, null, emptyLayerData,
ref payload, ref errorCode);
Assert.AreEqual(EpoxyProtocol.ClassifyState.InternalStateError, after);
Assert.Null(payload.Array);
Assert.Null(errorCode);
}
public void TransitionExpectPayloadOrError_InvalidPreconditions()
{
var message = default(EpoxyProtocol.MessageData);
ProtocolErrorCode?errorCode = null;
var after = EpoxyProtocol.TransitionExpectMessageData(
EpoxyProtocol.ClassifyState.ExpectMessageData, goodRequestFrame, null, emptyLayerData,
ref message, ref errorCode, LoggerTests.BlackHole);
Assert.AreEqual(EpoxyProtocol.ClassifyState.InternalStateError, after);
Assert.Null(message.Data.Array);
Assert.Null(errorCode);
}
public void TransitionExpectOptionalLayerData_MalformedFrame()
{
var layerData = new ArraySegment <byte>();
ProtocolErrorCode?errorCode = null;
var after = EpoxyProtocol.TransitionExpectOptionalLayerData(
EpoxyProtocol.ClassifyState.ExpectOptionalLayerData, shortRequestFrame, goodRequestHeaders,
ref layerData, ref errorCode, LoggerTests.BlackHole);
Assert.AreEqual(EpoxyProtocol.ClassifyState.MalformedFrame, after);
Assert.Null(layerData.Array);
Assert.AreEqual(ProtocolErrorCode.MALFORMED_DATA, errorCode);
}
public void TransitionExpectFirstFramelet_Valid()
{
ProtocolErrorCode?errorCode = null;
var after = EpoxyProtocol.TransitionExpectFirstFramelet(
EpoxyProtocol.ClassifyState.ExpectFirstFramelet, goodRequestFrame, ref errorCode, LoggerTests.BlackHole);
Assert.AreEqual(EpoxyProtocol.ClassifyState.ExpectEpoxyHeaders, after);
Assert.Null(errorCode);
after = EpoxyProtocol.TransitionExpectFirstFramelet(
EpoxyProtocol.ClassifyState.ExpectFirstFramelet, protocolErrorFrame, ref errorCode, LoggerTests.BlackHole);
Assert.AreEqual(EpoxyProtocol.ClassifyState.ExpectProtocolError, after);
Assert.Null(errorCode);
}
public void TransitionFrameComplete_Valid()
{
ProtocolErrorCode?errorCode = null;
var after = EpoxyProtocol.TransitionFrameComplete(
EpoxyProtocol.ClassifyState.FrameComplete, goodRequestHeaders, ref errorCode, LoggerTests.BlackHole);
Assert.AreEqual(EpoxyProtocol.ClassifyState.ValidFrame, after);
Assert.Null(errorCode);
after = EpoxyProtocol.TransitionFrameComplete(
EpoxyProtocol.ClassifyState.FrameComplete, goodResponseHeaders, ref errorCode, LoggerTests.BlackHole);
Assert.AreEqual(EpoxyProtocol.ClassifyState.ValidFrame, after);
Assert.Null(errorCode);
}
public void TransitionExpectConfig_InvalidPreconditions()
{
ProtocolErrorCode?errorCode = null;
var disposition = EpoxyProtocol.FrameDisposition.Indeterminate;
var after = EpoxyProtocol.TransitionExpectConfig(
EpoxyProtocol.ClassifyState.ExpectConfig, emptyFrame, ref errorCode, ref disposition, LoggerTests.BlackHole);
Assert.AreEqual(EpoxyProtocol.ClassifyState.InternalStateError, after);
// not a config frame
after = EpoxyProtocol.TransitionExpectConfig(
EpoxyProtocol.ClassifyState.ExpectConfig, protocolErrorFrame, ref errorCode, ref disposition, LoggerTests.BlackHole);
Assert.AreEqual(EpoxyProtocol.ClassifyState.InternalStateError, after);
}
public void TransitionExpectEndOfFrame_Valid()
{
ProtocolErrorCode?errorCode = null;
var after = EpoxyProtocol.TransitionExpectEndOfFrame(
EpoxyProtocol.ClassifyState.ExpectEndOfFrame, goodRequestFrame, emptyLayerData, ref errorCode, LoggerTests.BlackHole);
Assert.AreEqual(EpoxyProtocol.ClassifyState.FrameComplete, after);
Assert.Null(errorCode);
after = EpoxyProtocol.TransitionExpectEndOfFrame(
EpoxyProtocol.ClassifyState.ExpectEndOfFrame, goodRequestLayerDataFrame, goodLayerData, ref errorCode, LoggerTests.BlackHole);
Assert.AreEqual(EpoxyProtocol.ClassifyState.FrameComplete, after);
Assert.Null(errorCode);
}
public void TransitionExpectFirstFramelet_MalformedFrame()
{
ProtocolErrorCode?errorCode = null;
var after = EpoxyProtocol.TransitionExpectFirstFramelet(
EpoxyProtocol.ClassifyState.ExpectFirstFramelet, emptyFrame, ref errorCode, LoggerTests.BlackHole);
Assert.AreEqual(EpoxyProtocol.ClassifyState.MalformedFrame, after);
Assert.AreEqual(ProtocolErrorCode.MALFORMED_DATA, errorCode);
errorCode = null;
after = EpoxyProtocol.TransitionExpectFirstFramelet(
EpoxyProtocol.ClassifyState.ExpectFirstFramelet, backwardsRequestFrame, ref errorCode, LoggerTests.BlackHole);
Assert.AreEqual(EpoxyProtocol.ClassifyState.MalformedFrame, after);
Assert.AreEqual(ProtocolErrorCode.MALFORMED_DATA, errorCode);
}
public void TransitionExpectEpoxyHeaders_InvalidPreconditions()
{
EpoxyHeaders headers = null;
ProtocolErrorCode?errorCode = null;
var after = EpoxyProtocol.TransitionExpectEpoxyHeaders(
EpoxyProtocol.ClassifyState.ExpectEpoxyHeaders, emptyFrame, ref headers, ref errorCode, LoggerTests.BlackHole);
Assert.AreEqual(EpoxyProtocol.ClassifyState.InternalStateError, after);
Assert.Null(headers);
Assert.Null(errorCode);
after = EpoxyProtocol.TransitionExpectEpoxyHeaders(
EpoxyProtocol.ClassifyState.ExpectEpoxyHeaders, backwardsRequestFrame, ref headers, ref errorCode, LoggerTests.BlackHole);
Assert.AreEqual(EpoxyProtocol.ClassifyState.InternalStateError, after);
Assert.Null(headers);
Assert.Null(errorCode);
}
internal static ClassifyState TransitionExpectConfig(
ClassifyState state,
Frame frame,
ref ProtocolErrorCode?errorCode,
ref FrameDisposition disposition,
Logger logger)
{
Debug.Assert(state == ClassifyState.ExpectConfig);
Debug.Assert(frame != null);
if (frame.Count == 0 || frame.Framelets[0].Type != FrameletType.EpoxyConfig)
{
return(ClassifyState.InternalStateError);
}
if (frame.Count != 1)
{
logger.Site().Error("Config frame had trailing framelets.");
errorCode = ProtocolErrorCode.MALFORMED_DATA;
return(ClassifyState.MalformedFrame);
}
var framelet = frame.Framelets[0];
var inputBuffer = new InputBuffer(framelet.Contents);
var fastBinaryReader = new FastBinaryReader <InputBuffer>(inputBuffer, 1);
// We don't currently do anything with the config aside from try to deserialize it.
EpoxyConfig config;
switch (configDeserializer.TryDeserialize(fastBinaryReader, out config))
{
case Deserialize.Result.Success:
break;
default:
logger.Site().Error("Didn't get a valid {0}.", nameof(EpoxyConfig));
errorCode = ProtocolErrorCode.MALFORMED_DATA;
return(ClassifyState.MalformedFrame);
}
disposition = FrameDisposition.ProcessConfig;
return(ClassifyState.ClassifiedValidFrame);
}
internal static ClassifyState TransitionExpectMessageData(
ClassifyState state,
Frame frame,
EpoxyHeaders headers,
ArraySegment <byte> layerData,
ref MessageData messageData,
ref ProtocolErrorCode?errorCode,
Logger logger)
{
Debug.Assert(state == ClassifyState.ExpectMessageData);
Debug.Assert(frame != null);
if (headers == null)
{
return(ClassifyState.InternalStateError);
}
int messageDataIndex = (layerData.Array == null ? 1 : 2);
if (messageDataIndex >= frame.Count)
{
logger.Site().Error("Frame had headers but no message data.");
errorCode = ProtocolErrorCode.MALFORMED_DATA;
return(ClassifyState.MalformedFrame);
}
var framelet = frame.Framelets[messageDataIndex];
if (framelet.Type != FrameletType.PayloadData && framelet.Type != FrameletType.ErrorData)
{
logger.Site().Error("Frame had headers but no message data. Unexpected framelet type {0}", (int)framelet.Type);
errorCode = ProtocolErrorCode.MALFORMED_DATA;
return(ClassifyState.MalformedFrame);
}
messageData = new MessageData(framelet.Type == FrameletType.ErrorData, framelet.Contents);
logger.Site().Debug(
"Extracted {0}-byte message in conversation ID {1}.",
messageData.Data.Count,
headers.conversation_id);
return(ClassifyState.ExpectEndOfFrame);
}
public void TransitionOptionalExpectLayerData_Valid()
{
var layerData = new ArraySegment <byte>();
ProtocolErrorCode?errorCode = null;
var after = EpoxyProtocol.TransitionExpectOptionalLayerData(
EpoxyProtocol.ClassifyState.ExpectOptionalLayerData, goodRequestFrame, goodRequestHeaders,
ref layerData, ref errorCode);
Assert.AreEqual(EpoxyProtocol.ClassifyState.ExpectPayload, after);
Assert.Null(layerData.Array);
Assert.Null(errorCode);
after = EpoxyProtocol.TransitionExpectOptionalLayerData(
EpoxyProtocol.ClassifyState.ExpectOptionalLayerData, goodRequestLayerDataFrame, goodRequestHeaders,
ref layerData, ref errorCode);
Assert.AreEqual(EpoxyProtocol.ClassifyState.ExpectPayload, after);
Assert.NotNull(layerData.Array);
Assert.Null(errorCode);
}
public void TransitionExpectPayload_Valid()
{
var payload = new ArraySegment <byte>();
ProtocolErrorCode?errorCode = null;
var after = EpoxyProtocol.TransitionExpectPayload(
EpoxyProtocol.ClassifyState.ExpectPayload, goodRequestFrame, goodRequestHeaders, emptyLayerData,
ref payload, ref errorCode, LoggerTests.BlackHole);
Assert.AreEqual(EpoxyProtocol.ClassifyState.ExpectEndOfFrame, after);
Assert.NotNull(payload.Array);
Assert.Null(errorCode);
after = EpoxyProtocol.TransitionExpectPayload(
EpoxyProtocol.ClassifyState.ExpectPayload, goodRequestLayerDataFrame, goodRequestHeaders, nonEmptyLayerData,
ref payload, ref errorCode, LoggerTests.BlackHole);
Assert.AreEqual(EpoxyProtocol.ClassifyState.ExpectEndOfFrame, after);
Assert.NotNull(payload.Array);
Assert.Null(errorCode);
}
public void TransitionExpectOptionalLayerData_Valid()
{
var layerData = new ArraySegment <byte>();
ProtocolErrorCode?errorCode = null;
var after = EpoxyProtocol.TransitionExpectOptionalLayerData(
EpoxyProtocol.ClassifyState.ExpectOptionalLayerData, goodRequestFrame, goodRequestHeaders,
ref layerData, ref errorCode, LoggerTests.BlackHole);
Assert.AreEqual(EpoxyProtocol.ClassifyState.ExpectMessageData, after);
Assert.Null(layerData.Array);
Assert.Null(errorCode);
after = EpoxyProtocol.TransitionExpectOptionalLayerData(
EpoxyProtocol.ClassifyState.ExpectOptionalLayerData, goodRequestLayerDataFrame, goodRequestHeaders,
ref layerData, ref errorCode, LoggerTests.BlackHole);
Assert.AreEqual(EpoxyProtocol.ClassifyState.ExpectMessageData, after);
CollectionAssert.AreEqual(goodLayerData, layerData);
Assert.Null(errorCode);
}
internal static ClassifyState TransitionFrameComplete(
ClassifyState state, EpoxyHeaders headers, ref ProtocolErrorCode?errorCode, Logger logger)
{
if (state != ClassifyState.FrameComplete || headers == null)
{
return(ClassifyState.InternalStateError);
}
switch (headers.payload_type)
{
case PayloadType.Request:
case PayloadType.Response:
case PayloadType.Event:
return(ClassifyState.ValidFrame);
default:
logger.Site().Warning("Received unrecognized payload type {0}.", headers.payload_type);
errorCode = ProtocolErrorCode.NOT_SUPPORTED;
return(ClassifyState.MalformedFrame);
}
}
internal static ClassifyState TransitionFrameComplete(
ClassifyState state, EpoxyHeaders headers, ref ProtocolErrorCode?errorCode, Logger logger)
{
if (state != ClassifyState.FrameComplete || headers == null)
{
return(ClassifyState.InternalStateError);
}
switch (headers.message_type)
{
case EpoxyMessageType.REQUEST:
case EpoxyMessageType.RESPONSE:
case EpoxyMessageType.EVENT:
return(ClassifyState.ValidFrame);
default:
logger.Site().Warning("Received unrecognized message type {0}.", headers.message_type);
errorCode = ProtocolErrorCode.NOT_SUPPORTED;
return(ClassifyState.MalformedFrame);
}
}
internal static ClassifyState TransitionExpectOptionalLayerData(
ClassifyState state, Frame frame, EpoxyHeaders headers, ref ArraySegment <byte> layerData,
ref ProtocolErrorCode?errorCode)
{
Debug.Assert(state == ClassifyState.ExpectOptionalLayerData);
Debug.Assert(frame != null);
if (headers == null)
{
return(ClassifyState.InternalStateError);
}
if (frame.Count < 2)
{
Log.Error("{0}.{1}: Frame did not continue with LayerData or PayloadData.",
nameof(EpoxyProtocol), nameof(TransitionExpectEpoxyHeaders));
errorCode = ProtocolErrorCode.MALFORMED_DATA;
return(ClassifyState.MalformedFrame);
}
if (frame.Framelets[1].Type == FrameletType.PayloadData)
{
return(ClassifyState.ExpectPayload);
}
var framelet = frame.Framelets[1];
if (framelet.Type != FrameletType.LayerData)
{
Log.Error("{0}.{1}: Frame did not continue with LayerData or PayloadData.",
nameof(EpoxyProtocol), nameof(TransitionExpectOptionalLayerData));
errorCode = ProtocolErrorCode.MALFORMED_DATA;
return(ClassifyState.MalformedFrame);
}
layerData = framelet.Contents;
Log.Debug("{0}.{1}: Extracted {2}-byte layer data in conversation ID {3}.",
nameof(EpoxyProtocol), nameof(TransitionExpectOptionalLayerData), layerData.Count, headers.conversation_id);
return(ClassifyState.ExpectPayload);
}