public void EndSendResponse(uint requestID, ConnectionType ctype)
{
isSendingResponse = false;
m_currentResponse?.Clear();
m_currentResponse = null;
lock (m_requestsLock)
m_waitingResponse = false;
if (contextID < 0)
{
return;
}
if (ctype == ConnectionType.Close)
{
m_isClosing = true;
m_requests.Clear();
TriggerKeepalive = true;
return;
}
else
{
LastActivityTimeMS = ContextTimeoutManager.EnvironmentTickCount();
if (Stream == null || !Stream.CanWrite)
{
return;
}
HttpRequest nextRequest = null;
lock (m_requestsLock)
{
if (m_requests != null && m_requests.Count > 0)
{
nextRequest = m_requests.Dequeue();
}
if (nextRequest != null && RequestReceived != null)
{
m_waitingResponse = true;
TriggerKeepalive = false;
}
else
{
TriggerKeepalive = true;
}
}
if (nextRequest != null)
{
RequestReceived?.Invoke(this, new RequestEventArgs(nextRequest));
}
}
}
private CloudConnectorApiContext ProcessCloudMessage(CloudRequestMessage cloudMessage)
{
var apiContext = new CloudConnectorApiContext(cloudMessage);
var eventArgs = new ApiRequestReceivedEventArgs(apiContext);
RequestReceived?.Invoke(this, eventArgs);
if (!eventArgs.IsHandled)
{
apiContext.ResultCode = ApiResultCode.ActionNotSupported;
}
return(apiContext);
}
private void Communication()
{
string exitReason = "None";
try {
Debug.WriteLine($"[Server {InstanceId}] Communication Started");
if (!_streams.WaitForConnectionCancelable())
{
exitReason = "Connect canceled"; return;
}
Debug.WriteLine($"[Server {InstanceId}] Communication Connected");
Connected?.Invoke(this, EventArgs.Empty);
while (true)
{
if (_disposeFlag)
{
exitReason = "Disposed"; break;
}
if (_streams.Reader.EndOfStream)
{
exitReason = "EndOfStream"; break;
}
var request = _streams.Reader.ReadLine(); // TODO read strategy message/byte/line
Debug.WriteLine($"[Server {InstanceId}] Communication Received");
if (request != null)
{
var msgEventArgs = new PipeMsgEventArgs(request);
RequestReceived.Invoke(this, msgEventArgs);
_streams.Writer.WriteLine(msgEventArgs.Response);
_streams.Writer.Flush();
}
}
}
catch (IOException ex) {
exitReason = "IOException";
Debug.WriteLine(ex);
}
catch (Exception ex) {
exitReason = "Exeption";
Debug.WriteLine(ex);
}
finally {
Debug.WriteLine($"[Server {InstanceId}] Communication exit. Reason: {exitReason}");
Disconnected?.Invoke(this, EventArgs.Empty);
Dispose();
}
}
private void DispatchHttpRequest(HttpContext httpContext)
{
var apiContext = CreateApiContext(httpContext);
if (apiContext == null)
{
httpContext.Response.StatusCode = HttpStatusCode.BadRequest;
return;
}
var eventArgs = new ApiRequestReceivedEventArgs(apiContext);
RequestReceived?.Invoke(this, eventArgs);
if (!eventArgs.IsHandled)
{
httpContext.Response.StatusCode = HttpStatusCode.BadRequest;
return;
}
if (eventArgs.Context.Response == null)
{
eventArgs.Context.Response = new JObject();
}
httpContext.Response.StatusCode = ConvertResultCode(eventArgs.Context.ResultCode);
if (apiContext.UseHash)
{
var serverHash = GenerateHash(apiContext.Response.ToString());
eventArgs.Context.Response["$Hash"] = serverHash;
var serverHashWithQuotes = "\"" + serverHash + "\"";
string clientHash;
if (httpContext.Request.Headers.TryGetValue(HttpHeaderNames.IfNoneMatch, out clientHash))
{
if (clientHash.Equals(serverHashWithQuotes))
{
httpContext.Response.StatusCode = HttpStatusCode.NotModified;
return;
}
}
httpContext.Response.Headers[HttpHeaderNames.ETag] = serverHashWithQuotes;
}
httpContext.Response.Body = new JsonBody(eventArgs.Context.Response);
}
protected virtual void OnRequestReceived(HttpRequestEventArgs e)
{
foreach (HttpRequestEventHandler handler in RequestReceived.GetInvocationList())
{
try
{
handler.Invoke(this, e);
}
catch (Exception ex)
{
ex.Source = handler.Method.Module + "/" + handler.Method.DeclaringType.Name + "/" + handler.Method.Name;
RaiseUnhandledException(e.Context, ex);
}
}
}
async void Listener()
{
try
{
while (udp != null)
{
var result = await udp.ReceiveAsync();
RequestReceived?.Invoke(this, result);
}
}
catch (Exception)
{
// eat the exception
}
}
protected override Task <HttpResponseMessage> SendAsync(HttpRequestMessage request,
CancellationToken cancellationToken)
{
if (_responses.Count == 0)
{
throw new InvalidOperationException("No response configured");
}
RequestReceived?.Invoke(this, request);
_requests.Add(request);
var response = _responses.Dequeue();
return(Task.FromResult(response.MakeResponse(cancellationToken)));
}
private void DispatchRequest(HttpContext httpContext)
{
var apiContext = CreateContext(httpContext);
if (apiContext == null)
{
httpContext.Response.StatusCode = HttpStatusCode.BadRequest;
return;
}
var eventArgs = new ApiRequestReceivedEventArgs(apiContext);
RequestReceived?.Invoke(this, eventArgs);
if (!eventArgs.IsHandled)
{
httpContext.Response.StatusCode = HttpStatusCode.BadRequest;
return;
}
if (eventArgs.Context.Response == null)
{
eventArgs.Context.Response = new JsonObject();
}
httpContext.Response.StatusCode = ConvertResultCode(eventArgs.Context.ResultCode);
if (apiContext.CallType == ApiCallType.Request)
{
var serverHash = apiContext.Response.GetNamedObject("Meta", new JsonObject()).GetNamedString("Hash", string.Empty);
var serverHashWithQuotes = "\"" + serverHash + "\"";
string clientHash;
if (httpContext.Request.Headers.TryGetValue(HttpHeaderNames.IfNoneMatch, out clientHash))
{
if (clientHash.Equals(serverHashWithQuotes))
{
httpContext.Response.StatusCode = HttpStatusCode.NotModified;
return;
}
}
httpContext.Response.Headers[HttpHeaderNames.ETag] = serverHashWithQuotes;
}
httpContext.Response.Body = new JsonBody(eventArgs.Context.Response);
}
public static async Task InitAsync()
{
_service = AppServiceConnectionFactory.GetConnection();
_service.RequestReceived += (AppServiceConnection sender, AppServiceRequestReceivedEventArgs args) =>
{
RequestReceived?.Invoke(sender, args);
};
_service.ServiceClosed += (AppServiceConnection sender, AppServiceClosedEventArgs args) => { Reconnect($"Service closed: {args.Status}."); };
var status = await _service.OpenAsync();
if (status != AppServiceConnectionStatus.Success)
{
Reconnect($"Connection to app service failed: {status}.");
return;
}
Debug.WriteLine("Connected to app service.");
}
public IApiCall Invoke(string action, JObject parameter)
{
if (action == null)
{
throw new ArgumentNullException(nameof(action));
}
if (parameter == null)
{
throw new ArgumentNullException(nameof(parameter));
}
var apiCall = new ApiCall(action, parameter, null);
RequestReceived?.Invoke(this, new ApiRequestReceivedEventArgs(apiCall));
return(apiCall);
}
private void ProcessMessage(string message)
{
if (Settings.Default.AddJsonRootObject)
{
var json = ParseJson(message, out string root);
if (root.ToLower() == "request")
{
var request = JsonConvert.DeserializeObject <Request>(json);
RequestReceived?.Invoke(this, message);
HandleRequest(request);
}
else if (root.ToLower() == "acknowledge")
{
AckReceived?.Invoke(this, message);
}
else
{
Error?.Invoke(this, new NotSupportedException($"Unknown Message Type: {root}"));
}
}
else
{
var root = JsonConvert.DeserializeObject <RootObject>(message);
switch (root.MessageType)
{
case MessageType.Request:
var request = JsonConvert.DeserializeObject <Request>(message);
RequestReceived?.Invoke(this, message);
HandleRequest(request);
break;
case MessageType.Response:
break;
case MessageType.Acknowledge:
AckReceived?.Invoke(this, message);
break;
default:
Error?.Invoke(this, new NotSupportedException($"Unknown Message Type: {root}"));
break;
}
}
}
protected void RaiseOnRequestReceived(string data)
{
try
{
LogMessage("Request received from", data);
LinkRequest linkRequest = JsonConvert.DeserializeObject <LinkRequest>(data.ToString());
RequestReceived?.Invoke(linkRequest);
}
catch (Exception e)
{
LogError(e.Message, data);
//if (Connector != null)
{
//Connector.Publish(LinkRequestResponseError(null, "DALError", e.Message), new TopicOption[] { TopicOption.Servicer }).ConfigureAwait(false);
Console.WriteLine($"RaisedOnRequestReceived: exception='{e.Message}'");
}
}
}
internal void OnRequestReceived(HttpClient client, HttpRequest request)
{
var args = new RequestEventArgs(client, request);
RequestReceived?.Invoke(this, args);
if (request.IsValidRequest)
{
if (LogRequests)
{
Log.WriteLine("Request: " + client.RemoteAddress + " " + request.Uri.OriginalString);
}
ValidRequestReceived?.Invoke(this, args);
}
else
{
InvalidRequestReceived?.Invoke(this, args);
}
}
private void DistpachMessage(object sender, MessageReceivedEventArgs e)
{
var correlationId = (string)e.Body["CorrelationId"];
var uri = (string)e.Body["Uri"];
var request = (JObject)e.Body["Content"] ?? new JObject();
var context = new QueueBasedApiContext(correlationId, uri, request, new JObject());
var eventArgs = new ApiRequestReceivedEventArgs(context);
RequestReceived?.Invoke(this, eventArgs);
if (!eventArgs.IsHandled)
{
context.ResultCode = ApiResultCode.UnknownUri;
}
SendResponseMessage(context).Wait();
}
private void DistpachMessage(object sender, MessageReceivedEventArgs e)
{
var apiRequest = e.Body.ToObject <ApiRequest>();
var correlationId = (string)e.Body["CorrelationId"];
var context = new QueueBasedApiContext(correlationId, apiRequest.Action, apiRequest.Parameter, apiRequest.ResultHash);
var eventArgs = new ApiRequestReceivedEventArgs(context);
RequestReceived?.Invoke(this, eventArgs);
if (!eventArgs.IsHandled)
{
context.ResultCode = ApiResultCode.ActionNotSupported;
}
SendResponseMessage(context).Wait();
}
private void OnSyncRequestEvent(string sender, IntPtr request, IntPtr response, IntPtr data)
{
SafeParcelHandle reqSafeHandle = new SafeParcelHandle(request, false);
object req = null;
using (Parcel reqParcel = new Parcel(reqSafeHandle))
{
req = FromParcel(reqParcel);
}
var args = new RequestEventArgs(sender, req, true);
RequestReceived?.Invoke(this, args);
var result = args.Reply;
if (result == null)
{
Log.Error(LogTag, "result is null");
}
else if (!result.GetType().IsSerializable)
{
Log.Error(LogTag, "result is not serializable");
}
else
{
SafeParcelHandle resSafeHandle = new SafeParcelHandle(response, false);
using (Parcel resParcel = new Parcel(resSafeHandle))
{
using (Parcel resultParcel = ToParcel(result))
{
if (resultParcel != null)
{
resParcel.UnMarshall(resultParcel.Marshall());
}
else
{
Log.Error(LogTag, "Result parcel is null");
}
}
}
}
}
private bool _disposedValue = false; // To detect redundant calls
protected virtual void Dispose(bool disposing)
{
Log.Info($"{this}: Dispose({disposing})");
if (!_disposedValue)
{
if (disposing)
{
_closedCancellation.Cancel();
foreach (RequestReceived callback in (RequestReceived?.GetInvocationList() ?? Enumerable.Empty <Delegate>()))
{
RequestReceived -= callback;
}
_closedCancellation?.Dispose();
}
_disposedValue = true;
}
}
private void _HandleRequest(RequestMessage message)
{
Debug("Handle Request", message);
RequestContext context = new RequestContext(message, this);
_requestContexts.Add(context);
if (message.Method.Equals(CoreMethods.CancelRequest))
{
// remove the duplicate context we just added
_requestContexts.Remove(context);
// get the original request context
RequestContext cancelContext = _requestContexts.FirstOrDefault(x => x.Request.Id.Equals(message.Id));
cancelContext?.Cancel();
}
else if (message.Method.Equals(CoreMethods.Initialize))
{
State = LanguageServerState.Started;
InitializeParams parameters = message.Params.ToObject <InitializeParams>();
Initialize?.Invoke(this, parameters);
InitializeResult result = new InitializeResult
{
Capabilities = _serverCapabilities
};
SendResponseAsync(message.Id, result).Wait();
}
else if (message.Method.Equals(CoreMethods.Shutdown))
{
SendResponseAsync(message.Id, null).Wait();
}
RequestReceived?.Invoke(this, context);
}
private async void SocketListener_ConnectionReceived(StreamSocketListener sender, StreamSocketListenerConnectionReceivedEventArgs args)
{
if (sender != _socketListener)
{
return;
}
StreamSocket socket = args.Socket;
_log.Debug("Incoming connection to {0}:{1} from {2}...", socket.Information.LocalAddress.DisplayName, socket.Information.LocalPort, socket.Information.RemoteAddress.DisplayName);
HttpRequest request = await HttpRequest.GetHttpRequest(args.Socket);
if (request == null)
{
return;
}
_log.Info("Received request from {0}: {1}", socket.Information.RemoteAddress.DisplayName, request.Uri.PathAndQuery);
RequestReceived.Raise(this, new HttpRequestEventArgs(request));
}
/// <summary>
/// Handles the http request received through Trouter
/// </summary>
/// <param name="requestReceived">Http request to be processed</param>
/// <returns><see cref="HttpResponseMessage"/> to be sent in response of the request</returns>
private async Task <HttpResponseMessage> ProcessIncomingTrouterRequestAsync(RequestReceived requestReceived)
{
try
{
m_logger.Information("Incoming callback\r\n " + requestReceived.Body);
var message = new SerializableHttpRequestMessage();
message.Method = requestReceived.HttpMethod;
message.Uri = requestReceived.RelativeUri;
message.LoggingContext = new LoggingContext(Guid.NewGuid());
message.Content = requestReceived.Body;
message.ContentType = "application/json";
message.IsIncoming = true;
message.Timestamp = DateTime.UtcNow;
if (requestReceived.Headers != null)
{
message.RequestHeaders = new List <Tuple <string, string> >();
foreach (KeyValuePair <string, string> header in requestReceived.Headers)
{
if (!string.IsNullOrEmpty(header.Key) && !string.IsNullOrEmpty(header.Value))
{
message.RequestHeaders.Add(new Tuple <string, string>(header.Key, header.Value));
}
}
}
// Suppress the warning
await Task.CompletedTask.ConfigureAwait(false);
// Pass down the response to event channel
HandleIncomingEvents?.Invoke(this, new EventsChannelArgs(message));
}
catch (Exception ex)
{
Debug.Assert(false, "unexpected exception: " + ex.ToString());
}
return(new HttpResponseMessage(HttpStatusCode.OK));
}
private void OnApiRequestReceived(HttpContext context)
{
IApiCall apiCall = CreateApiContext(context);
if (apiCall == null)
{
context.Response.StatusCode = HttpStatusCode.BadRequest;
return;
}
var eventArgs = new ApiRequestReceivedEventArgs(apiCall);
RequestReceived?.Invoke(this, eventArgs);
if (!eventArgs.IsHandled)
{
context.Response.StatusCode = HttpStatusCode.BadRequest;
return;
}
context.Response.StatusCode = HttpStatusCode.Ok;
if (eventArgs.ApiContext.Result == null)
{
eventArgs.ApiContext.Result = new JObject();
}
var apiResponse = new ApiResponse
{
ResultCode = apiCall.ResultCode,
Result = apiCall.Result,
ResultHash = apiCall.ResultHash
};
var json = JsonConvert.SerializeObject(apiResponse);
context.Response.Body = Encoding.UTF8.GetBytes(json);
context.Response.MimeType = MimeTypeProvider.Json;
}
private void DistpachMessage(object sender, MessageReceivedEventArgs e)
{
Stopwatch processingStopwatch = Stopwatch.StartNew();
string uri = e.Body.GetNamedString("Uri", string.Empty);
if (string.IsNullOrEmpty(uri))
{
Log.Warning("Received Azure queue message with missing or invalid URI property.");
return;
}
string callTypeSource = e.Body.GetNamedString("CallType", string.Empty);
ApiCallType callType;
if (!Enum.TryParse(callTypeSource, true, out callType))
{
Log.Warning("Received Azure queue message with missing or invalid CallType property.");
return;
}
var request = e.Body.GetNamedObject("Content", new JsonObject());
var context = new QueueBasedApiContext(e.BrokerProperties, e.Body, processingStopwatch, callType, uri, request, new JsonObject());
var eventArgs = new ApiRequestReceivedEventArgs(context);
RequestReceived?.Invoke(this, eventArgs);
if (!eventArgs.IsHandled)
{
Log.Warning("Received Azure queue message is not handled.");
Log.Warning("Received Azure queue message is not handled.");
return;
}
SendResponseMessage(context).Wait();
}
private void Listen()
{
Log.F("Listening thread started.", "http_server.log");
while (_listening)
{
try
{
var ctx = _server.GetContext();
using (var reader = new StreamReader(ctx.Request.InputStream, ctx.Request.ContentEncoding))
{
var stringReq = reader.ReadToEnd();
var jsonReq = JObject.Parse(stringReq);
if (jsonReq.ContainsKey(Request.MethodKey))
{
RequestReceived?.Invoke(new Request(jsonReq));
}
else if (jsonReq.ContainsKey(Response.ErrorKey) || jsonReq.ContainsKey(Response.ResultKey))
{
ResponseReceived?.Invoke(new Response(jsonReq));
}
else
{
Log.CW("[Server] Unknown message type.");
}
ctx.Response.StatusCode = 200;
ctx.Response.Close();
}
}
catch (Exception e)
{
Log.CW($"[Server] Error while parsing request: {e}");
Log.F($"Error while parsing request: {e}", "http_server.log");
}
}
Log.F("Exiting listening thread.", "http_server.log");
}
private async Task QueueListener_RequestReceived(object sender, RequestReceivedEventArgs e)
{
var iMessages = Counters.IncrementMessages();
try
{
Counters.IncrementReceivingTime(e.Request.Header.TotalTime);
if (_serverQueues?.AdditionalSendQueues?.Any() == true)
{
e.ResponseQueues.AddRange(_serverQueues.AdditionalSendQueues);
}
e.Response.Header.Response.Label = Config.ResponseOptions.ServerSenderOptions.Label;
Core.Log.InfoDetail("Request message received with CorrelationId = {0} . Current messages processing = {1}", e.Request.CorrelationId, iMessages);
if (RequestReceived != null)
{
await RequestReceived.InvokeAsync(sender, e).ConfigureAwait(false);
}
e.Response.Header.Response.Label = string.IsNullOrEmpty(e.Response.Header.Response.Label) ? e.Response.Body?.ToString() ?? typeof(ResponseMessage).FullName : e.Response.Header.Response.Label;
if (MQueueServerEvents.RequestReceived != null)
{
await MQueueServerEvents.RequestReceived.InvokeAsync(sender, e).ConfigureAwait(false);
}
if (e.SendResponse && e.Response?.Body != ResponseMessage.NoResponse)
{
e.Response.Header.Response.ApplicationSentDate = Core.Now;
ResponseSentEventArgs rsea = null;
if (BeforeSendResponse != null || MQueueServerEvents.BeforeSendResponse != null ||
ResponseSent != null || MQueueServerEvents.ResponseSent != null)
{
rsea = new ResponseSentEventArgs(Name, e.Response);
if (BeforeSendResponse != null)
{
await BeforeSendResponse.InvokeAsync(this, rsea).ConfigureAwait(false);
}
if (MQueueServerEvents.BeforeSendResponse != null)
{
await MQueueServerEvents.BeforeSendResponse.InvokeAsync(this, rsea).ConfigureAwait(false);
}
}
var sentBytes = await OnSendAsync(e.Response, e).ConfigureAwait(false);
if (sentBytes > -1)
{
if (rsea != null)
{
rsea.MessageLength = sentBytes;
if (ResponseSent != null)
{
await ResponseSent.InvokeAsync(this, rsea).ConfigureAwait(false);
}
if (MQueueServerEvents.ResponseSent != null)
{
await MQueueServerEvents.ResponseSent.InvokeAsync(this, rsea).ConfigureAwait(false);
}
}
}
else
{
Core.Log.Warning("The message couldn't be sent.");
}
}
Counters.DecrementMessages();
Counters.IncrementTotalMessagesProccesed();
}
catch (Exception)
{
Counters.IncrementTotalExceptions();
Counters.DecrementMessages();
throw;
}
}
protected virtual void OnRequestReceived(HttpListenerContext context)
{
RequestReceived?.Invoke(this, new EventArgs <HttpListenerContext>(context));
}
protected virtual void OnRequestReceived(HttpServerEventArgs <TContext> e)
{
RequestReceived?.Invoke(this, e);
}
/// <summary>
/// Processes a request message.
/// </summary>
private bool ProcessRequestMessage(uint messageType, ArraySegment <byte> messageChunk)
{
// validate the channel state.
if (State != TcpChannelState.Open)
{
ForceChannelFault(StatusCodes.BadTcpMessageTypeInvalid, "Client sent an unexpected request message.");
return(false);
}
// validate security on the message.
ChannelToken token = null;
uint requestId = 0;
uint sequenceNumber = 0;
ArraySegment <byte> messageBody;
try
{
messageBody = ReadSymmetricMessage(messageChunk, true, out token, out requestId, out sequenceNumber);
// check for replay attacks.
if (!VerifySequenceNumber(sequenceNumber, "ProcessRequestMessage"))
{
throw new ServiceResultException(StatusCodes.BadSequenceNumberInvalid);
}
if (token == CurrentToken && PreviousToken != null && !PreviousToken.Expired)
{
Utils.Trace("Server Revoked Token. ChannelId={1}, TokenId={0}", PreviousToken.TokenId, PreviousToken.ChannelId, DateTime.UtcNow);
PreviousToken.Lifetime = 0;
}
}
catch (Exception e)
{
Utils.Trace("Could not verify security on incoming request.");
ForceChannelFault(e, StatusCodes.BadSecurityChecksFailed, "Could not verify security on incoming request.");
return(false);
}
BufferCollection chunksToProcess = null;
try
{
// check for an abort.
if (TcpMessageType.IsAbort(messageType))
{
Utils.Trace("Request was aborted.");
chunksToProcess = GetSavedChunks(requestId, messageBody);
return(true);
}
// check if it is necessary to wait for more chunks.
if (!TcpMessageType.IsFinal(messageType))
{
SaveIntermediateChunk(requestId, messageBody);
return(true);
}
Utils.Trace("Channel {0}: ProcessRequestMessage {1}", ChannelId, requestId);
// get the chunks to process.
chunksToProcess = GetSavedChunks(requestId, messageBody);
// decode the request.
IServiceRequest request = BinaryDecoder.DecodeMessage(new ArraySegmentStream(chunksToProcess), null, Quotas.MessageContext) as IServiceRequest;
if (request == null)
{
SendServiceFault(token, requestId, ServiceResult.Create(StatusCodes.BadStructureMissing, "Could not parse request body."));
return(true);
}
// ensure that only discovery requests come through unsecured.
if (DiscoveryOnly)
{
if (!(request is GetEndpointsRequest || request is FindServersRequest))
{
SendServiceFault(token, requestId, ServiceResult.Create(StatusCodes.BadSecurityPolicyRejected, "Channel can only be used for discovery."));
return(true);
}
}
// hand the request to the server.
RequestReceived?.Invoke(this, requestId, request);
return(true);
}
catch (Exception e)
{
Utils.Trace(e, "Unexpected error processing request.");
SendServiceFault(token, requestId, ServiceResult.Create(e, StatusCodes.BadTcpInternalError, "Unexpected error processing request."));
return(true);
}
finally
{
if (chunksToProcess != null)
{
chunksToProcess.Release(BufferManager, "ProcessRequestMessage");
}
}
}
private void OnRequestCompleted(object source, EventArgs args)
{
TriggerKeepalive = false;
MonitorKeepaliveStartMS = 0;
FullRequestReceived = true;
LastActivityTimeMS = ContextTimeoutManager.EnvironmentTickCount();
if (m_maxRequests == 0)
{
return;
}
if (--m_maxRequests == 0)
{
m_currentRequest.Connection = ConnectionType.Close;
}
if (m_currentRequest.Uri == null)
{
// should not happen
try
{
Uri uri = new Uri(m_currentRequest.Secure ? "https://" : "http://" + m_currentRequest.UriPath);
m_currentRequest.Uri = uri;
m_currentRequest.UriPath = uri.AbsolutePath;
}
catch
{
return;
}
}
// load cookies if they exist
if (m_currentRequest.Headers["cookie"] != null)
{
m_currentRequest.SetCookies(new RequestCookies(m_currentRequest.Headers["cookie"]));
}
m_currentRequest.Body.Seek(0, SeekOrigin.Begin);
bool donow = true;
lock (m_requestsLock)
{
if (m_waitingResponse)
{
m_requests.Enqueue(m_currentRequest);
donow = false;
}
else
{
m_waitingResponse = true;
}
}
if (donow)
{
RequestReceived?.Invoke(this, new RequestEventArgs(m_currentRequest));
}
m_currentRequest = new HttpRequest(this);
}
protected virtual void OnRequestReceived(RequestReceivedArgs <TMessage> e)
{
RequestReceived?.Invoke(this, e);
}
private void OnRequestReceived(object sender, RequestEventArgs e)
{
RequestReceived?.Invoke(sender, e);
}
