public void DatagramRecvHandler(SelectServerSharedBuffer server, Socket sock)
{
int bytesReceived = sock.ReceiveFrom(server.sharedBuffer, ref from);
if (bytesReceived <= 0)
{
if (bytesReceived < 0)
{
throw new InvalidOperationException(String.Format("ReceiveFrom on UDP socket returned {0}", bytesReceived));
}
return; // TODO: how to handle neg
}
String clientString = "?";
try
{
clientString = from.ToString();
}
catch (Exception) { }
UInt32 parametersOffset;
RpcMessage callMessage = new RpcMessage(server.sharedBuffer, 0, (uint)bytesReceived, out parametersOffset);
if (callMessage.messageType != RpcMessageType.Call)
{
throw new InvalidOperationException(String.Format("Received an Rpc reply from '{0}' but only expecting Rpc calls", clientString));
}
if (!ProgramHeaderSupported(callMessage.call.programHeader))
{
new RpcMessage(callMessage.transmissionID, new RpcReply(RpcVerifier.None, RpcAcceptStatus.ProgramUnavailable)).SendUdp(from, sock, ref server.sharedBuffer, null);
return;
}
ISerializer replyParameters;
RpcReply reply = Call(clientString, callMessage.call, server.sharedBuffer, parametersOffset, (uint)bytesReceived, out replyParameters);
if (reply != null)
{
new RpcMessage(callMessage.transmissionID, reply).SendUdp(from, sock, ref server.sharedBuffer, replyParameters);
}
}
public T CallBlockingTcp <T>(UInt32 procedureNumber, ISerializer requestSerializer, IInstanceSerializer <T> responseSerializer, ByteArrayReference buffer)
{
UInt32 transmissionID = nextTransactionID++;
RpcMessage callMessage = new RpcMessage(transmissionID, new RpcCall(programHeader,
procedureNumber, credentials, verifier));
callMessage.SendTcp(socket, buffer, requestSerializer);
UInt32 contentOffset, contentOffsetLimit;
RpcMessage replyMessage = new RpcMessage(socket, buffer, out contentOffset, out contentOffsetLimit);
if (replyMessage.messageType != RpcMessageType.Reply)
{
throw new InvalidOperationException(String.Format("Received an Rpc call from '{0}' but expected an rpc reply", socket.RemoteEndPoint));
}
if (replyMessage.transmissionID != transmissionID)
{
throw new InvalidOperationException(String.Format("Expected reply with transmission id {0} but got {1}", transmissionID, replyMessage.transmissionID));
}
RpcReply reply = replyMessage.reply;
RpcCallFailedException.VerifySuccessfulReply(callMessage.call, reply);
T instance;
UInt32 offset = responseSerializer.Deserialize(buffer.array, contentOffset, contentOffsetLimit, out instance);
if (offset != contentOffsetLimit)
{
StringBuilder dataBuidler = new StringBuilder();
throw new InvalidOperationException(String.Format("Deserialization of rpc message '{0}' as the following '{1}' resulted in an offset of {2}, but the record had {3} bytes",
DataStringBuilder.DataString(reply, dataBuidler), DataStringBuilder.DataString(responseSerializer, instance, dataBuidler), offset, contentOffsetLimit));
}
return(instance);
}
private static String CheckForFailureInReply(RpcCall call, RpcReply reply)
{
if (reply.status != RpcReplyStatus.Accepted)
{
return(DataStringBuilder.DataString(reply.rejectedReply, new StringBuilder()));
}
RpcAcceptedReply acceptedReply = reply.acceptedReply;
if (acceptedReply.status == RpcAcceptStatus.Success)
{
return(null);
}
if (acceptedReply.status == RpcAcceptStatus.ProgramMismatch)
{
return(String.Format("ProgramMismatch: {0}", DataStringBuilder.DataString(acceptedReply.mismatchInfo, new StringBuilder())));
}
else
{
return(acceptedReply.status.ToString());
}
}
public RpcCallFailedException(RpcCall call, RpcReply reply)
: this(call, FailureReason(call, reply))
{
}
