Files
dotnet-bot adf899c629 Adding System.Data..., System.ServiceModel..., and System.Web...
Adding reference source for
System.Data
System.Data.DataSetExtensions
System.Data.Entity
System.Data.Entity.Design
System.Data.Linq
System.Data.SqlXml
System.ServiceModel
System.ServiceModel.Activation
System.ServiceModel.Activities
System.ServiceModel.Channels
System.ServiceModel.Discovery
System.ServiceModel.Internals
System.ServiceModel.Routing
System.ServiceModel.WasHosting
System.ServiceModel.Web
System.Web
System.Web.ApplicationServices
System.Web.DynamicData
System.Web.Entity
System.Web.Entity.Design
System.Web.Extensions
System.Web.Mobile
System.Web.Routing
System.Web.Services
System.Xml
System.Xml.Linq
2016-05-03 00:07:37 +02:00

290 lines
10 KiB
C#

//------------------------------------------------------------------------------
// <copyright file="RequestQueue.cs" company="Microsoft">
// Copyright (c) Microsoft Corporation. All rights reserved.
// </copyright>
//------------------------------------------------------------------------------
//
// Request Queue
// queues up the requests to avoid thread pool starvation,
// making sure that there are always available threads to process requests
//
namespace System.Web {
using System.Threading;
using System.Collections;
using System.Web.Util;
using System.Web.Hosting;
using System.Web.Configuration;
internal class RequestQueue {
// configuration params
private int _minExternFreeThreads;
private int _minLocalFreeThreads;
private int _queueLimit;
private TimeSpan _clientConnectedTime;
private bool _iis6;
// two queues -- one for local requests, one for external
private Queue _localQueue = new Queue();
private Queue _externQueue = new Queue();
// total count
private int _count;
// work items queued to pick up new work
private WaitCallback _workItemCallback;
private int _workItemCount;
private const int _workItemLimit = 2;
private bool _draining;
// timer to drain the queue
private readonly TimeSpan _timerPeriod = new TimeSpan(0, 0, 10); // 10 seconds
private Timer _timer;
// helpers
private static bool IsLocal(HttpWorkerRequest wr) {
String remoteAddress = wr.GetRemoteAddress();
// check if localhost
if (remoteAddress == "127.0.0.1" || remoteAddress == "::1")
return true;
// if unknown, assume not local
if (String.IsNullOrEmpty(remoteAddress))
return false;
// compare with local address
if (remoteAddress == wr.GetLocalAddress())
return true;
return false;
}
private void QueueRequest(HttpWorkerRequest wr, bool isLocal) {
lock (this) {
if (isLocal) {
_localQueue.Enqueue(wr);
}
else {
_externQueue.Enqueue(wr);
}
_count++;
}
PerfCounters.IncrementGlobalCounter(GlobalPerfCounter.REQUESTS_QUEUED);
PerfCounters.IncrementCounter(AppPerfCounter.REQUESTS_IN_APPLICATION_QUEUE);
if (EtwTrace.IsTraceEnabled(EtwTraceLevel.Information, EtwTraceFlags.Infrastructure)) EtwTrace.Trace(EtwTraceType.ETW_TYPE_REQ_QUEUED, wr);
}
private HttpWorkerRequest DequeueRequest(bool localOnly) {
HttpWorkerRequest wr = null;
while (_count > 0) {
lock (this) {
if (_localQueue.Count > 0) {
wr = (HttpWorkerRequest)_localQueue.Dequeue();
_count--;
}
else if (!localOnly && _externQueue.Count > 0) {
wr = (HttpWorkerRequest)_externQueue.Dequeue();
_count--;
}
}
if (wr == null) {
break;
}
else {
PerfCounters.DecrementGlobalCounter(GlobalPerfCounter.REQUESTS_QUEUED);
PerfCounters.DecrementCounter(AppPerfCounter.REQUESTS_IN_APPLICATION_QUEUE);
if (EtwTrace.IsTraceEnabled(EtwTraceLevel.Information, EtwTraceFlags.Infrastructure)) EtwTrace.Trace(EtwTraceType.ETW_TYPE_REQ_DEQUEUED, wr);
if (!CheckClientConnected(wr)) {
HttpRuntime.RejectRequestNow(wr, true);
wr = null;
PerfCounters.IncrementGlobalCounter(GlobalPerfCounter.REQUESTS_DISCONNECTED);
PerfCounters.IncrementCounter(AppPerfCounter.APP_REQUEST_DISCONNECTED);
}
else {
break;
}
}
}
return wr;
}
// This method will check to see if the client is still connected.
// The checks are only done if it's an in-proc Isapi request AND the request has been waiting
// more than the configured clientConenctedCheck time.
private bool CheckClientConnected(HttpWorkerRequest wr) {
if (DateTime.UtcNow - wr.GetStartTime() > _clientConnectedTime)
return wr.IsClientConnected();
else
return true;
}
// ctor
internal RequestQueue(int minExternFreeThreads, int minLocalFreeThreads, int queueLimit, TimeSpan clientConnectedTime) {
_minExternFreeThreads = minExternFreeThreads;
_minLocalFreeThreads = minLocalFreeThreads;
_queueLimit = queueLimit;
_clientConnectedTime = clientConnectedTime;
_workItemCallback = new WaitCallback(this.WorkItemCallback);
_timer = new Timer(new TimerCallback(this.TimerCompletionCallback), null, _timerPeriod, _timerPeriod);
_iis6 = HostingEnvironment.IsUnderIIS6Process;
// set the minimum number of requests that must be executing in order to detect a deadlock
int maxWorkerThreads, maxIoThreads;
ThreadPool.GetMaxThreads(out maxWorkerThreads, out maxIoThreads);
UnsafeNativeMethods.SetMinRequestsExecutingToDetectDeadlock(maxWorkerThreads - minExternFreeThreads);
}
// method called from HttpRuntime for incoming requests
internal HttpWorkerRequest GetRequestToExecute(HttpWorkerRequest wr) {
int workerThreads, ioThreads;
ThreadPool.GetAvailableThreads(out workerThreads, out ioThreads);
int freeThreads;
if (_iis6)
freeThreads = workerThreads; // ignore IO threads to avoid starvation from Indigo TCP requests
else
freeThreads = (ioThreads > workerThreads) ? workerThreads : ioThreads;
// fast path when there are threads available and nothing queued
if (freeThreads >= _minExternFreeThreads && _count == 0)
return wr;
bool isLocal = IsLocal(wr);
// fast path when there are threads for local requests available and nothing queued
if (isLocal && freeThreads >= _minLocalFreeThreads && _count == 0)
return wr;
// reject if queue limit exceeded
if (_count >= _queueLimit) {
HttpRuntime.RejectRequestNow(wr, false);
return null;
}
// can't execute the current request on the current thread -- need to queue
QueueRequest(wr, isLocal);
// maybe can execute a request previously queued
if (freeThreads >= _minExternFreeThreads) {
wr = DequeueRequest(false); // enough threads to process even external requests
}
else if (freeThreads >= _minLocalFreeThreads) {
wr = DequeueRequest(true); // enough threads to process only local requests
}
else {
wr = null; // not enough threads -> do nothing on this thread
ScheduleMoreWorkIfNeeded(); // try to schedule to worker thread
}
return wr;
}
// method called from HttpRuntime at the end of request
internal void ScheduleMoreWorkIfNeeded() {
// too late for more work if draining
if (_draining)
return;
// is queue empty?
if (_count == 0)
return;
// already scheduled enough work items
if (_workItemCount >= _workItemLimit)
return;
// enough worker threads?
int workerThreads, ioThreads;
ThreadPool.GetAvailableThreads(out workerThreads, out ioThreads);
if (workerThreads < _minLocalFreeThreads)
return;
// queue the work item
Interlocked.Increment(ref _workItemCount);
ThreadPool.QueueUserWorkItem(_workItemCallback);
}
// is empty property
internal bool IsEmpty {
get { return (_count == 0); }
}
// method called to pick up more work
private void WorkItemCallback(Object state) {
Interlocked.Decrement(ref _workItemCount);
// too late for more work if draining
if (_draining)
return;
// is queue empty?
if (_count == 0)
return;
int workerThreads, ioThreads;
ThreadPool.GetAvailableThreads(out workerThreads, out ioThreads);
// not enough worker threads to do anything
if (workerThreads < _minLocalFreeThreads)
return;
// pick up request from the queue
HttpWorkerRequest wr = DequeueRequest(workerThreads < _minExternFreeThreads);
if (wr == null)
return;
// let another work item through before processing the request
ScheduleMoreWorkIfNeeded();
// call the runtime to process request
HttpRuntime.ProcessRequestNow(wr);
}
// periodic timer to pick up more work
private void TimerCompletionCallback(Object state) {
ScheduleMoreWorkIfNeeded();
}
// reject all requests
internal void Drain() {
// set flag before killing timer to shorten the code path
// in the callback after the timer is disposed
_draining = true;
// stop the timer
if (_timer != null) {
((IDisposable)_timer).Dispose();
_timer = null;
}
// wait for all work items to finish
while (_workItemCount > 0)
Thread.Sleep(100);
// is queue empty?
if (_count == 0)
return;
// reject the remaining requests
for (;;) {
HttpWorkerRequest wr = DequeueRequest(false);
if (wr == null)
break;
HttpRuntime.RejectRequestNow(wr, false);
}
}
}
}