public virtual void sendUnsubscription(UnsubscribeRequest request, RequestTutor tutor)
{
if (this.session != null)
{
this.session.sendUnsubscription(request, tutor);
}
}
public virtual bool addRequestToBatch(SubscribeRequest request, RequestTutor tutor, RequestListener listener)
{
if (this.batchType != CONTROL)
{
log.Error("Unexpected request type was given to batch");
return(false);
}
string key = request.SubscriptionId.ToString();
RequestObjects requestObj = new RequestObjects(request, tutor, listener);
RequestObjects queuedRequest = null;
keys.TryGetValue(key, out queuedRequest);
if (queuedRequest != null)
{
//can never happen that an ADD request substitutes a REMOVE request for 2 reasons:
// *if those requests are part of the same session than to remove and re-add a table
// changes its key.
// *if those requests are not part of the same session than during session change
// all pending request are removed.
//so, all cases should pass from the if (requestType == ControlRequest.REMOVE) case
// thus, this is an unexpected case, let's handle it anyway
queuedRequest.tutor.notifyAbort();
this.substituteRequest(key, requestObj);
}
else
{
this.addRequestInternal(key, requestObj);
}
return(true);
}
public virtual bool addRequestToBatch(ChangeSubscriptionRequest request, RequestTutor tutor, RequestListener listener)
{
if (this.batchType != CONTROL)
{
log.Error("Unexpected request type was given to batch");
return(false);
}
string key = CHANGE_SUB_KEY + request.SubscriptionId;
RequestObjects requestObj = new RequestObjects(request, tutor, listener);
RequestObjects queuedRequest = null;
keys.TryGetValue(key, out queuedRequest);
if (queuedRequest != null)
{
//this change frequency request is newer, replace the old one
queuedRequest.tutor.notifyAbort();
this.substituteRequest(key, requestObj);
}
else
{
this.addRequestInternal(key, requestObj);
}
return(true);
}
public virtual bool addRequestToBatch(ForceRebindRequest request, RequestTutor tutor, RequestListener listener)
{
if (this.batchType != CONTROL)
{
log.Error("Unexpected request type was given to batch");
return(false);
}
//can we queue force rebind for 2 different sessions? (NO)
string key = FORCE_REBIND_KEY;
RequestObjects requestObj = new RequestObjects(request, tutor, listener);
RequestObjects queuedRequest = null;
keys.TryGetValue(key, out queuedRequest);
if (queuedRequest != null)
{
queuedRequest.tutor.notifyAbort();
this.substituteRequest(key, requestObj);
}
else
{
this.addRequestInternal(key, requestObj);
}
return(true);
}
public virtual bool addRequestToBatch(UnsubscribeRequest request, RequestTutor tutor, RequestListener listener)
{
if (this.batchType != CONTROL)
{
log.Error("Unexpected request type was given to batch");
return(false);
}
string key = request.SubscriptionId.ToString();
RequestObjects requestObj = new RequestObjects(request, tutor, listener);
RequestObjects queuedRequest = null;
keys.TryGetValue(key, out queuedRequest);
if (queuedRequest != null)
{
if (queuedRequest.request is SubscribeRequest)
{ //can't be the first attempt, otherwise the unsubscribe request would not be here
log.Debug("Substituting SUBSCRIBE request with UNSUBSCRIBE");
queuedRequest.tutor.notifyAbort();
this.substituteRequest(key, requestObj);
}
else
{
//delete already queued, should not happen, still, we don't have nothing to do
}
}
else
{
this.addRequestInternal(key, requestObj);
}
return(true);
}
public virtual void sendReverseHeartbeat(ReverseHeartbeatRequest request, RequestTutor tutor)
{
if (this.session != null)
{
this.session.sendReverseHeartbeat(request, tutor);
}
}
//////////////////////////////////////////////MESSAGE API CALLS
public virtual void sendMessage(MessageRequest request, RequestTutor tutor)
{
if (this.session != null)
{
this.session.sendMessage(request, tutor);
}
}
public virtual bool addRequestToBatch(DestroyRequest request, RequestTutor tutor, RequestListener listener)
{
if (this.batchType != CONTROL)
{
log.Error("Unexpected request type was given to batch");
return(false);
}
string key = request.Session;
RequestObjects requestObj = new RequestObjects(request, tutor, listener);
RequestObjects queuedRequest = null;
keys.TryGetValue(key, out queuedRequest);
if (queuedRequest != null)
{
log.Debug("Substituting DESTROY request");
queuedRequest.tutor.notifyAbort();
this.substituteRequest(key, requestObj);
}
else
{
this.addRequestInternal(key, requestObj);
}
return(true);
}
public virtual bool addRequestToBatch(ReverseHeartbeatRequest request, RequestTutor tutor, RequestListener listener)
{
if (this.batchType != HEARTBEAT)
{
log.Error("Unexpected request type was given to batch");
return(false);
}
//I should only add to queue, the heart-beats are always sent to the server
RequestObjects hb = new RequestObjects(request, tutor, listener);
this.addRequestInternal(this.messageNextKey++, hb);
return(true);
}
public virtual bool addRequestToBatch(MessageRequest request, RequestTutor tutor, RequestListener listener)
{
if (this.batchType != MESSAGE)
{
log.Error("Unexpected request type was given to batch");
return(false);
}
//I should only add to queue, the sendMessages are always sent to the server
RequestObjects message = new RequestObjects(request, tutor, listener);
this.addRequestInternal(this.messageNextKey++, message);
return(true);
}
private bool addToProperBatch(LightstreamerRequest request, RequestTutor tutor, RequestListener listener)
{
if (request is MessageRequest)
{
if (log.IsDebugEnabled)
{
log.Debug("New Message request: " + request.RequestName + ", " + listener);
}
return(this.messageQueue.addRequestToBatch((MessageRequest)request, tutor, listener));
}
else if (request is ReverseHeartbeatRequest)
{
return(this.hbQueue.addRequestToBatch((ReverseHeartbeatRequest)request, tutor, listener));
}
else if (request is ConstrainRequest)
{
return(this.controlQueue.addRequestToBatch((ConstrainRequest)request, tutor, listener));
}
else if (request is ForceRebindRequest)
{
return(this.controlQueue.addRequestToBatch((ForceRebindRequest)request, tutor, listener));
}
else if (request is UnsubscribeRequest)
{
return(this.controlQueue.addRequestToBatch((UnsubscribeRequest)request, tutor, listener));
}
else if (request is SubscribeRequest)
{
return(this.controlQueue.addRequestToBatch((SubscribeRequest)request, tutor, listener));
}
else if (request is ChangeSubscriptionRequest)
{
return(this.controlQueue.addRequestToBatch((ChangeSubscriptionRequest)request, tutor, listener));
}
else if (request is DestroyRequest)
{
return(this.destroyQueue.addRequestToBatch((DestroyRequest)request, tutor, listener));
}
else
{
return(false);
}
}
public virtual void addRequest(LightstreamerRequest request, RequestTutor tutor, RequestListener reqListener)
{
Debug.Assert(request is ControlRequest || request is MessageRequest || request is ReverseHeartbeatRequest);
if (request is NumberedRequest)
{
/*
* for numbered requests (i.e. having a LS_reqId) the client expects a REQOK/REQERR notification from the server
*/
NumberedRequest numberedReq = (NumberedRequest)request;
Debug.Assert(!pendingRequestMap.ContainsKey(numberedReq.RequestId));
pendingRequestMap[numberedReq.RequestId] = reqListener;
sessionLog.Debug("Pending request - post - " + numberedReq.RequestId);
}
if (wsTransport == null)
{
// no transport: this case can happen for example when the flag isEarlyWSOpenEnabled is off.
// buffer the request and await the binding of the session
controlRequestQueue.AddLast(new PendingRequest(request, reqListener, tutor));
}
else
{
// there is a transport, so openSocket was already called: the state is CONNECTED or CONNECTING
InternalState state = wsTransport.State;
switch (state)
{
case InternalState.CONNECTED:
sendControlRequest(request, reqListener, tutor);
break;
case InternalState.CONNECTING:
// buffer the requests, which will be flushed when the client state is CONNECTED
controlRequestQueue.AddLast(new PendingRequest(request, reqListener, tutor));
break;
default:
// Debug.Assert(false);
sessionLog.Warn("Unexpected request " + request.RequestName + " in state " + state);
break;
}
}
}
public virtual void addRequest(LightstreamerRequest request, RequestTutor tutor, RequestListener listener)
{
Debug.Assert(request is ControlRequest || request is MessageRequest || request is ReverseHeartbeatRequest);
if (this.@is(END) || this.@is(ENDING))
{
log.Error("Unexpected call on dismissed batch manager: " + request.TransportUnawareQueryString);
throw new System.InvalidOperationException("Unexpected call on dismissed batch manager");
}
this.addToProperBatch(request, tutor, listener);
if (this.@is(IDLE))
{
this.dequeue(SYNC_DEQUEUE, "add");
}
else
{
//we're already busy, we'll dequeue when we'll be back
log.Debug("Request manager busy: the request will be sent later " + request);
}
}
protected override void forwardDestroyRequest(DestroyRequest request, RequestTutor tutor, RequestListener reqListener)
{
// don't send destroy request when transport is http
}
public override void sendControlRequest(LightstreamerRequest request, RequestTutor tutor, RequestListener reqListener)
{
httpRequestManager.addRequest(request, tutor, reqListener);
}
public override void sendReverseHeartbeat(ReverseHeartbeatRequest request, RequestTutor tutor)
{
base.sendReverseHeartbeat(request, tutor);
}
public PendingRequest(LightstreamerRequest request, RequestListener reqListener, RequestTutor tutor)
{
this.request = request;
this.reqListener = reqListener;
this.tutor = tutor;
}
public virtual void sendSubscriptionChange(ChangeSubscriptionRequest request, RequestTutor tutor)
{
if (this.session != null)
{
this.session.sendSubscriptionChange(request, tutor);
}
}
private void sendControlRequest(LightstreamerRequest request, RequestListener reqListener, RequestTutor tutor)
{
ongoingRequest = new PendingRequest(request, reqListener, tutor);
wsTransport.sendRequest(protocol, request, new ListenerWrapperAnonymousInnerClass(this, reqListener)
, null, null, 0, 0);
}
public RequestObjects(LightstreamerRequest request, RequestTutor tutor, RequestListener listener)
{
this.request = request;
this.tutor = tutor;
this.listener = listener;
}
protected override void forwardDestroyRequest(DestroyRequest request, RequestTutor tutor, RequestListener reqListener)
{
wsRequestManager.addRequest(request, tutor, reqListener);
}
