public RpcTcpMessage <RpcResponse> GetResponse()
{
var h = ProtoBufSerializer.FromByteArray <RpcResponseHeader>(_headerBuffer);
int offset = IdentityLength + HeaderLength;
RpcResponse response = new RpcResponse()
{
ErrorCode = (RpcErrorCode)h.ResponseCode,
Options = (RpcMessageOptions)h.Option,
};
int len = h.BodyLength - 1;
if (len > 0)
{
response.BodyBuffer = new RpcBodyBuffer(_bodyBuffer);
response.BodyBuffer.TextError = true;
offset += len;
}
else if (len == 0)
{
response.BodyBuffer = RpcBodyBuffer.EmptyBody;
}
else
{
response.BodyBuffer = null;
}
var message = new RpcTcpMessage <RpcResponse>()
{
Sequence = h.Sequence,
Message = response,
};
return(message);
}
public T ReceiceRequest <T>()
{
if (_context.HasBody)
{
return(ProtoBufSerializer.FromByteArray <T>(_buffer));
}
else
{
return(default(T));
}
}
public T ReceiveResponse <T>()
{
if (_context.HasBody)
{
return(ProtoBufSerializer.FromByteArray <T>(_bodyBuffer));
}
else
{
return(default(T));
}
}
public void ProtoBuffer_TestSimple2()
{
byte[] buffer1 = ProtoBufSerializer.ToByteArray <int>(123);
byte[] buffer2 = ProtoBufSerializer.ToByteArray <HybridDictionary <int, int> >(new HybridDictionary <int, int>());
HybridDictionary <int, string> s = new HybridDictionary <int, string>();
s.Add(1, "!23123");
byte[] buffer3 = ProtoBufSerializer.ToByteArray <HybridDictionary <int, string> >(s);
var ss = ProtoBufSerializer.FromByteArray <HybridDictionary <int, string> >(buffer3);
Assert.AreEqual(ss.Count, 1);
Assert.AreEqual(ss.Keys.Count, 1);
Assert.AreEqual(ss.Values.Count, 1);
}
public static RpcPipeContext ReadStream(PipeStream stream, out byte[] buffer)
{
byte[] headerBuffer = new byte[RpcPipeHeader.Size];
stream.Read(headerBuffer, 0, RpcPipeHeader.Size);
RpcPipeHeader header = RpcPipeHeader.FromByteArray(headerBuffer);
if (header.Mark != RpcPipeHeader.MagicMark)
{
// throw new RpcException("RpcPipeHeader Crashed", "", RpcErrorCode.SendFailed, null);
buffer = null;
return(null);
}
if (header.ContextSize > 1024 || header.BodySize > 64000000)
{
// throw new RpcException("RpcPipeHeader Length To Long", "", RpcErrorCode.SendFailed, null);
buffer = null;
return(null);
}
byte[] contextBuffer = new byte[header.ContextSize];
stream.Read(contextBuffer, 0, contextBuffer.Length);
RpcPipeContext context = ProtoBufSerializer.FromByteArray <RpcPipeContext>(contextBuffer);
if (context.HasBody)
{
if (header.BodySize == 0)
{
buffer = EmptyBuffer;
}
else
{
buffer = new byte[header.BodySize];
stream.Read(buffer, 0, buffer.Length);
}
}
else
{
buffer = null;
}
return(context);
}
public virtual V GetValue <V>()
{
if (_value != null)
{
return((V)_value);
}
switch (_mode)
{
case RpcBodyBufferMode.Input:
_value = ProtoBufSerializer.FromByteArray <V>(_buffer);
return((V)_value);
case RpcBodyBufferMode.DataOutput:
return((V)_value);
default:
throw new NotSupportedException("Mode Not Support:" + _mode);
}
}
public RpcTcpMessage <RpcRequest> GetRequest()
{
var h = ProtoBufSerializer.FromByteArray <RpcRequestHeader>(_headerBuffer);
RpcRequest request = new RpcRequest()
{
Service = h.Service,
Method = h.Method,
FromComputer = h.FromComputer,
FromService = h.FromService,
ContextUri = h.ContextUri,
Options = (RpcMessageOptions)h.Option,
};
int len = h.BodyLength - 1;
if (len > 0)
{
request.BodyBuffer = new RpcBodyBuffer(_bodyBuffer);
}
else if (len == 0)
{
request.BodyBuffer = RpcBodyBuffer.EmptyBody;
}
else
{
request.BodyBuffer = null;
}
var message = new RpcTcpMessage <RpcRequest>()
{
Sequence = h.Sequence,
Message = request,
};
return(message);
}
