private void DispatchResponse(EpoxyHeaders headers, ArraySegment <byte> payload, ArraySegment <byte> layerData)
{
IMessage response;
if (headers.error_code != (int)ErrorCode.OK)
{
response = Message.FromError(Unmarshal <Error> .From(payload));
}
else
{
response = Message.FromPayload(Unmarshal.From(payload));
}
var receiveContext = new EpoxyReceiveContext(this);
IBonded bondedLayerData = (layerData.Array == null) ? null : Unmarshal.From(layerData);
Error layerError = LayerStackUtils.ProcessOnReceive(parentTransport.LayerStack, MessageType.Response, receiveContext, bondedLayerData);
if (layerError != null)
{
Log.Error("{0}.{1}: Receiving response {2}/{3} failed due to layer error (Code: {4}, Message: {5}).",
this, nameof(DispatchResponse), headers.conversation_id, headers.method_name,
layerError.error_code, layerError.message);
response = Message.FromError(layerError);
}
if (!responseMap.Complete(headers.conversation_id, response))
{
Log.Error("{0}.{1}: Response for unmatched request. Conversation ID: {2}",
this, nameof(DispatchResponse), headers.conversation_id);
}
}
private void FlushReceivingQueue()
{
if (this.mReceivingSemaphore.WaitOne(0) == true)
{
// handle required packets
while (this.mPacketizer.PacketCount > 0 && this.mPacketReceiveCallback != null)
{
try
{
// unmarshal the packet
PyDataType packet = Unmarshal.ReadFromByteArray(this.mPacketizer.PopItem());
#if DEBUG
this.mPacketLog.Trace(PrettyPrinter.FromDataType(packet));
#endif
// and invoke the callback for the packet handling if it is present
this.mPacketReceiveCallback.Invoke(packet);
}
catch (Exception e)
{
this.HandleException(e);
}
}
// finally free the receiving semaphore
this.mReceivingSemaphore.Release();
}
// semaphore not acquired, there's something already sending data, so we're sure the data will get there eventually
}
static void Main()
{
// Define root node for a tree of strings
var root = new Node <string> {
data = "root"
};
root.left = new Node <string> {
data = "root/left"
};
root.right = new Node <string> {
data = "root/right"
};
root.left.left = new Node <string> {
data = "root/left/left"
};
root.left.left.right = new Node <string> {
data = "root/left/left/right"
};
var output = new OutputBuffer();
var writer = new CompactBinaryWriter <OutputBuffer>(output);
Marshal.To(writer, root);
var tree = Unmarshal <Node <string> > .From(output.Data);
Debug.Assert(Comparer.Equal(root, tree));
}
public PySubStream(byte[] data)
: base(PyObjectType.SubStream)
{
RawData = data;
DataUnmarshal = new Unmarshal();
Data = DataUnmarshal.Process(data);
}
public override void Decode(Unmarshal context, MarshalOpcode op, BinaryReader source)
{
if (op == MarshalOpcode.RealZero)
Value = 0.0d;
else
Value = source.ReadDouble();
}
public override void Decode(Unmarshal context, MarshalOpcode op, BinaryReader source)
{
if (op == MarshalOpcode.ObjectEx2)
IsType2 = true;
Dictionary = new Dictionary<PyObject, PyObject>();
List = new List<PyObject>();
Header = context.ReadObject(source);
while (source.BaseStream.Position < source.BaseStream.Length)
{
var b = source.ReadByte();
if (b == PackedTerminator)
break;
source.BaseStream.Seek(-1, SeekOrigin.Current);
List.Add(context.ReadObject(source));
}
while (source.BaseStream.Position < source.BaseStream.Length)
{
var b = source.ReadByte();
if (b == PackedTerminator)
break;
source.BaseStream.Seek(-1, SeekOrigin.Current);
var key = context.ReadObject(source);
var value = context.ReadObject(source);
Dictionary.Add(key, value);
}
}
public override void Decode(Unmarshal context, MarshalOpcode op, BinaryReader source)
{
uint len = source.ReadSizeEx();
RawData = source.ReadBytes((int) len);
DataUnmarshal = new Unmarshal();
Data = DataUnmarshal.Process(RawData);
}
private void DispatchEvent(EpoxyHeaders headers, ArraySegment <byte> payload, ArraySegment <byte> layerData)
{
if (headers.error_code != (int)ErrorCode.OK)
{
Log.Error("{0}.{1}: Received event with a non-zero error code. Conversation ID: {2}",
this, nameof(DispatchEvent), headers.conversation_id);
return;
}
IMessage request = Message.FromPayload(Unmarshal.From(payload));
var receiveContext = new EpoxyReceiveContext(this);
IBonded bondedLayerData = (layerData.Array == null) ? null : Unmarshal.From(layerData);
Error layerError = LayerStackUtils.ProcessOnReceive(parentTransport.LayerStack, MessageType.Event, receiveContext, bondedLayerData);
if (layerError != null)
{
Log.Error("{0}.{1}: Receiving event {2}/{3} failed due to layer error (Code: {4}, Message: {5}).",
this, nameof(DispatchEvent), headers.conversation_id, headers.method_name,
layerError.error_code, layerError.message);
return;
}
Task.Run(async() =>
{
await serviceHost.DispatchEvent(headers.method_name, receiveContext, request, connectionMetrics);
});
}
static void Subscriber()
{
var ctx = new ZContext();
var subscriber = new ZSocket(ctx, ZSocketType.SUB);
subscriber.Connect("tcp://127.0.0.1:12345");
subscriber.SubscribeAll();
for (;;)
{
var received = subscriber.ReceiveFrame();
// INCORRECT
// var str = received.ReadString();
// var byteArr = Encoding.ASCII.GetBytes(str);
var byteArr = received.Read();
var arrSeg = new ArraySegment <byte>(byteArr); // There's an InputBuffer ctor that takes a byte[] directly
var input = new InputBuffer(arrSeg);
var dst = Unmarshal <Record> .From(input);
foreach (var kvp in dst.payload)
{
Console.WriteLine("{0} {1}", kvp.Key, kvp.Value);
}
}
}
private State?DispatchRequest(EpoxyHeaders headers, EpoxyProtocol.MessageData messageData, ArraySegment <byte> layerData)
{
Task.Run(async() =>
{
var totalTime = Stopwatch.StartNew();
var requestMetrics = Metrics.StartRequestMetrics(ConnectionMetrics);
var receiveContext = new EpoxyReceiveContext(this, ConnectionMetrics, requestMetrics);
ILayerStack layerStack = null;
IMessage result;
if (messageData.IsError)
{
logger.Site().Error("{0} Received request with an error message. Only payload messages are allowed. Conversation ID: {1}",
this, headers.conversation_id);
result = Message.FromError(new Error
{
error_code = (int)ErrorCode.INVALID_INVOCATION,
message = "Received request with an error message"
});
}
else
{
IMessage request = Message.FromPayload(Unmarshal.From(messageData.Data));
IBonded bondedLayerData = (layerData.Array == null) ? null : Unmarshal.From(layerData);
Error layerError = parentTransport.GetLayerStack(requestMetrics.request_id, out layerStack);
if (layerError == null)
{
layerError = LayerStackUtils.ProcessOnReceive(
layerStack, MessageType.REQUEST, receiveContext, bondedLayerData, logger);
}
if (layerError == null)
{
result = await serviceHost.DispatchRequest(headers.service_name, headers.method_name, receiveContext, request);
}
else
{
logger.Site().Error("{0} Receiving request {1}/{2}.{3} failed due to layer error (Code: {4}, Message: {5}).",
this, headers.conversation_id, headers.service_name, headers.method_name,
layerError.error_code, layerError.message);
// Set layer error as result of this Bond method call and do not dispatch to method.
// Since this error will be returned to client, cleanse out internal server error details, if any.
result = Message.FromError(Errors.CleanseInternalServerError(layerError));
}
}
await SendReplyAsync(headers.conversation_id, result, layerStack, requestMetrics);
Metrics.FinishRequestMetrics(requestMetrics, totalTime);
metrics.Emit(requestMetrics);
});
// no state change needed
return(null);
}
static void Main()
{
var obj = new Struct
{
n = 0x1000,
str = "test",
items = { 3.14, 0 }
};
// Protocols may have different versions with different features.
// When serializing/deserializing the same version needs to be used.
//
// Marshaling can be used to embed the protocol and version in the
// payload so the reading side can automatically determine which
// protocol and version to use.
{
// Here, we use Compact Binary v1.
var output = new OutputBuffer();
var writer = new CompactBinaryWriter <OutputBuffer>(output, version: 1);
Serialize.To(writer, obj);
var input = new InputBuffer(output.Data);
var reader = new CompactBinaryReader <InputBuffer>(input, version: 1);
var obj2 = Deserialize <Struct> .From(reader);
ThrowIfFalse(Comparer.Equal(obj, obj2));
}
{
// Here, we use Compact Binary v2.
var output = new OutputBuffer();
var writer = new CompactBinaryWriter <OutputBuffer>(output, version: 2);
Serialize.To(writer, obj);
var input = new InputBuffer(output.Data);
var reader = new CompactBinaryReader <InputBuffer>(input, version: 2);
var obj2 = Deserialize <Struct> .From(reader);
ThrowIfFalse(Comparer.Equal(obj, obj2));
}
{
// Here, we Marshal to Compact Binary v2.
var output = new OutputBuffer();
var writer = new CompactBinaryWriter <OutputBuffer>(output, version: 2);
Marshal.To(writer, obj);
var input = new InputBuffer(output.Data);
// The protocol and version are determined from the payload
// itself.
var obj2 = Unmarshal <Struct> .From(input);
ThrowIfFalse(Comparer.Equal(obj, obj2));
}
}
public override void Decode(Unmarshal context, MarshalOpcode op, BinaryReader source)
{
var nameObject = context.ReadObject(source);
if (nameObject.Type != PyObjectType.String)
throw new DataException("Expected PyString");
Name = (nameObject as PyString).Value;
Arguments = context.ReadObject(source);
}
private void button1_Click(object sender, EventArgs e)
{
if (txtInput.Text.Length == 0)
{
txtOutput.Text = "";
return;
}
string hex = txtInput.Text.Replace(" ", "").Replace(System.Environment.NewLine, "");
try
{
//txtOutput.Text = hex;
byte[] raw = new Byte[hex.Length / 2];
for (int i = 0; i < raw.Length; i++)
{
raw[i] = Convert.ToByte(hex.Substring(i * 2, 2), 16);
}
Console.WriteLine(raw.Length + ", " + hex.Length);
Unmarshal un = new Unmarshal();
//un.DebugMode = true;
//PyObject obj = un.Process(BinaryReader.);
PyRep obj = un.Process(raw);
PrettyPrinter pp = new PrettyPrinter();
txtOutput.Text = pp.Print(obj);
}
catch
{
hex = txtInput.Text.Substring(8, txtInput.Text.Length - 8).Replace(" ", "").Replace(System.Environment.NewLine, "");
byte[] raw = new Byte[hex.Length / 2];
for (int i = 0; i < raw.Length; i++)
{
raw[i] = Convert.ToByte(hex.Substring(i * 2, 2), 16);
}
Console.WriteLine(raw.Length + ", " + hex.Length);
Unmarshal un = new Unmarshal();
un.DebugMode = true;
// un.DebugMode = true;
//PyObject obj = un.Process(BinaryReader.);
PyRep obj = un.Process(raw);
PrettyPrinter pp = new PrettyPrinter();
txtOutput.Text = pp.Print(obj);
}
/*
* //txtOutput.Text = hex;
* byte[] raw = new Byte[hex.Length / 2];
* for (int i = 0; i < raw.Length; i++) {
* raw[i] = Convert.ToByte(hex.Substring(i * 2, 2), 16);
* }
* Console.WriteLine(raw.Length+", "+hex.Length);
* Unmarshal un = new Unmarshal();
* // un.DebugMode = true;
* //PyObject obj = un.Process(BinaryReader.);
* PyObject obj = un.Process(raw);
* txtOutput.Text = PrettyPrinter.Print(obj);
*/
}
public void DecimalUnmarshal_Value()
{
PyDataType value = Unmarshal.ReadFromByteArray(sDecimal_ValueBuffer, false);
Assert.IsInstanceOf <PyDecimal>(value);
PyDecimal @decimal = value as PyDecimal;
Assert.AreEqual(sDecimal_Value, @decimal.Value);
}
public override void Decode(Unmarshal context, MarshalOpcode op, BinaryReader source)
{
context.NeedObjectEx = true;
Header = context.ReadObject(source);
context.NeedObjectEx = false;
RawData = LoadZeroCompressed(source);
if (!ParseRowData(context, source))
throw new InvalidDataException("Could not fully unpack PackedRow, stream integrity is broken");
}
public void TupleUnmarshal_Empty()
{
PyDataType value = Unmarshal.ReadFromByteArray(sTupleMarshaling_Empty, false);
Assert.IsInstanceOf <PyTuple>(value);
PyTuple tuple = value as PyTuple;
Assert.AreEqual(0, tuple.Count);
}
public void BooleanUnmarshal_False()
{
PyDataType result = Unmarshal.ReadFromByteArray(sBooleanMarshal_FalseValueBuffer, false);
Assert.IsInstanceOf <PyBool>(result);
PyBool pyBool = result as PyBool;
Assert.AreEqual(sBooleanMarshal_FalseValue, pyBool.Value);
}
public void ListUnmarshal_Empty()
{
PyDataType value = Unmarshal.ReadFromByteArray(sListMarshaling_Empty, false);
Assert.IsInstanceOf <PyList>(value);
PyList list = value as PyList;
Assert.AreEqual(0, list.Count);
}
public void TokenUmarshal_Normal()
{
PyDataType result = Unmarshal.ReadFromByteArray(sTokenMarshal_NormalBuffer, false);
Assert.IsInstanceOf <PyToken>(result);
PyToken pyToken = result as PyToken;
Assert.AreEqual(sTokenMarshal_Normal.Length, pyToken.Length);
Assert.AreEqual(sTokenMarshal_Normal, pyToken.Token);
}
public override void Decode(Unmarshal context, MarshalOpcode op, BinaryReader source)
{
var entries = source.ReadSizeEx();
Dictionary = new Dictionary<PyObject, PyObject>((int)entries);
for (uint i = 0; i < entries; i++)
{
var value = context.ReadObject(source);
var key = context.ReadObject(source);
Dictionary.Add(key, value);
}
}
public void IntegerUnmarshal_Long2()
{
PyDataType result = Unmarshal.ReadFromByteArray(sIntegerMarshal_LongValue2Buffer, false);
Assert.IsInstanceOf <PyInteger>(result);
PyInteger pyInteger = result as PyInteger;
Assert.AreEqual(sIntegerMarshal_LongValue2, pyInteger.Value);
Assert.AreEqual(true, sIntegerMarshal_LongValue2 == pyInteger);
Assert.AreEqual(PyInteger.IntegerTypeEnum.Long, pyInteger.IntegerType);
}
IBonded CreateBondedTestData(string value)
{
var realLayerData = new Dummy {
string_value = value
};
var outputBuffer = new OutputBuffer(20);
var compactWriter = new CompactBinaryWriter <OutputBuffer>(outputBuffer);
Marshal.To <CompactBinaryWriter <OutputBuffer>, Dummy>(compactWriter, realLayerData);
return(Unmarshal.From(outputBuffer.Data));
}
public void TupleUnmarshal_One()
{
PyDataType value = Unmarshal.ReadFromByteArray(sTupleMarshaling_One, false);
Assert.IsInstanceOf <PyTuple>(value);
PyTuple tuple = value as PyTuple;
Assert.AreEqual(1, tuple.Count);
Assert.IsInstanceOf <PyInteger>(tuple[0]);
Assert.AreEqual(sTupleMarshaling_FirstValue, (tuple[0] as PyInteger).Value);
}
public void ListUnmarshal_One()
{
PyDataType value = Unmarshal.ReadFromByteArray(sListMarshaling_One, false);
Assert.IsInstanceOf <PyList>(value);
PyList list = value as PyList;
Assert.AreEqual(1, list.Count);
Assert.IsInstanceOf <PyInteger>(list[0]);
Assert.AreEqual(sListMarshaling_FirstValue, (list[0] as PyInteger).Value);
}
private State?DispatchRequest(EpoxyHeaders headers, ArraySegment <byte> payload, ArraySegment <byte> layerData)
{
if (headers.error_code != (int)ErrorCode.OK)
{
logger.Site().Error("{0} Received request with a non-zero error code. Conversation ID: {1}",
this, headers.conversation_id);
protocolError = ProtocolErrorCode.PROTOCOL_VIOLATED;
return(State.SendProtocolError);
}
Task.Run(async() =>
{
var totalTime = Stopwatch.StartNew();
var requestMetrics = Metrics.StartRequestMetrics(ConnectionMetrics);
var receiveContext = new EpoxyReceiveContext(this, ConnectionMetrics, requestMetrics);
IMessage request = Message.FromPayload(Unmarshal.From(payload));
IBonded bondedLayerData = (layerData.Array == null) ? null : Unmarshal.From(layerData);
ILayerStack layerStack;
Error layerError = parentTransport.GetLayerStack(requestMetrics.request_id, out layerStack);
if (layerError == null)
{
layerError = LayerStackUtils.ProcessOnReceive(
layerStack, MessageType.Request, receiveContext, bondedLayerData, logger);
}
IMessage result;
if (layerError == null)
{
result = await serviceHost.DispatchRequest(headers.method_name, receiveContext, request);
}
else
{
logger.Site().Error("{0} Receiving request {1}/{2} failed due to layer error (Code: {3}, Message: {4}).",
this, headers.conversation_id, headers.method_name,
layerError.error_code, layerError.message);
// Set layer error as result of this Bond method call and do not dispatch to method.
// Since this error will be returned to client, cleanse out internal server error details, if any.
result = Message.FromError(Errors.CleanseInternalServerError(layerError));
}
await SendReplyAsync(headers.conversation_id, result, layerStack, requestMetrics);
Metrics.FinishRequestMetrics(requestMetrics, totalTime);
metrics.Emit(requestMetrics);
});
// no state change needed
return(null);
}
public override void Decode(Unmarshal context, MarshalOpcode op, BinaryReader source)
{
switch (op)
{
case MarshalOpcode.BoolTrue:
Value = true;
break;
case MarshalOpcode.BoolFalse:
Value = false;
break;
}
}
public void StringUnmarshal_LongMultiByteString()
{
PyDataType result = Unmarshal.ReadFromByteArray(sStringMarshal_LongMultiByteStringBuffer, false);
Assert.IsInstanceOf <PyString>(result);
PyString pyString = result as PyString;
Assert.AreEqual(sStringMarshal_LongString.Length, pyString.Length);
Assert.AreEqual(sStringMarshal_LongString, pyString.Value);
Assert.AreEqual(true, pyString.IsUTF8);
Assert.AreEqual(false, pyString.IsStringTableEntry);
}
void DispatchEvent(EpoxyHeaders headers, EpoxyProtocol.MessageData messageData, ArraySegment <byte> layerData)
{
if (messageData.IsError)
{
logger.Site().Error(
"{0} Received event with an error message. Only payload messages are allowed. Conversation ID: {1}",
this,
headers.conversation_id);
return;
}
Task.Run(
async() =>
{
IMessage request = Message.FromPayload(Unmarshal.From(messageData.Data));
var totalTime = Stopwatch.StartNew();
var requestMetrics = Metrics.StartRequestMetrics(ConnectionMetrics);
var receiveContext = new RelayEpoxyReceiveContext(this, ConnectionMetrics, requestMetrics);
IBonded bondedLayerData = (layerData.Array == null) ? null : Unmarshal.From(layerData);
ILayerStack layerStack;
Error layerError = parentTransport.GetLayerStack(requestMetrics.request_id, out layerStack);
if (layerError == null)
{
layerError = LayerStackUtils.ProcessOnReceive(
layerStack,
MessageType.EVENT,
receiveContext,
bondedLayerData,
logger);
}
if (layerError != null)
{
logger.Site().Error(
"{0}: Receiving event {1}/{2}.{3} failed due to layer error (Code: {4}, Message: {5}).",
this,
headers.conversation_id,
headers.service_name,
headers.method_name,
layerError.error_code,
layerError.message);
return;
}
await serviceHost.DispatchEvent(headers.service_name, headers.method_name, receiveContext, request);
Metrics.FinishRequestMetrics(requestMetrics, totalTime);
metrics.Emit(requestMetrics);
});
}
public void StringUnmarshal_StringTableString()
{
PyDataType result = Unmarshal.ReadFromByteArray(sStringMarshal_StringTableBuffer, false);
Assert.IsInstanceOf <PyString>(result);
PyString pyString = result as PyString;
Assert.AreEqual(sStringMarshal_StringTable.Length, pyString.Length);
Assert.AreEqual(sStringMarshal_StringTable, pyString.Value);
Assert.AreEqual(StringTableUtils.EntryList.contraband, pyString.StringTableEntryIndex);
Assert.AreEqual(false, pyString.IsUTF8);
Assert.AreEqual(true, pyString.IsStringTableEntry);
}
public override void Decode(Unmarshal context, MarshalOpcode op, BinaryReader source)
{
if (op == MarshalOpcode.IntegerOne)
Value = 1;
else if (op == MarshalOpcode.IntegerZero)
Value = 0;
else if (op == MarshalOpcode.IntegerMinusOne)
Value = -1;
else if (op == MarshalOpcode.IntegerByte)
Value = source.ReadByte();
else if (op == MarshalOpcode.IntegerSignedShort)
Value = source.ReadInt16();
else if (op == MarshalOpcode.IntegerLong)
Value = source.ReadInt32();
}
public void TupleUnmarshal_Big()
{
PyDataType value = Unmarshal.ReadFromByteArray(sTupleMarshaling_Big, false);
Assert.IsInstanceOf <PyTuple>(value);
PyTuple tuple = value as PyTuple;
Assert.AreEqual(256, tuple.Count);
foreach (PyDataType entry in tuple)
{
Assert.AreEqual(null, entry);
}
}
public void ListUnmarshal_Big()
{
PyDataType value = Unmarshal.ReadFromByteArray(sListMarshaling_Big, false);
Assert.IsInstanceOf <PyList>(value);
PyList list = value as PyList;
Assert.AreEqual(256, list.Count);
foreach (PyDataType entry in list)
{
Assert.AreEqual(null, entry);
}
}
void DispatchResponse(EpoxyHeaders headers, EpoxyProtocol.MessageData messageData, ArraySegment <byte> layerData)
{
IMessage response = messageData.IsError
? Message.FromError(Unmarshal <Error> .From(messageData.Data))
: Message.FromPayload(Unmarshal.From(messageData.Data));
TaskCompletionSource <IMessage> tcs = responseMap.TakeTaskCompletionSource(headers.conversation_id);
if (tcs == null)
{
logger.Site().Error(
"{0} Response for unmatched request. Conversation ID: {1}",
this,
headers.conversation_id);
return;
}
Task.Run(
() =>
{
var totalTime = Stopwatch.StartNew();
var requestMetrics = Metrics.StartRequestMetrics(ConnectionMetrics);
var receiveContext = new RelayEpoxyReceiveContext(this, ConnectionMetrics, requestMetrics);
IBonded bondedLayerData = (layerData.Array == null) ? null : Unmarshal.From(layerData);
ILayerStack layerStack = tcs.Task.AsyncState as ILayerStack;
Error layerError = LayerStackUtils.ProcessOnReceive(layerStack, MessageType.RESPONSE, receiveContext, bondedLayerData, logger);
if (layerError != null)
{
logger.Site().Error(
"{0} Receiving response {1}/{2}.{3} failed due to layer error (Code: {4}, Message: {5}).",
this,
headers.conversation_id,
headers.service_name,
headers.method_name,
layerError.error_code,
layerError.message);
response = Message.FromError(layerError);
}
tcs.SetResult(response);
Metrics.FinishRequestMetrics(requestMetrics, totalTime);
metrics.Emit(requestMetrics);
});
}
public void TupleUnmarshal_Three()
{
PyDataType value = Unmarshal.ReadFromByteArray(sTupleMarshaling_Three, false);
Assert.IsInstanceOf <PyTuple>(value);
PyTuple tuple = value as PyTuple;
Assert.AreEqual(3, tuple.Count);
Assert.IsInstanceOf <PyInteger>(tuple[0]);
Assert.AreEqual(sTupleMarshaling_FirstValue, (tuple[0] as PyInteger).Value);
Assert.IsInstanceOf <PyString>(tuple[1]);
Assert.AreEqual(sTupleMarshaling_SecondValue, (tuple[1] as PyString).Value);
Assert.IsInstanceOf <PyDecimal>(tuple[2]);
Assert.AreEqual(sTupleMarshaling_ThirdValue, (tuple[2] as PyDecimal).Value);
}
static void Main()
{
var v1 = new Struct_v1();
// Struct_v1 has a required field foo which by default is set to
// 'nothing'. If we try to serialize object v1 w/o initializing
// the field to some value Bond will throw an exception.
try
{
Console.WriteLine("Serializing v1... ");
Marshal(v1);
}
catch (Exception ex)
{
Console.WriteLine(ex);
}
// Initialize field by assigning a value to it...
v1.foo = 10;
// ... or for complex fields create a new instance of the
// appropriate C# type.
v1.baz = new LinkedList <string>();
v1.baz.AddLast("test1");
v1.baz.AddLast("test2");
// We can also set a field to 'nothing' by assigning null to the
// field itself. Optional fields that are set to 'nothing' are
// omitted when object is serialized.
v1.baz = null;
ArraySegment <byte> buffer = Marshal(v1);
// Deserialize the payload into object of type Struct_v2
Struct_v2 v2 = Unmarshal <Struct_v2> .From(buffer);
// Struct_v2 has an optional field bar, which didn't exist in
// Struct_v1. It is initialized to 'nothing' by default. By
// checking if the field is 'nothing' (== null) after
// de-serialization we can detect if it was present in the
// payload or not.
Debug.Assert(v2.bar == null);
Debug.Assert(v2.baz == null);
}
private void DispatchResponse(EpoxyHeaders headers, ArraySegment <byte> payload, ArraySegment <byte> layerData)
{
IMessage response;
if (headers.error_code != (int)ErrorCode.OK)
{
response = Message.FromError(Unmarshal <Error> .From(payload));
}
else
{
response = Message.FromPayload(Unmarshal.From(payload));
}
TaskCompletionSource <IMessage> tcs = responseMap.TakeTaskCompletionSource(headers.conversation_id);
if (tcs == null)
{
logger.Site().Error("{0} Response for unmatched request. Conversation ID: {1}",
this, headers.conversation_id);
return;
}
Task.Run(() =>
{
var receiveContext = new EpoxyReceiveContext(this);
IBonded bondedLayerData = (layerData.Array == null) ? null : Unmarshal.From(layerData);
ILayerStack layerStack = tcs.Task.AsyncState as ILayerStack;
Error layerError = LayerStackUtils.ProcessOnReceive(layerStack, MessageType.Response, receiveContext, bondedLayerData, logger);
if (layerError != null)
{
logger.Site().Error("{0} Receiving response {1}/{2} failed due to layer error (Code: {3}, Message: {4}).",
this, headers.conversation_id, headers.method_name,
layerError.error_code, layerError.message);
response = Message.FromError(layerError);
}
tcs.SetResult(response);
});
}
private void listBox1_SelectedIndexChanged(object sender, EventArgs e)
{
if (listBox1.SelectedItem == null)
{
richTextBox2.Text = "";
return;
}
if (Cache.UpdateCache(listBox1.SelectedItem.ToString()) == false)
{
WindowLog.Error("Main::LoadCache", "Error loading cache");
return;
}
PyObject cache = Cache.GetCache(listBox1.SelectedItem.ToString());
PyCachedObject obj = new PyCachedObject();
if (obj.Decode(cache) == false)
{
WindowLog.Error("Main::LoadCache", "Cannot decode the cache data");
return;
}
if (Program.cacheDataDisplayMode == "Pretty")
{
try
{
richTextBox2.Text = PrettyPrinter.Print(Unmarshal.Process <PyObject>(obj.cache.Data));
}
catch (Exception)
{
WindowLog.Error("Main::LoadCache", "Cannot Unmarshal the cache data");
richTextBox2.Text = "Error";
}
}
else
{
richTextBox2.Text = ByteToString(obj.cache.Data);
}
WindowLog.Debug("Main::LoadCache", "Cache loaded");
}
static void Main()
{
var example = new Example
{
num = 42,
str = "test",
items = { 3.14, 0 }
};
var output = new OutputBuffer();
var writer = new CompactBinaryWriter <OutputBuffer>(output);
Marshal.To(writer, example);
var input = new InputBuffer(output.Data);
ExampleView view = Unmarshal <ExampleView> .From(input);
Debug.Assert(example.num == view.num);
Debug.Assert(example.str.Equals(view.str, StringComparison.Ordinal));
}
private State?DispatchRequest(EpoxyHeaders headers, ArraySegment <byte> payload, ArraySegment <byte> layerData)
{
if (headers.error_code != (int)ErrorCode.OK)
{
Log.Error("{0}.{1}: Received request with a non-zero error code. Conversation ID: {2}",
this, nameof(DispatchRequest), headers.conversation_id);
protocolError = ProtocolErrorCode.PROTOCOL_VIOLATED;
return(State.SendProtocolError);
}
IMessage request = Message.FromPayload(Unmarshal.From(payload));
var receiveContext = new EpoxyReceiveContext(this);
IBonded bondedLayerData = (layerData.Array == null) ? null : Unmarshal.From(layerData);
Error layerError = LayerStackUtils.ProcessOnReceive(parentTransport.LayerStack, MessageType.Request, receiveContext, bondedLayerData);
Task.Run(async() =>
{
IMessage result;
if (layerError == null)
{
result = await serviceHost.DispatchRequest(headers.method_name, receiveContext, request,
connectionMetrics);
}
else
{
Log.Error("{0}.{1}: Receiving request {2}/{3} failed due to layer error (Code: {4}, Message: {5}).",
this, nameof(DispatchRequest), headers.conversation_id, headers.method_name,
layerError.error_code, layerError.message);
result = Message.FromError(layerError);
}
await SendReplyAsync(headers.conversation_id, result);
});
// no state change needed
return(null);
}
public override void Decode(Unmarshal context, MarshalOpcode op, BinaryReader source)
{
if (op == MarshalOpcode.StringEmpty)
Update(new byte[0]);
else if (op == MarshalOpcode.StringChar)
Update(new[]{source.ReadByte()});
else if (op == MarshalOpcode.WStringUTF8)
UpdateUTF8(source.ReadBytes((int)source.ReadSizeEx()));
else if (op == MarshalOpcode.WStringUCS2Char)
Update(new[]{source.ReadByte(), source.ReadByte()}, true);
else if (op == MarshalOpcode.WStringEmpty)
Update(new byte[0]);
else if (op == MarshalOpcode.WStringUCS2)
Update(source.ReadBytes((int)source.ReadSizeEx()), true);
else if (op == MarshalOpcode.StringShort)
Update(source.ReadBytes(source.ReadByte()));
else if (op == MarshalOpcode.StringLong)
Update(source.ReadBytes((int)source.ReadSizeEx()));
else if (op == MarshalOpcode.StringTable)
{
byte index = source.ReadByte();
Update(StringTable.Entries[index-1]);
}
}
public override void Decode(Unmarshal context, MarshalOpcode op, BinaryReader source)
{
var size = source.ReadSizeEx();
Data = source.ReadBytes((int)size);
}
public override void Decode(Unmarshal context, MarshalOpcode op, BinaryReader source)
{
}
private bool ParseRowData(Unmarshal context, BinaryReader source)
{
var objex = Header as PyObjectEx;
if (objex == null)
return false;
var header = objex.Header as PyTuple;
if (header == null || header.Items.Count < 2)
return false;
var columns = header.Items[1] as PyTuple;
if (columns == null)
return false;
/*
columns = columns.Items[0] as PyTuple;
if (columns == null)
return false;
*/
Columns = new List<Column>(columns.Items.Count);
foreach (var obj in columns)
{
var fieldData = obj as PyTuple;
if (fieldData == null || fieldData.Items.Count < 2)
continue;
var name = fieldData.Items[0] as PyString;
if (name == null)
continue;
Columns.Add(new Column(name.Value, (FieldType) fieldData.Items[1].IntValue));
}
var sizeList = Columns.OrderByDescending(c => FieldTypeHelper.GetTypeBits(c.Type));
var sizeSum = sizeList.Sum(c => FieldTypeHelper.GetTypeBits(c.Type));
// align
sizeSum = (sizeSum + 7) >> 3;
var rawStream = new MemoryStream();
// fill up
rawStream.Write(RawData, 0, RawData.Length);
for (int i = 0; i < (sizeSum - RawData.Length); i++)
rawStream.WriteByte(0);
rawStream.Seek(0, SeekOrigin.Begin);
var reader = new BinaryReader(rawStream);
int bitOffset = 0;
foreach (var column in sizeList)
{
switch (column.Type)
{
case FieldType.I8:
case FieldType.UI8:
case FieldType.CY:
case FieldType.FileTime:
column.Value = new PyLongLong(reader.ReadInt64());
break;
case FieldType.I4:
case FieldType.UI4:
column.Value = new PyInt(reader.ReadInt32());
break;
case FieldType.I2:
case FieldType.UI2:
column.Value = new PyInt(reader.ReadInt16());
break;
case FieldType.I1:
case FieldType.UI1:
column.Value = new PyInt(reader.ReadByte());
break;
case FieldType.R8:
column.Value = new PyFloat(reader.ReadDouble());
break;
case FieldType.R4:
column.Value = new PyFloat(reader.ReadSingle());
break;
case FieldType.Bytes:
case FieldType.Str:
case FieldType.WStr:
column.Value = context.ReadObject(source);
break;
case FieldType.Bool:
{
if (7 < bitOffset)
{
bitOffset = 0;
reader.ReadByte();
}
var b = reader.ReadByte();
reader.BaseStream.Seek(-1, SeekOrigin.Current);
column.Value = new PyInt((b >> bitOffset++) & 0x01);
break;
}
default:
throw new Exception("No support for " + column.Type);
}
}
return true;
}
public override void Decode(Unmarshal context, MarshalOpcode op, BinaryReader source)
{
throw new NotImplementedException();
}
public override void Decode(Unmarshal context, MarshalOpcode op, BinaryReader source)
{
var len = source.ReadSizeEx();
Raw = source.ReadBytes((int) len);
}
public override void Decode(Unmarshal context, MarshalOpcode op, BinaryReader source)
{
Checksum = source.ReadUInt32();
Data = context.ReadObject(source);
}
public override void Decode(Unmarshal context, MarshalOpcode op, BinaryReader source)
{
byte len = source.ReadByte();
RawToken = source.ReadBytes(len);
Token = Encoding.ASCII.GetString(RawToken);
}
public override void Decode(Unmarshal context, MarshalOpcode op, BinaryReader source)
{
Definition = context.ReadObject(source);
}
public override void Decode(Unmarshal context, MarshalOpcode op, BinaryReader source)
{
Value = source.ReadInt64();
}
