internal void ReturnSocket(SocketHandler socket) { TimeSpan span = (TimeSpan) (DateTime.UtcNow - socket.CreationTime); bool flag = false; lock (this) { if ((this._socketCachePolicy != SocketCachePolicy.AbsoluteTimeout) || (span < this._socketLifetime)) { for (CachedSocket socket2 = this._socketList; socket2 != null; socket2 = socket2.Next) { if (socket == socket2.Handler) { return; } } this._socketList = new CachedSocket(socket, this._socketList); this._socketCount++; } else { flag = true; } } if (flag) { socket.Close(); } }
// reject all requests internal void Drain() { _draining = true; // wait for all work items to finish while (_workItemCount > 0) { Thread.Sleep(100); } // is queue empty? if (_count == 0) { return; } for (;;) { SocketHandler sh = DequeueRequest(false); if (sh == null) { break; } sh.RejectRequestNowSinceServerIsBusy(); } }
// method called to process the next request internal void ProcessNextRequest(SocketHandler sh) { sh = GetRequestToExecute(sh); if (sh != null) sh.ProcessRequestNow(); } // ProcessNextRequest
} // CachedSocketList internal SocketHandler GetSocket() { if (_socketCount == 0) { return(null); } lock (this) { if (_socketList != null) { SocketHandler socket = _socketList.Handler; _socketList = _socketList.Next; bool bRes = socket.RaceForControl(); // We should always have control since there shouldn't // be contention here. InternalRemotingServices.RemotingAssert(bRes, "someone else has the socket?"); _socketCount--; return(socket); } } return(null); } // GetSocket
} // GetSocket internal void ReturnSocket(SocketHandler socket) { TimeSpan socketActiveTime = DateTime.UtcNow - socket.CreationTime; bool closeSocket = false; lock (this) { // Check if socket active time has exceeded the lifetime // If it has just close the Socket if (_socketCachePolicy != SocketCachePolicy.AbsoluteTimeout || socketActiveTime < _socketLifetime) { // Ignore duplicate entries for the same socket handler for (CachedSocket curr = _socketList; curr != null; curr = curr.Next) { if (socket == curr.Handler) { return; } } _socketList = new CachedSocket(socket, _socketList); _socketCount++; } else { closeSocket = true; } } if (closeSocket) { socket.Close(); } } // ReturnSocket
// method called to pick up more work private void WorkItemCallback(Object state) { Interlocked.Decrement(ref _workItemCount); // is queue empty? if (_count == 0) { return; } int workerThreads, ioThreads; ThreadPool.GetAvailableThreads(out workerThreads, out ioThreads); bool bHandledRequest = false; // service another request if enough worker threads are available if (workerThreads >= _minLocalFreeThreads) { // pick up request from the queue SocketHandler sh = DequeueRequest(workerThreads < _minExternFreeThreads); if (sh != null) { sh.ProcessRequestNow(); bHandledRequest = true; } } if (!bHandledRequest) { Thread.Sleep(250); ScheduleMoreWorkIfNeeded(); } }
private void WorkItemCallback(object state) { Interlocked.Decrement(ref this._workItemCount); if (this._count != 0) { int num; int num2; ThreadPool.GetAvailableThreads(out num, out num2); bool flag = false; if (num >= this._minLocalFreeThreads) { SocketHandler handler = this.DequeueRequest(num < this._minExternFreeThreads); if (handler != null) { handler.ProcessRequestNow(); flag = true; } } if (!flag) { Thread.Sleep(250); this.ScheduleMoreWorkIfNeeded(); } } }
internal CachedSocket(SocketHandler socket, CachedSocket next) { _socket = socket; _socketLastUsed = DateTime.Now; _next = next; } // CachedSocket
internal void ProcessNextRequest(SocketHandler sh) { sh = this.GetRequestToExecute(sh); if (sh != null) { sh.ProcessRequestNow(); } }
} // GetSocket internal void ReturnSocket(SocketHandler socket) { lock (this) { _socketList = new CachedSocket(socket, _socketList); _socketCount++; } } // ReturnSocket
private void QueueRequest(SocketHandler sh, bool isLocal) { lock (this) { if (isLocal) _localQueue.Enqueue(sh); else _externQueue.Enqueue(sh); _count++; } }
internal SocketHandler GetSocket() { SocketHandler socket = this._cachedSocketList.GetSocket(); if (socket != null) { return(socket); } return(this.CreateNewSocket()); }
public void ReleaseSocket(string machinePortAndSid, SocketHandler socket) { RemoteConnection connection = (RemoteConnection) _connections[machinePortAndSid]; if (connection != null) { connection.ReleaseSocket(socket); } else { socket.Close(); } }
} // ProcessNextRequest // method called when data arrives for incoming requests internal SocketHandler GetRequestToExecute(SocketHandler sh) { int workerThreads, ioThreads; ThreadPool.GetAvailableThreads(out workerThreads, out ioThreads); int freeThreads = (ioThreads > workerThreads) ? workerThreads : ioThreads; // fast path when there are threads available and nothing queued if (freeThreads >= _minExternFreeThreads && _count == 0) { return(sh); } bool isLocal = IsLocal(sh); // fast path when there are threads for local requests available and nothing queued if (isLocal && freeThreads >= _minLocalFreeThreads && _count == 0) { return(sh); } // reject if queue limit exceeded if (_count >= _queueLimit) { sh.RejectRequestNowSinceServerIsBusy(); return(null); } // can't execute the current request on the current thread -- need to queue QueueRequest(sh, isLocal); // maybe can execute a request previously queued if (freeThreads >= _minExternFreeThreads) { sh = DequeueRequest(false); // enough threads to process even external requests } else if (freeThreads >= _minLocalFreeThreads) { sh = DequeueRequest(true); // enough threads to process only local requests } else { sh = null; } if (sh == null) // not enough threads -> do nothing on this thread { ScheduleMoreWorkIfNeeded(); // try to schedule to worker thread } return(sh); }
public void ReleaseSocket(string machinePortAndSid, SocketHandler socket) { RemoteConnection connection = (RemoteConnection)_connections[machinePortAndSid]; if (connection != null) { connection.ReleaseSocket(socket); } else { socket.Close(); } }
} // RemoteConnection internal SocketHandler GetSocket() { // try the cached socket list SocketHandler socketHandler = _cachedSocketList.GetSocket(); if (socketHandler != null) { return(socketHandler); } // Otherwise, we'll just create a new one. return(CreateNewSocket()); } // GetSocket
} // GetSocket public void ReleaseSocket(String machinePortAndSid, SocketHandler socket) { RemoteConnection connection = (RemoteConnection)_connections[machinePortAndSid]; if (connection != null) { connection.ReleaseSocket(socket); } else { // there should have been a connection, so let's just close // this socket. socket.Close(); } } // ReleaseSocket
private void QueueRequest(SocketHandler sh, bool isLocal) { lock (this) { if (isLocal) { _localQueue.Enqueue(sh); } else { _externQueue.Enqueue(sh); } _count++; } }
internal SocketHandler GetSocket() { if (this._socketCount != 0) { lock (this) { if (this._socketList != null) { SocketHandler handler = this._socketList.Handler; this._socketList = this._socketList.Next; handler.RaceForControl(); this._socketCount--; return handler; } } } return null; }
internal SocketHandler GetRequestToExecute(SocketHandler sh) { int num; int num2; ThreadPool.GetAvailableThreads(out num, out num2); int num3 = (num2 > num) ? num : num2; if ((num3 < this._minExternFreeThreads) || (this._count != 0)) { bool isLocal = IsLocal(sh); if ((isLocal && (num3 >= this._minLocalFreeThreads)) && (this._count == 0)) { return(sh); } if (this._count >= this._queueLimit) { sh.RejectRequestNowSinceServerIsBusy(); return(null); } this.QueueRequest(sh, isLocal); if (num3 >= this._minExternFreeThreads) { sh = this.DequeueRequest(false); } else if (num3 >= this._minLocalFreeThreads) { sh = this.DequeueRequest(true); } else { sh = null; } if (sh == null) { this.ScheduleMoreWorkIfNeeded(); } } return(sh); }
internal SocketHandler GetRequestToExecute(SocketHandler sh) { int num; int num2; ThreadPool.GetAvailableThreads(out num, out num2); int num3 = (num2 > num) ? num : num2; if ((num3 < this._minExternFreeThreads) || (this._count != 0)) { bool isLocal = IsLocal(sh); if ((isLocal && (num3 >= this._minLocalFreeThreads)) && (this._count == 0)) { return sh; } if (this._count >= this._queueLimit) { sh.RejectRequestNowSinceServerIsBusy(); return null; } this.QueueRequest(sh, isLocal); if (num3 >= this._minExternFreeThreads) { sh = this.DequeueRequest(false); } else if (num3 >= this._minLocalFreeThreads) { sh = this.DequeueRequest(true); } else { sh = null; } if (sh == null) { this.ScheduleMoreWorkIfNeeded(); } } return sh; }
} // GetSocket internal void ReleaseSocket(SocketHandler socket) { socket.ReleaseControl(); _cachedSocketList.ReturnSocket(socket); } // ReleaseSocket
} // GetSocket public void ReleaseSocket(String machineAndPort, SocketHandler socket) { RemoteConnection connection = (RemoteConnection)_connections[machineAndPort]; if (connection != null) { connection.ReleaseSocket(socket); } else { // there should have been a connection, so let's just close // this socket. socket.Close(); } } // ReleaseSocket
} // GetSocket internal void ReturnSocket(SocketHandler socket) { lock (this) { _socketList = new CachedSocket(socket, _socketList); _socketCount++; } } // ReturnSocket
internal CachedSocket(SocketHandler socket, CachedSocket next) { this._socket = socket; this._socketLastUsed = DateTime.UtcNow; this._next = next; }
internal TcpFixedLengthReadingStream(SocketHandler inputStream, int contentLength) { this._inputStream = inputStream; this._bytesLeft = contentLength; }
} // GetSocket internal void ReturnSocket(SocketHandler socket) { TimeSpan socketActiveTime = DateTime.UtcNow - socket.CreationTime; bool closeSocket = false; lock (this) { // Check if socket active time has exceeded the lifetime // If it has just close the Socket if (_socketCachePolicy != SocketCachePolicy.AbsoluteTimeout || socketActiveTime < _socketLifetime) { // Ignore duplicate entries for the same socket handler for (CachedSocket curr = _socketList; curr != null; curr = curr.Next){ if (socket == curr.Handler) return; } _socketList = new CachedSocket(socket, _socketList); _socketCount++; } else { closeSocket = true; } } if(closeSocket) { socket.Close(); } } // ReturnSocket
} // ProcessNextRequest // method called when data arrives for incoming requests internal SocketHandler GetRequestToExecute(SocketHandler sh) { int workerThreads, ioThreads; ThreadPool.GetAvailableThreads(out workerThreads, out ioThreads); int freeThreads = (ioThreads > workerThreads) ? workerThreads : ioThreads; // fast path when there are threads available and nothing queued if (freeThreads >= _minExternFreeThreads && _count == 0) return sh; bool isLocal = IsLocal(sh); // fast path when there are threads for local requests available and nothing queued if (isLocal && freeThreads >= _minLocalFreeThreads && _count == 0) return sh; // reject if queue limit exceeded if (_count >= _queueLimit) { sh.RejectRequestNowSinceServerIsBusy(); return null; } // can't execute the current request on the current thread -- need to queue QueueRequest(sh, isLocal); // maybe can execute a request previously queued if (freeThreads >= _minExternFreeThreads) { sh = DequeueRequest(false); // enough threads to process even external requests } else if (freeThreads >= _minLocalFreeThreads) { sh = DequeueRequest(true); // enough threads to process only local requests } else{ sh = null; } if (sh == null){ // not enough threads -> do nothing on this thread ScheduleMoreWorkIfNeeded(); // try to schedule to worker thread } return sh; }
internal TcpChunkedReadingStream(SocketHandler inputStream) { this._inputStream = inputStream; this._bytesLeft = 0; }
// helpers private static bool IsLocal(SocketHandler sh) { return(sh.IsLocal()); }
// helpers private static bool IsLocal(SocketHandler sh) { return sh.IsLocal(); }
} // GetSocket internal void ReleaseSocket(SocketHandler socket) { socket.ReleaseControl(); _cachedSocketList.ReturnSocket(socket); } // ReleaseSocket
internal CachedSocket(SocketHandler socket, CachedSocket next) { _socket = socket; _socketLastUsed = DateTime.Now; _next = next; } // CachedSocket