private void TestFoobar()
{
Util.Log("client request foobar");
SpObject foobar_request = new SpObject();
foobar_request.Insert("what", "foo");
SpStream req = client.Request("foobar", foobar_request, 1);
Util.Assert(req.Length == 11);
Util.Log("request foobar size = " + req.Length);
req.Position = 0;
SpRpcResult dispatch_result = server.Dispatch(req);
Util.Assert(dispatch_result.Arg["what"].AsString().Equals("foo"));
Util.DumpObject(dispatch_result.Arg);
Util.Log("server response");
SpObject foobar_response = new SpObject();
foobar_response.Insert("ok", true);
SpStream resp = server.Response(dispatch_result.Session, foobar_response);
Util.Assert(resp.Length == 7);
Util.Log("response package size = " + resp.Length);
Util.Log("client dispatch");
resp.Position = 0;
dispatch_result = client.Dispatch(resp);
Util.Assert(dispatch_result.Arg["ok"].AsBoolean() == true);
Util.DumpObject(dispatch_result.Arg);
}
public void ProcessMessage(byte[] bytes)
{
var stream = new SpStream(bytes, 0, bytes.Length, bytes.Length);
var result = _rpc.Dispatch(stream);
_client.ProcessMessage(result);
}
private void Receive(IAsyncResult asyncResult)
{
int receiveLength = mSocket.EndReceive(asyncResult);
int read = 0;
while (receiveLength > read)
{
if (read >= mReceiveBuffer.Length - 1)
{
break;
}
int size = (mReceiveBuffer[read] | mReceiveBuffer[read + 1] << 8);
read += 2;
if (receiveLength >= read + size)
{
SpStream spStream = new SpStream(mReceiveBuffer, read, size, size);
SpRpcResult spResult = mRpc.Dispatch(spStream);
mReceiveQueue.Enqueue(spResult);
}
read += size;
}
mSocket.BeginReceive(mReceiveBuffer, 0, mReceiveBuffer.Length, SocketFlags.None, new AsyncCallback(ReceiveCallback), this);
}
public void Recv(IAsyncResult ar)
{
int ret = mSocket.EndReceive(ar);
if (ret > 0)
{
mRecvOffset += ret;
int read = 0;
while (mRecvOffset > read)
{
int size = (mRecvBuffer[read + 1] | (mRecvBuffer[read + 0] << 8));
read += 2;
if (mRecvOffset >= size + read)
{
SpStream stream = new SpStream(mRecvBuffer, read, size, size);
SpRpcResult result = mRpc.Dispatch(stream);
switch (result.Op)
{
case SpRpcOp.Request:
Util.Log("Recv Request : " + result.Protocol.Name + ", session : " + result.Session);
if (result.Arg != null)
{
Util.DumpObject(result.Arg);
}
break;
case SpRpcOp.Response:
Util.Log("Recv Response : " + result.Protocol.Name + ", session : " + result.Session);
if (result.Arg != null)
{
Util.DumpObject(result.Arg);
}
break;
}
read += size;
}
}
Util.Assert(mRecvOffset == read);
mRecvOffset = 0;
}
mSocket.BeginReceive(mRecvBuffer, 0, mRecvBuffer.Length, SocketFlags.None, new System.AsyncCallback(ReadCallback), this);
}
public static SpRpcResult Parse(byte[] bytes, int dataLength)
{
var stream = new SpStream(bytes, 0, dataLength, dataLength);
return(_rpc.Dispatch(stream));
}
