public void TestAnnotations() { var annotations = new Dictionary<string,byte[]>(); annotations["TEST"]=new byte[]{10,20,30,40,50}; var msg = new Message(Message.MSG_CONNECT, new byte[]{1,2,3,4,5}, this.serializer_id, 0, 0, annotations); byte[] data = msg.to_bytes(); int annotations_size = 4+2+20 + 4+2+5; Assert.AreEqual(Message.HEADER_SIZE + 5 + annotations_size, data.Length); Assert.AreEqual(annotations_size, msg.annotations_size); Assert.AreEqual(2, msg.annotations.Count); Assert.AreEqual(new byte[]{10,20,30,40,50}, msg.annotations["TEST"]); byte[] mac = pyrohmac(new byte[]{1,2,3,4,5}, annotations); Assert.AreEqual(mac, msg.annotations["HMAC"]); }
public void testAnnotationsIdLength4() { try { var anno = new Dictionary<string, byte[]>(); anno["TOOLONG"] = new byte[]{10,20,30}; var msg = new Message(Message.MSG_CONNECT, new byte[]{1,2,3,4,5}, this.serializer_id, 0, 0, anno); byte[]data = msg.to_bytes(); Assert.Fail("should fail, too long"); } catch(ArgumentException) { //ok } try { var anno = new Dictionary<string, byte[]>(); anno["QQ"] = new byte[]{10,20,30}; var msg = new Message(Message.MSG_CONNECT, new byte[]{1,2,3,4,5}, this.serializer_id, 0, 0, anno); byte[] data = msg.to_bytes(); Assert.Fail("should fail, too short"); } catch (ArgumentException) { //ok } }
public void TestAnnotations() { byte[] hmac=Encoding.UTF8.GetBytes("secret"); var annotations = new Dictionary<string,byte[]>(); annotations["TES1"]=new byte[]{10,20,30,40,50}; annotations["TES2"]=new byte[]{20,30,40,50,60}; annotations["TES3"]=new byte[]{30,40,50,60,70}; annotations["TES4"]=new byte[]{40,50,60,70,80}; var msg = new Message(Message.MSG_CONNECT, new byte[]{1,2,3,4,5}, this.serializer_id, 0, 0, annotations, hmac); byte[] data = msg.to_bytes(); int annotations_size = 4+2+20 + (4+2+5)*4; Assert.AreEqual(Message.HEADER_SIZE + 5 + annotations_size, data.Length); Assert.AreEqual(annotations_size, msg.annotations_size); Assert.AreEqual(5, msg.annotations.Count); Assert.AreEqual(new byte[]{10,20,30,40,50}, msg.annotations["TES1"]); Assert.AreEqual(new byte[]{20,30,40,50,60}, msg.annotations["TES2"]); Assert.AreEqual(new byte[]{30,40,50,60,70}, msg.annotations["TES3"]); Assert.AreEqual(new byte[]{40,50,60,70,80}, msg.annotations["TES4"]); byte[] mac = msg.hmac(hmac); Assert.AreEqual(mac, msg.annotations["HMAC"]); annotations = new Dictionary<string,byte[]>(); annotations["TES4"]=new byte[]{40,50,60,70,80}; annotations["TES3"]=new byte[]{30,40,50,60,70}; annotations["TES2"]=new byte[]{20,30,40,50,60}; annotations["TES1"]=new byte[]{10,20,30,40,50}; var msg2 = new Message(Message.MSG_CONNECT, new byte[]{1,2,3,4,5}, this.serializer_id, 0, 0, annotations, hmac); Assert.AreEqual(msg.hmac(hmac), msg2.hmac(hmac)); annotations = new Dictionary<string,byte[]>(); annotations["TES4"]=new byte[]{40,50,60,70,80}; var msg3 = new Message(Message.MSG_CONNECT, new byte[]{1,2,3,4,5}, this.serializer_id, 0, 0, annotations, hmac); Assert.AreNotEqual(msg.hmac(hmac), msg3.hmac(hmac)); }
/** * Internal call method to actually perform the Pyro method call and process the result. */ private object call(string method, ushort flags, params object[] parameters) { lock (this) { connect(); unchecked { sequenceNr++; // unchecked so this ushort wraps around 0-65535 instead of raising an OverflowException } } if (parameters == null) { parameters = new object[] {} } ; PyroSerializer ser = PyroSerializer.GetFor(Config.SERIALIZER); byte[] pickle = ser.serializeCall(objectid, method, parameters, new Dictionary <string, object>(0)); var msg = new Message(Message.MSG_INVOKE, pickle, ser.serializer_id, flags, sequenceNr, null); Message resultmsg; lock (this.sock) { IOUtil.send(sock_stream, msg.to_bytes()); if (Config.MSG_TRACE_DIR != null) { Message.TraceMessageSend(sequenceNr, msg.get_header_bytes(), msg.get_annotations_bytes(), msg.data); } pickle = null; if ((flags & Message.FLAGS_ONEWAY) != 0) { return(null); } resultmsg = Message.recv(sock_stream, new ushort[] { Message.MSG_RESULT }); } if (resultmsg.seq != sequenceNr) { throw new PyroException("result msg out of sync"); } if ((resultmsg.flags & Message.FLAGS_COMPRESSED) != 0) { // we need to skip the first 2 bytes in the buffer due to a tiny mismatch between zlib-written // data and the deflate data bytes that .net expects. // See http://www.chiramattel.com/george/blog/2007/09/09/deflatestream-block-length-does-not-match.html using (MemoryStream compressed = new MemoryStream(resultmsg.data, 2, resultmsg.data.Length - 2, false)) { using (DeflateStream decompresser = new DeflateStream(compressed, CompressionMode.Decompress)) { MemoryStream bos = new MemoryStream(resultmsg.data.Length); byte[] buffer = new byte[4096]; int numRead; while ((numRead = decompresser.Read(buffer, 0, buffer.Length)) != 0) { bos.Write(buffer, 0, numRead); } resultmsg.data = bos.ToArray(); } } } if ((resultmsg.flags & Message.FLAGS_EXCEPTION) != 0) { Exception rx = (Exception)ser.deserializeData(resultmsg.data); if (rx is PyroException) { throw (PyroException)rx; } else { PyroException px = new PyroException("remote exception occurred", rx); PropertyInfo remotetbProperty = rx.GetType().GetProperty("_pyroTraceback"); if (remotetbProperty != null) { string remotetb = (string)remotetbProperty.GetValue(rx, null); px._pyroTraceback = remotetb; } throw px; } } return(ser.deserializeData(resultmsg.data)); }
/// <summary> /// Perform the Pyro protocol connection handshake with the Pyro daemon. /// </summary> protected void _handshake() { var ser = PyroSerializer.GetFor(Config.SERIALIZER); var handshakedata = new Dictionary <string, Object>(); handshakedata["handshake"] = pyroHandshake; if (Config.METADATA) { handshakedata["object"] = objectid; } byte[] data = ser.serializeData(handshakedata); ushort flags = Config.METADATA? Message.FLAGS_META_ON_CONNECT : (ushort)0; var msg = new Message(Message.MSG_CONNECT, data, ser.serializer_id, flags, sequenceNr, annotations(), pyroHmacKey); IOUtil.send(sock_stream, msg.to_bytes()); if (Config.MSG_TRACE_DIR != null) { Message.TraceMessageSend(sequenceNr, msg.get_header_bytes(), msg.get_annotations_bytes(), msg.data); } // process handshake response msg = Message.recv(sock_stream, new [] { Message.MSG_CONNECTOK, Message.MSG_CONNECTFAIL }, pyroHmacKey); responseAnnotations(msg.annotations, msg.type); object handshake_response = "?"; if (msg.data != null) { if ((msg.flags & Message.FLAGS_COMPRESSED) != 0) { _decompressMessageData(msg); } try { ser = PyroSerializer.GetFor(msg.serializer_id); handshake_response = ser.deserializeData(msg.data); } catch (Exception) { msg.type = Message.MSG_CONNECTFAIL; handshake_response = "<not available because unsupported serialization format>"; } } if (msg.type == Message.MSG_CONNECTOK) { if ((msg.flags & Message.FLAGS_META_ON_CONNECT) != 0) { var response_dict = (IDictionary <object, object>)handshake_response; _processMetadata((IDictionary <object, object>)response_dict["meta"]); handshake_response = response_dict["handshake"]; try { validateHandshake(handshake_response); } catch (Exception) { close(); throw; } } } else if (msg.type == Message.MSG_CONNECTFAIL) { close(); throw new PyroException("connection rejected, reason: " + handshake_response); } else { close(); throw new PyroException(string.Format("connect: invalid msg type {0} received", msg.type)); } }
/// <summary> /// Internal call method to actually perform the Pyro method call and process the result. /// </summary> private object internal_call(string method, string actual_objectId, ushort flags, bool checkMethodName, params object[] parameters) { actual_objectId = actual_objectId ?? this.objectid; lock (this) { connect(); unchecked { sequenceNr++; // unchecked so this ushort wraps around 0-65535 instead of raising an OverflowException } } if (pyroAttrs.Contains(method)) { throw new PyroException("cannot call an attribute"); } if (pyroOneway.Contains(method)) { flags |= Message.FLAGS_ONEWAY; } if (checkMethodName && Config.METADATA && !pyroMethods.Contains(method)) { throw new PyroException(string.Format("remote object '{0}' has no exposed attribute or method '{1}'", actual_objectId, method)); } if (parameters == null) { parameters = new object[] {} } ; PyroSerializer ser = PyroSerializer.GetFor(Config.SERIALIZER); byte[] pickle = ser.serializeCall(actual_objectId, method, parameters, new Dictionary <string, object>(0)); var msg = new Message(Message.MSG_INVOKE, pickle, ser.serializer_id, flags, sequenceNr, this.annotations(), pyroHmacKey); Message resultmsg; lock (this.sock) { IOUtil.send(sock_stream, msg.to_bytes()); if (Config.MSG_TRACE_DIR != null) { Message.TraceMessageSend(sequenceNr, msg.get_header_bytes(), msg.get_annotations_bytes(), msg.data); } // ReSharper disable once RedundantAssignment pickle = null; if ((flags & Message.FLAGS_ONEWAY) != 0) { return(null); } resultmsg = Message.recv(sock_stream, new [] { Message.MSG_RESULT }, pyroHmacKey); } if (resultmsg.seq != sequenceNr) { throw new PyroException("result msg out of sync"); } responseAnnotations(resultmsg.annotations, resultmsg.type); if ((resultmsg.flags & Message.FLAGS_COMPRESSED) != 0) { _decompressMessageData(resultmsg); } if ((resultmsg.flags & Message.FLAGS_ITEMSTREAMRESULT) != 0) { byte[] streamId; if (!resultmsg.annotations.TryGetValue("STRM", out streamId)) { throw new PyroException("result of call is an iterator, but the server is not configured to allow streaming"); } return(new StreamResultIterator(Encoding.UTF8.GetString(streamId), this)); } if ((resultmsg.flags & Message.FLAGS_EXCEPTION) != 0) { Exception rx = (Exception)ser.deserializeData(resultmsg.data); if (rx is PyroException) { throw (PyroException)rx; } else { PyroException px; // if the source was a PythonException, copy its message and python exception type PythonException pyx = rx as PythonException; if (pyx == null) { px = new PyroException(null, rx); } else { px = new PyroException(rx.Message, rx); px.PythonExceptionType = pyx.PythonExceptionType; } PropertyInfo remotetbProperty = rx.GetType().GetProperty("_pyroTraceback"); if (remotetbProperty != null) { string remotetb = (string)remotetbProperty.GetValue(rx, null); px._pyroTraceback = remotetb; } throw px; } } return(ser.deserializeData(resultmsg.data)); }
public void testRecvNoAnnotations() { var msg = new Message(Message.MSG_CONNECT, new byte[]{1,2,3,4,5}, 42, 0, 0, null); var c = new ConnectionMock(); c.send(msg.to_bytes()); msg = Message.recv(c, null); Assert.AreEqual(0, c.RemainingLength); Assert.AreEqual(5, msg.data_size); Assert.AreEqual(new byte[]{1,2,3,4,5}, msg.data); Assert.AreEqual(0, msg.annotations_size); Assert.AreEqual(0, msg.annotations.Count); }
public void TestMessage() { new Message(99, new byte[0], this.serializer_id, 0, 0, null); // doesn't check msg type here Assert.Throws(typeof(PyroException), ()=>Message.from_header(Encoding.ASCII.GetBytes("FOOBAR"))); var msg = new Message(Message.MSG_CONNECT, Encoding.ASCII.GetBytes("hello"), this.serializer_id, 0, 0, null); Assert.AreEqual(Message.MSG_CONNECT, msg.type); Assert.AreEqual(5, msg.data_size); Assert.AreEqual(new byte[]{(byte)'h',(byte)'e',(byte)'l',(byte)'l',(byte)'o'}, msg.data); Assert.AreEqual(4+2+20, msg.annotations_size); byte[] mac = pyrohmac(Encoding.ASCII.GetBytes("hello"), msg.annotations); var expected = new Dictionary<string, byte[]>(); expected["HMAC"] = mac; CollectionAssert.AreEqual(expected, msg.annotations); byte[] hdr = msg.to_bytes().Take(Message.HEADER_SIZE).ToArray(); msg = Message.from_header(hdr); Assert.AreEqual(Message.MSG_CONNECT, msg.type); Assert.AreEqual(4+2+20, msg.annotations_size); Assert.AreEqual(5, msg.data_size); hdr = new Message(Message.MSG_RESULT, new byte[0], this.serializer_id, 0, 0, null).to_bytes().Take(Message.HEADER_SIZE).ToArray(); msg = Message.from_header(hdr); Assert.AreEqual(Message.MSG_RESULT, msg.type); Assert.AreEqual(4+2+20, msg.annotations_size); Assert.AreEqual(0, msg.data_size); hdr = new Message(Message.MSG_RESULT, Encoding.ASCII.GetBytes("hello"), 12345, 60006, 30003, null).to_bytes().Take(Message.HEADER_SIZE).ToArray(); msg = Message.from_header(hdr); Assert.AreEqual(Message.MSG_RESULT, msg.type); Assert.AreEqual(60006, msg.flags); Assert.AreEqual(5, msg.data_size); Assert.AreEqual(12345, msg.serializer_id); Assert.AreEqual(30003, msg.seq); byte[] data = new Message(255, new byte[0], this.serializer_id, 0, 255, null).to_bytes(); Assert.AreEqual(50, data.Length); data = new Message(1, new byte[0], this.serializer_id, 0, 255, null).to_bytes(); Assert.AreEqual(50, data.Length); data = new Message(1, new byte[0], this.serializer_id, 253, 254, null).to_bytes(); Assert.AreEqual(50, data.Length); // compression is a job of the code supplying the data, so the messagefactory should leave it untouched data = new byte[1000]; byte[] msg_bytes1 = new Message(Message.MSG_INVOKE, data, this.serializer_id, 0, 0, null).to_bytes(); byte[] msg_bytes2 = new Message(Message.MSG_INVOKE, data, this.serializer_id, Message.FLAGS_COMPRESSED, 0, null).to_bytes(); Assert.AreEqual(msg_bytes1.Length, msg_bytes2.Length); }
public void testMessageHeaderDatasize() { var msg = new Message(Message.MSG_RESULT, Encoding.ASCII.GetBytes("hello"), 12345, 60006, 30003, null); msg.data_size = 0x12345678; // hack it to a large value to see if it comes back ok byte[] hdr = msg.to_bytes().Take(Message.HEADER_SIZE).ToArray(); msg = Message.from_header(hdr); Assert.AreEqual(Message.MSG_RESULT, msg.type); Assert.AreEqual(60006, msg.flags); Assert.AreEqual(0x12345678, msg.data_size); Assert.AreEqual(12345, msg.serializer_id); Assert.AreEqual(30003, msg.seq); }
/// <summary> /// Perform the Pyro protocol connection handshake with the Pyro daemon. /// </summary> protected void _handshake() { var ser = PyroSerializer.GetSerpentSerializer(); var handshakedata = new Dictionary <string, object> { ["handshake"] = pyroHandshake }; handshakedata["object"] = objectid; var data = ser.serializeData(handshakedata); ushort flags = 0; if (correlation_id != null) { flags |= Message.FLAGS_CORR_ID; } var msg = new Message(Message.MSG_CONNECT, data, ser.serializer_id, flags, sequenceNr, annotations(), correlation_id); IOUtil.send(sock_stream, msg.to_bytes()); if (Config.MSG_TRACE_DIR != null) { Message.TraceMessageSend(sequenceNr, msg.get_header_bytes(), msg.get_annotations_bytes(), msg.data); } // process handshake response msg = Message.recv(sock_stream, new [] { Message.MSG_CONNECTOK, Message.MSG_CONNECTFAIL }); responseAnnotations(msg.annotations, msg.type); object handshake_response = "?"; if (msg.data != null) { if ((msg.flags & Message.FLAGS_COMPRESSED) != 0) { _decompressMessageData(msg); } try { ser = PyroSerializer.GetFor(msg.serializer_id); handshake_response = ser.deserializeData(msg.data); } catch (Exception) { msg.type = Message.MSG_CONNECTFAIL; handshake_response = "<not available because unsupported serialization format>"; } } switch (msg.type) { case Message.MSG_CONNECTOK: var response_dict = (IDictionary)handshake_response; _processMetadata((IDictionary)response_dict["meta"]); handshake_response = response_dict["handshake"]; try { validateHandshake(handshake_response); } catch (Exception) { close(); throw; } break; case Message.MSG_CONNECTFAIL: close(); throw new PyroException("connection rejected, reason: " + handshake_response); default: close(); throw new PyroException($"connect: invalid msg type {msg.type} received"); } }
public void testChecksum() { var msg = new Message(Message.MSG_RESULT, new byte[]{1,2,3,4}, 42, 0, 1, null); var c = new ConnectionMock(); c.send(msg.to_bytes()); // corrupt the checksum bytes byte[] data = c.ReceivedData; data[Message.HEADER_SIZE-2] = 0; data[Message.HEADER_SIZE-1] = 0; c = new ConnectionMock(data); try { Message.recv(c, null); Assert.Fail("crash expected"); } catch(PyroException x) { Assert.IsTrue(x.Message.Contains("checksum")); } }
/** * Internal call method to actually perform the Pyro method call and process the result. */ private object call(string method, ushort flags, params object[] parameters) { lock(this) { connect(); unchecked { sequenceNr++; // unchecked so this ushort wraps around 0-65535 instead of raising an OverflowException } } if (parameters == null) parameters = new object[] {}; PyroSerializer ser = PyroSerializer.GetFor(Config.SERIALIZER); byte[] pickle = ser.serializeCall(objectid, method, parameters, new Dictionary<string,object>(0)); var msg = new Message(Message.MSG_INVOKE, pickle, ser.serializer_id, flags, sequenceNr, null); Message resultmsg; lock (this.sock) { IOUtil.send(sock_stream, msg.to_bytes()); if(Config.MSG_TRACE_DIR!=null) { Message.TraceMessageSend(sequenceNr, msg.get_header_bytes(), msg.get_annotations_bytes(), msg.data); } pickle = null; if ((flags & Message.FLAGS_ONEWAY) != 0) return null; resultmsg = Message.recv(sock_stream, new ushort[]{Message.MSG_RESULT}); } if (resultmsg.seq != sequenceNr) { throw new PyroException("result msg out of sync"); } if ((resultmsg.flags & Message.FLAGS_COMPRESSED) != 0) { // we need to skip the first 2 bytes in the buffer due to a tiny mismatch between zlib-written // data and the deflate data bytes that .net expects. // See http://www.chiramattel.com/george/blog/2007/09/09/deflatestream-block-length-does-not-match.html using(MemoryStream compressed=new MemoryStream(resultmsg.data, 2, resultmsg.data.Length-2, false)) { using(DeflateStream decompresser=new DeflateStream(compressed, CompressionMode.Decompress)) { MemoryStream bos = new MemoryStream(resultmsg.data.Length); byte[] buffer = new byte[4096]; int numRead; while ((numRead = decompresser.Read(buffer, 0, buffer.Length)) != 0) { bos.Write(buffer, 0, numRead); } resultmsg.data=bos.ToArray(); } } } if ((resultmsg.flags & Message.FLAGS_EXCEPTION) != 0) { Exception rx = (Exception) ser.deserializeData(resultmsg.data); if (rx is PyroException) { throw (PyroException) rx; } else { PyroException px = new PyroException("remote exception occurred", rx); PropertyInfo remotetbProperty=rx.GetType().GetProperty("_pyroTraceback"); if(remotetbProperty!=null) { string remotetb=(string)remotetbProperty.GetValue(rx,null); px._pyroTraceback=remotetb; } throw px; } } return ser.deserializeData(resultmsg.data); }
public void testChecksum() { var msg = new Message(Message.MSG_RESULT, new byte[]{1,2,3,4}, 42, 0, 1, null, null); byte[] data = msg.to_bytes(); // corrupt the checksum bytes data[Message.HEADER_SIZE-2] = 0; data[Message.HEADER_SIZE-1] = 0; Stream ms = new MemoryStream(data); try { Message.recv(ms, null, null); Assert.Fail("crash expected"); } catch(PyroException x) { Assert.IsTrue(x.Message.Contains("checksum")); } }
public void testRecvNoAnnotations() { var msg = new Message(Message.MSG_CONNECT, new byte[]{1,2,3,4,5}, 42, 0, 0, null, null); byte[] data = msg.to_bytes(); var ms = new MemoryStream(data); msg = Message.recv(ms, null, null); Assert.AreEqual(-1, ms.ReadByte()); Assert.AreEqual(5, msg.data_size); Assert.AreEqual(new byte[]{1,2,3,4,5}, msg.data); Assert.AreEqual(0, msg.annotations_size); Assert.AreEqual(0, msg.annotations.Count); }
/// <summary> /// Perform the Pyro protocol connection handshake with the Pyro daemon. /// </summary> protected void _handshake() { var ser = PyroSerializer.GetFor(Config.SERIALIZER); var handshakedata = new Dictionary<string, Object>(); handshakedata["handshake"] = pyroHandshake; if(Config.METADATA) handshakedata["object"] = objectid; byte[] data = ser.serializeData(handshakedata); ushort flags = Config.METADATA? Message.FLAGS_META_ON_CONNECT : (ushort)0; var msg = new Message(Message.MSG_CONNECT, data, ser.serializer_id, flags, sequenceNr, annotations(), pyroHmacKey); IOUtil.send(sock_stream, msg.to_bytes()); if(Config.MSG_TRACE_DIR!=null) { Message.TraceMessageSend(sequenceNr, msg.get_header_bytes(), msg.get_annotations_bytes(), msg.data); } // process handshake response msg = Message.recv(sock_stream, new ushort[]{Message.MSG_CONNECTOK, Message.MSG_CONNECTFAIL}, pyroHmacKey); responseAnnotations(msg.annotations, msg.type); object handshake_response = "?"; if(msg.data!=null) { if((msg.flags & Message.FLAGS_COMPRESSED) != 0) { _decompressMessageData(msg); } handshake_response = ser.deserializeData(msg.data); } if(msg.type==Message.MSG_CONNECTOK) { if((msg.flags & Message.FLAGS_META_ON_CONNECT) != 0) { var response_dict = (Hashtable)handshake_response; _processMetadata(response_dict["meta"] as Hashtable); handshake_response = response_dict["handshake"]; try { validateHandshake(handshake_response); } catch (Exception) { close(); throw; } } } else if (msg.type==Message.MSG_CONNECTFAIL) { close(); throw new PyroException("connection rejected, reason: "+handshake_response); } else { close(); throw new PyroException(string.Format("connect: invalid msg type {0} received", msg.type)); } }
public void testRecvAnnotations() { var annotations = new Dictionary<string, byte[]>(); annotations["TEST"] = new byte[]{10, 20,30,40,50}; var msg = new Message(Message.MSG_CONNECT, new byte[]{1,2,3,4,5}, this.serializer_id, 0, 0, annotations); var c = new ConnectionMock(); c.send(msg.to_bytes()); msg = Message.recv(c, null); Assert.AreEqual(0, c.RemainingLength); Assert.AreEqual(5, msg.data_size); Assert.AreEqual(new byte[]{1,2,3,4,5}, msg.data); Assert.AreEqual(new byte[]{10,20,30,40,50}, msg.annotations["TEST"]); Assert.IsTrue(msg.annotations.ContainsKey("HMAC")); }
/// <summary> /// Internal call method to actually perform the Pyro method call and process the result. /// </summary> private object internal_call(string method, string actual_objectId, ushort flags, bool checkMethodName, params object[] parameters) { actual_objectId = actual_objectId ?? this.objectid; lock(this) { connect(); unchecked { sequenceNr++; // unchecked so this ushort wraps around 0-65535 instead of raising an OverflowException } } if(pyroAttrs.Contains(method)) { throw new PyroException("cannot call an attribute"); } if(pyroOneway.Contains(method)) { flags |= Message.FLAGS_ONEWAY; } if(checkMethodName && Config.METADATA && !pyroMethods.Contains(method)) { throw new PyroException(string.Format("remote object '{0}' has no exposed attribute or method '{1}'", actual_objectId, method)); } if (parameters == null) parameters = new object[] {}; PyroSerializer ser = PyroSerializer.GetFor(Config.SERIALIZER); byte[] pickle = ser.serializeCall(actual_objectId, method, parameters, new Dictionary<string,object>(0)); var msg = new Message(Message.MSG_INVOKE, pickle, ser.serializer_id, flags, sequenceNr, this.annotations(), pyroHmacKey); Message resultmsg; lock (this.sock) { IOUtil.send(sock_stream, msg.to_bytes()); if(Config.MSG_TRACE_DIR!=null) { Message.TraceMessageSend(sequenceNr, msg.get_header_bytes(), msg.get_annotations_bytes(), msg.data); } pickle = null; if ((flags & Message.FLAGS_ONEWAY) != 0) return null; resultmsg = Message.recv(sock_stream, new ushort[]{Message.MSG_RESULT}, pyroHmacKey); } if (resultmsg.seq != sequenceNr) { throw new PyroException("result msg out of sync"); } responseAnnotations(resultmsg.annotations, resultmsg.type); if ((resultmsg.flags & Message.FLAGS_COMPRESSED) != 0) { _decompressMessageData(resultmsg); } if ((resultmsg.flags & Message.FLAGS_EXCEPTION) != 0) { Exception rx = (Exception) ser.deserializeData(resultmsg.data); if (rx is PyroException) { throw (PyroException) rx; } else { PyroException px = new PyroException("remote exception occurred", rx); PropertyInfo remotetbProperty=rx.GetType().GetProperty("_pyroTraceback"); if(remotetbProperty!=null) { string remotetb=(string)remotetbProperty.GetValue(rx,null); px._pyroTraceback=remotetb; } throw px; } } return ser.deserializeData(resultmsg.data); }
public void testRecvAnnotations() { var annotations = new Dictionary<string, byte[]>(); annotations["TEST"] = new byte[]{10, 20,30,40,50}; var msg = new Message(Message.MSG_CONNECT, new byte[]{1,2,3,4,5}, this.serializer_id, 0, 0, annotations, Encoding.UTF8.GetBytes("secret")); var ms = new MemoryStream(msg.to_bytes()); msg = Message.recv(ms, null, Encoding.UTF8.GetBytes("secret")); Assert.AreEqual(-1, ms.ReadByte()); Assert.AreEqual(5, msg.data_size); Assert.AreEqual(new byte[]{1,2,3,4,5}, msg.data); Assert.AreEqual(new byte[]{10,20,30,40,50}, msg.annotations["TEST"]); Assert.IsTrue(msg.annotations.ContainsKey("HMAC")); }