internal IAsyncResult BeginGetRunspace(AsyncCallback callback, object state) { this.AssertPoolIsOpen(); GetRunspaceAsyncResult requestToEnqueue = new GetRunspaceAsyncResult(this.InstanceId, callback, state); this.EnqueueCheckAndStartRequestServicingThread(requestToEnqueue, true); return(requestToEnqueue); }
public Runspace GetRunspace() { using (RunspacePoolInternal.tracer.TraceMethod()) { this.AssertPoolIsOpen(); GetRunspaceAsyncResult runspace = (GetRunspaceAsyncResult)this.BeginGetRunspace((AsyncCallback)null, (object)null); runspace.AsyncWaitHandle.WaitOne(); return(runspace.Exception == null ? runspace.Runspace : throw runspace.Exception); } }
public Runspace GetRunspace() { this.AssertPoolIsOpen(); GetRunspaceAsyncResult result = (GetRunspaceAsyncResult)this.BeginGetRunspace(null, null); result.AsyncWaitHandle.WaitOne(); if (result.Exception != null) { throw result.Exception; } return(result.Runspace); }
internal void CancelGetRunspace(IAsyncResult asyncResult) { if (asyncResult == null) { throw PSTraceSource.NewArgumentNullException("asyncResult"); } GetRunspaceAsyncResult result = asyncResult as GetRunspaceAsyncResult; if ((result == null) || (result.OwnerId != this.instanceId)) { throw PSTraceSource.NewArgumentException("asyncResult", resBaseName, "AsyncResultNotOwned", new object[] { "IAsyncResult", "BeginGetRunspace" }); } result.IsActive = false; }
internal Runspace EndGetRunspace(IAsyncResult asyncResult) { if (asyncResult == null) { throw PSTraceSource.NewArgumentNullException("asyncResult"); } GetRunspaceAsyncResult result = asyncResult as GetRunspaceAsyncResult; if ((result == null) || (result.OwnerId != this.instanceId)) { throw PSTraceSource.NewArgumentException("asyncResult", resBaseName, "AsyncResultNotOwned", new object[] { "IAsyncResult", "BeginGetRunspace" }); } result.EndInvoke(); return(result.Runspace); }
protected void EnqueueCheckAndStartRequestServicingThread(GetRunspaceAsyncResult requestToEnqueue, bool useCallingThread) { bool flag = false; lock (this.runspaceRequestQueue) { if (requestToEnqueue != null) { this.runspaceRequestQueue.Enqueue(requestToEnqueue); } if (this.isServicingRequests) { return; } if ((this.runspaceRequestQueue.Count + this.ultimateRequestQueue.Count) > 0) { lock (this.pool) { if ((this.pool.Count > 0) || (this.totalRunspaces < this.maxPoolSz)) { this.isServicingRequests = true; if (useCallingThread && (this.ultimateRequestQueue.Count == 0)) { flag = true; } else { ThreadPool.QueueUserWorkItem(new WaitCallback(this.ServicePendingRequests), false); } } } } } if (flag) { this.ServicePendingRequests(true); } }
/// <summary> /// Begin for obtaining a runspace for the specified ConnectionInfo /// </summary> /// <param name="connectionInfo">connection info to be used for remote connections</param> /// <param name="retryCount">number of times to retry</param> /// <param name="callback">optional user defined callback</param> /// <param name="state">optional user specified state</param> /// <param name="retryInterval">time in milliseconds before the next retry has to be attempted</param> /// <returns>async result</returns> public override IAsyncResult BeginGetRunspace(WSManConnectionInfo connectionInfo, uint retryCount, uint retryInterval, AsyncCallback callback, object state) { GetRunspaceAsyncResult result = new GetRunspaceAsyncResult(state, callback, Guid.Empty); // Create a Request Object and queue the same RequestInfo requestInfo = new RequestInfo { ConnectionInfo = connectionInfo, RetryCount = retryCount, AsyncResult = result, RetryInterval = retryInterval }; _tracer.WriteMessage("PSW ConnMgr: New incoming request for runspace queued"); _inComingRequests.Enqueue(requestInfo); _perfCountersMgr.UpdateCounterByValue( PSWorkflowPerformanceCounterSetInfo.CounterSetId, PSWorkflowPerformanceCounterIds.PSRemotingPendingRequestsQueueLength); // start servicing thread if required CheckAndStartRequiredThreads(); return result; }
internal void AddToPendingCallback(GetRunspaceAsyncResult asyncResult) { _callbacks.Enqueue(asyncResult); CheckAndStartCallbackServicingThread(); }
/// <summary> /// Gets Runspace asynchronously from the runspace pool. The caller /// will get notified with the runspace using <paramref name="callback"/> /// </summary> /// <param name="callback"> /// A AsyncCallback to call once the runspace is available. /// </param> /// <param name="state"> /// A user supplied state to call the <paramref name="callback"/> /// with. /// </param> /// <returns> /// An IAsyncResult object to track the status of the Async operation. /// </returns> internal IAsyncResult BeginGetRunspace( AsyncCallback callback, object state) { AssertPoolIsOpen(); GetRunspaceAsyncResult asyncResult = new GetRunspaceAsyncResult(this.InstanceId, callback, state); // Enqueue and start servicing thread in one go..saving multiple locks. EnqueueCheckAndStartRequestServicingThread(asyncResult, true); return asyncResult; }
/// <summary> /// If <paramref name="requestToEnqueue"/> is not null, enqueues the request. /// Checks if a thread pool thread is queued to service pending requests /// for runspace. If a thread is not queued, queues one. /// </summary> /// <param name="requestToEnqueue"> /// Used by calling threads to queue a request before checking and starting /// servicing thread. /// </param> /// <param name="useCallingThread"> /// uses calling thread to assign available runspaces (if any) to runspace /// requesters. /// </param> protected void EnqueueCheckAndStartRequestServicingThread(GetRunspaceAsyncResult requestToEnqueue, bool useCallingThread) { bool shouldStartServicingInSameThread = false; lock (runspaceRequestQueue) { if (requestToEnqueue != null) { runspaceRequestQueue.Enqueue(requestToEnqueue); } // if a thread is already servicing requests..just return. if (isServicingRequests) { return; } if ((runspaceRequestQueue.Count + ultimateRequestQueue.Count) > 0) { // we have requests pending..check if a runspace is available to // service the requests. lock (pool) { if ((pool.Count > 0) || (totalRunspaces < maxPoolSz)) { isServicingRequests = true; if ((useCallingThread) && (ultimateRequestQueue.Count == 0)) { shouldStartServicingInSameThread = true; } else { // release a async result object using a thread pool thread. // this way the calling thread will not block. ThreadPool.QueueUserWorkItem(new WaitCallback(ServicePendingRequests), false); } } } } } // only one thread will be here if any.. // This will allow us to release lock. if (shouldStartServicingInSameThread) { ServicePendingRequests(true); } }
protected void ServicePendingRequests(object useCallingThreadState) { if ((this.stateInfo.State == RunspacePoolState.Closed) || (this.stateInfo.State == RunspacePoolState.Closing)) { return; } bool flag = (bool)useCallingThreadState; GetRunspaceAsyncResult result = null; try { bool flag4; Queue <GetRunspaceAsyncResult> queue = null; Label_0026: flag4 = false; try { Monitor.Enter(queue = this.ultimateRequestQueue, ref flag4); while (this.ultimateRequestQueue.Count > 0) { Runspace runspace; if (this.stateInfo.State == RunspacePoolState.Closing) { return; } lock (this.pool) { if (this.pool.Count > 0) { runspace = this.pool.Pop(); } else { if (this.totalRunspaces >= this.maxPoolSz) { return; } runspace = this.CreateRunspace(); } } result = this.ultimateRequestQueue.Dequeue(); if (!result.IsActive) { lock (this.pool) { this.pool.Push(runspace); } result.Release(); } else { result.Runspace = runspace; if (flag) { goto Label_01B9; } ThreadPool.QueueUserWorkItem(new WaitCallback(result.DoComplete)); } } } finally { if (flag4) { Monitor.Exit(queue); } } lock (this.runspaceRequestQueue) { if (this.runspaceRequestQueue.Count != 0) { goto Label_0167; } goto Label_01B9; Label_0151: this.ultimateRequestQueue.Enqueue(this.runspaceRequestQueue.Dequeue()); Label_0167: if (this.runspaceRequestQueue.Count > 0) { goto Label_0151; } goto Label_0026; } } finally { lock (this.runspaceRequestQueue) { this.isServicingRequests = false; this.EnqueueCheckAndStartRequestServicingThread(null, false); } } Label_01B9: if (flag && (result != null)) { result.DoComplete(null); } }
public override IAsyncResult BeginGetRunspace(WSManConnectionInfo connectionInfo, uint retryCount, uint retryInterval, AsyncCallback callback, object state) { GetRunspaceAsyncResult getRunspaceAsyncResult = new GetRunspaceAsyncResult(state, callback, Guid.Empty); ConnectionManager.RequestInfo requestInfo = new ConnectionManager.RequestInfo(); requestInfo.ConnectionInfo = connectionInfo; requestInfo.RetryCount = retryCount; requestInfo.AsyncResult = getRunspaceAsyncResult; requestInfo.RetryInterval = retryInterval; ConnectionManager.RequestInfo requestInfo1 = requestInfo; this._tracer.WriteMessage("PSW ConnMgr: New incoming request for runspace queued"); this._inComingRequests.Enqueue(requestInfo1); ConnectionManager._perfCountersMgr.UpdateCounterByValue(PSWorkflowPerformanceCounterSetInfo.CounterSetId, 24, (long)1, true); this.CheckAndStartRequiredThreads(); return getRunspaceAsyncResult; }