private void OnInitRequest(RequestState request)
{
try
{
Guid guid = Guid.NewGuid();
string peerId = guid.ToString();
if ((request.Context.Request.QueryString.Count < 1) || (request.Context.Request.QueryString[0] != "init"))
{
if (log.IsDebugEnabled)
{
log.DebugFormat("Received empty peer id", new object[0]);
}
RpcHttpHelper.SendErrorResponse(request.Context.Response, "Invalid rpc request");
request.AsyncResult.SetCompleted(null, false);
}
else
{
if (log.IsDebugEnabled)
{
log.DebugFormat("Received init request: pid={0}", new object[] { peerId });
}
PhotonHttpPeer photonPeer = new PhotonHttpPeer(peerId, this, request.Context);
if (!this.peerCache.TryAddPeer(photonPeer))
{
if (log.IsWarnEnabled)
{
log.WarnFormat("Failed to create peer: pid={0}", new object[] { peerId });
}
RpcHttpHelper.SendServerErrorResponse(request.Context.Response);
}
else
{
byte[] data = RpcHttpHelper.ReadRequest(request.Context.Request);
this.photonApplication.OnInit(photonPeer, data, 1);
if (photonPeer.Queue.Count == 0)
{
request.AsyncResult.SetCompleted(null, false);
}
else
{
byte[] buffer = photonPeer.Queue.Dequeue();
request.Context.Response.OutputStream.Write(guid.ToByteArray(), 0, 0x10);
request.Context.Response.OutputStream.Write(buffer, 0, buffer.Length);
request.AsyncResult.SetCompleted(null, false);
}
}
}
}
catch (Exception exception)
{
log.Error(exception);
}
}
public IAsyncResult BeginProcessRequest(HttpContext context, AsyncCallback cb, object extraData)
{
try
{
AsyncResult asyncCallback = new AsyncResult(cb, extraData);
RequestState state = new RequestState(HttpContext.Current, asyncCallback);
ThreadPool.QueueUserWorkItem(new WaitCallback(this.ProcessRequestCallBack), state);
return(asyncCallback);
}
catch (Exception exception)
{
log.Error(exception);
RpcHttpHelper.SendServerErrorResponse(context.Response);
AsyncResult result2 = new AsyncResult(cb, extraData);
result2.SetCompleted(null, true);
return(result2);
}
}
private void ProcessRequestCallBack(object state)
{
try
{
PhotonHttpPeer peer;
RequestState request = (RequestState)state;
HttpContext context = request.Context;
string str = context.Request.Params.Get("pid");
int maxHttpReceiveMessageSize = PhotonSettings.Default.MaxHttpReceiveMessageSize;
if ((context.Request.ContentLength > maxHttpReceiveMessageSize) || (context.Request.InputStream.Length > maxHttpReceiveMessageSize))
{
if (log.IsDebugEnabled)
{
log.DebugFormat("Max message size exceeded: pid={0}, ContentLenght={1}", new object[] { str, context.Request.ContentLength });
}
RpcHttpHelper.SendResponse(context.Response, HttpStatusCode.BadRequest, "Max message size exceeded");
}
else if (string.IsNullOrEmpty(str))
{
this.OnInitRequest(request);
}
else if (!this.peerCache.TryGetPeer(request.Context, str, out peer))
{
if (log.IsDebugEnabled)
{
log.DebugFormat("Received unknown peer id: {0}", new object[] { str });
}
RpcHttpHelper.SendResponse(context.Response, HttpStatusCode.Unauthorized, "Unknown peer id");
request.AsyncResult.SetCompleted(null, false);
}
else
{
if (context.Request.RequestType == "POST")
{
byte[] data = RpcHttpHelper.ReadRequest(context.Request);
if (data.Length == 1)
{
switch (data[0])
{
case 0:
this.SendQueuedMessages(peer, request);
request.AsyncResult.SetCompleted(null, false);
return;
case 1:
this.photonApplication.OnDisconnect(peer, peer.GetUserData(), DisconnectReason.ManagedDisconnect, string.Empty, 0, 0, 0);
this.peerCache.RemovePeer(peer.PeerId);
request.AsyncResult.SetCompleted(null, false);
return;
}
}
if (data.Length > 0)
{
string str2 = context.Request.Params["invocId"];
if (!string.IsNullOrEmpty(str2))
{
int invocationId;
if (!int.TryParse(str2, out invocationId))
{
log.DebugFormat("Received invalid invocation id: peerId={0}, invocationId={1}", new object[] { str, str2 });
RpcHttpHelper.SendResponse(context.Response, HttpStatusCode.BadRequest, "Invalid invocation id specified.");
request.AsyncResult.SetCompleted(null, false);
return;
}
peer.InvocationCache.Invoke(invocationId, () => this.ExecuteOnReceive(peer, data, new int?(invocationId)));
}
else
{
this.ExecuteOnReceive(peer, data, null);
}
}
}
this.SendQueuedMessages(peer, request);
request.AsyncResult.SetCompleted(null, false);
}
}
catch (Exception exception)
{
log.Error(exception);
}
}
