public override IAsyncResult BeginDisconnect(AsyncCallback callback, object state) { RunspacePoolState state2; if (!this.CanDisconnect) { throw PSTraceSource.NewInvalidOperationException("RunspacePoolStrings", "DisconnectNotSupportedOnServer", new object[0]); } bool flag = false; lock (base.syncObject) { state2 = base.stateInfo.State; if (state2 == RunspacePoolState.Opened) { RunspacePoolStateInfo newStateInfo = new RunspacePoolStateInfo(RunspacePoolState.Disconnecting, null); this.SetRunspacePoolState(newStateInfo); flag = true; } } if (flag) { base.RaiseStateChangeEvent(base.stateInfo); } if (state2 == RunspacePoolState.Opened) { this.disconnectAsyncResult = new RunspacePoolAsyncResult(base.instanceId, callback, state, false); this.dataStructureHandler.DisconnectPoolAsync(); return(this.disconnectAsyncResult); } InvalidRunspacePoolStateException exception = new InvalidRunspacePoolStateException(StringUtil.Format(RunspacePoolStrings.InvalidRunspacePoolState, RunspacePoolState.Opened, base.stateInfo.State), base.stateInfo.State, RunspacePoolState.Opened); throw exception; }
protected void AssertIfStateIsBeforeOpen() { if (this.stateInfo.State != RunspacePoolState.BeforeOpen) { InvalidRunspacePoolStateException exception = new InvalidRunspacePoolStateException(StringUtil.Format(RunspacePoolStrings.CannotOpenAgain, new object[] { this.stateInfo.State.ToString() }), this.stateInfo.State, RunspacePoolState.BeforeOpen); throw exception; } }
internal override void StartOperation() { bool flag = true; Exception exception = null; try { if (this._queryRunspaces == null) { this._session.Runspace.ConnectAsync(); } else { PSSession pSSession = this.QueryForSession(this._session); if (pSSession == null) { flag = false; } else { this._session.Runspace.StateChanged -= new EventHandler <RunspaceStateEventArgs>(this.StateCallBackHandler); this._oldSession = this._session; this._session = pSSession; this._session.Runspace.StateChanged += new EventHandler <RunspaceStateEventArgs>(this.StateCallBackHandler); this._session.Runspace.ConnectAsync(); } } } catch (PSInvalidOperationException pSInvalidOperationException1) { PSInvalidOperationException pSInvalidOperationException = pSInvalidOperationException1; exception = pSInvalidOperationException; } catch (InvalidRunspacePoolStateException invalidRunspacePoolStateException1) { InvalidRunspacePoolStateException invalidRunspacePoolStateException = invalidRunspacePoolStateException1; exception = invalidRunspacePoolStateException; } catch (RuntimeException runtimeException1) { RuntimeException runtimeException = runtimeException1; exception = runtimeException; } if (exception != null) { flag = false; this.WriteConnectFailed(exception, this._session); } if (!flag) { this._session.Runspace.StateChanged -= new EventHandler <RunspaceStateEventArgs>(this.StateCallBackHandler); this.SendStartComplete(); } }
public override IAsyncResult BeginConnect(AsyncCallback callback, object state) { RunspacePoolState state2; if (!this.AvailableForConnection) { throw PSTraceSource.NewInvalidOperationException("RunspacePoolStrings", "CannotConnect", new object[0]); } bool flag = false; lock (base.syncObject) { state2 = base.stateInfo.State; if (state2 == RunspacePoolState.Disconnected) { RunspacePoolStateInfo newStateInfo = new RunspacePoolStateInfo(RunspacePoolState.Connecting, null); this.SetRunspacePoolState(newStateInfo); flag = true; } } if (flag) { base.RaiseStateChangeEvent(base.stateInfo); } flag = false; if (state2 == RunspacePoolState.Disconnected) { RunspacePoolAsyncResult reconnectAsyncResult; if (this.canReconnect) { this.dataStructureHandler.ReconnectPoolAsync(); this.reconnectAsyncResult = new RunspacePoolAsyncResult(base.instanceId, callback, state, false); reconnectAsyncResult = this.reconnectAsyncResult; } else { this.dataStructureHandler.ConnectPoolAsync(); this.openAsyncResult = new RunspacePoolAsyncResult(base.instanceId, callback, state, false); reconnectAsyncResult = this.openAsyncResult; } if (flag) { base.RaiseStateChangeEvent(base.stateInfo); } return(reconnectAsyncResult); } InvalidRunspacePoolStateException exception = new InvalidRunspacePoolStateException(StringUtil.Format(RunspacePoolStrings.InvalidRunspacePoolState, RunspacePoolState.Disconnected, base.stateInfo.State), base.stateInfo.State, RunspacePoolState.Disconnected); throw exception; }
private void InternalClearAllResources() { Exception exception = new InvalidRunspacePoolStateException(StringUtil.Format(RunspacePoolStrings.InvalidRunspacePoolState, RunspacePoolState.Opened, this.stateInfo.State), this.stateInfo.State, RunspacePoolState.Opened); lock (this.runspaceRequestQueue) { while (this.runspaceRequestQueue.Count > 0) { this.runspaceRequestQueue.Dequeue().SetAsCompleted(exception); } } lock (this.ultimateRequestQueue) { while (this.ultimateRequestQueue.Count > 0) { this.ultimateRequestQueue.Dequeue().SetAsCompleted(exception); } } List <Runspace> list = new List <Runspace>(); lock (this.runspaceList) { list.AddRange(this.runspaceList); this.runspaceList.Clear(); } for (int i = list.Count - 1; i >= 0; i--) { try { list[i].Close(); list[i].Dispose(); } catch (InvalidRunspaceStateException exception2) { CommandProcessorBase.CheckForSevereException(exception2); } } lock (this.pool) { this.pool.Clear(); } }
/// <summary> /// Throws an exception if the runspace state is not /// BeforeOpen /// </summary> protected void AssertIfStateIsBeforeOpen() { if (stateInfo.State != RunspacePoolState.BeforeOpen) { //Call fails if RunspacePoolState is not BeforeOpen. InvalidRunspacePoolStateException e = new InvalidRunspacePoolStateException ( StringUtil.Format(RunspacePoolStrings.CannotOpenAgain, new object[] { stateInfo.State.ToString() } ), stateInfo.State, RunspacePoolState.BeforeOpen ); throw e; } } // AssertIfStateIsBeforeOpen
/// <summary> /// Close all the runspaces in the pool /// </summary> private void InternalClearAllResources() { string message = StringUtil.Format(RunspacePoolStrings.InvalidRunspacePoolState, RunspacePoolState.Opened, stateInfo.State); Exception invalidStateException = new InvalidRunspacePoolStateException(message, stateInfo.State, RunspacePoolState.Opened); GetRunspaceAsyncResult runspaceRequester; // clear the request queue first..this way waiting threads // are immediately notified. lock (runspaceRequestQueue) { while (runspaceRequestQueue.Count > 0) { runspaceRequester = runspaceRequestQueue.Dequeue(); runspaceRequester.SetAsCompleted(invalidStateException); } } lock (ultimateRequestQueue) { while (ultimateRequestQueue.Count > 0) { runspaceRequester = ultimateRequestQueue.Dequeue(); runspaceRequester.SetAsCompleted(invalidStateException); } } // close all the runspaces List<Runspace> runspaceListCopy = new List<Runspace>(); lock (runspaceList) { runspaceListCopy.AddRange(runspaceList); runspaceList.Clear(); } //Start from the most recent runspace. for (int index = runspaceListCopy.Count - 1; index >= 0; index--) { // close runspaces suppress exceptions try { // this will release pipelines executing in the // runspace. runspaceListCopy[index].Close(); runspaceListCopy[index].Dispose(); } catch (InvalidRunspaceStateException e) { CommandProcessorBase.CheckForSevereException(e); } } lock (pool) { pool.Clear(); } // dont release pool/runspacelist/runspaceRequestQueue/ultimateRequestQueue as they // might be accessed in lock() statements from another thread. }
/// <summary> /// Asynchronous connect. /// </summary> /// <param name="callback">ASyncCallback object.</param> /// <param name="state">state Object.</param> /// <returns>IAsyncResult</returns> public override IAsyncResult BeginConnect(AsyncCallback callback, object state) { if (!AvailableForConnection) { throw PSTraceSource.NewInvalidOperationException(RunspacePoolStrings.CannotConnect); } RunspacePoolState currentState; bool raiseEvents = false; lock (syncObject) { currentState = stateInfo.State; if (currentState == RunspacePoolState.Disconnected) { RunspacePoolStateInfo newStateInfo = new RunspacePoolStateInfo(RunspacePoolState.Connecting, null); SetRunspacePoolState(newStateInfo); raiseEvents = true; } } // Raise events outside of lock. if (raiseEvents) { RaiseStateChangeEvent(this.stateInfo); } raiseEvents = false; if (currentState == RunspacePoolState.Disconnected) { // Assign to local variable to ensure we always pass a non-null value. // The async class members can be nulled out if the session closes suddenly. RunspacePoolAsyncResult ret = new RunspacePoolAsyncResult( instanceId, callback, state, false); if (_canReconnect) { // This indicates a reconnect scenario where this object instance was previously // disconnected. _reconnectAsyncResult = ret; DataStructureHandler.ReconnectPoolAsync(); } else { // This indicates a reconstruction scenario where this object was created // in the disconnect state and is being connected for the first time. _openAsyncResult = ret; DataStructureHandler.ConnectPoolAsync(); } if (raiseEvents) { RaiseStateChangeEvent(this.stateInfo); } return ret; } else { string message = StringUtil.Format(RunspacePoolStrings.InvalidRunspacePoolState, RunspacePoolState.Disconnected, stateInfo.State); InvalidRunspacePoolStateException invalidStateException = new InvalidRunspacePoolStateException(message, stateInfo.State, RunspacePoolState.Disconnected); throw invalidStateException; } }
/// <summary> /// Asynchronous disconnect. /// </summary> /// <param name="callback">AsyncCallback object.</param> /// <param name="state">state object.</param> /// <returns>IAsyncResult</returns> public override IAsyncResult BeginDisconnect(AsyncCallback callback, object state) { if (!CanDisconnect) { throw PSTraceSource.NewInvalidOperationException(RunspacePoolStrings.DisconnectNotSupportedOnServer); } RunspacePoolState currentState; bool raiseEvents = false; lock (syncObject) { currentState = stateInfo.State; if (currentState == RunspacePoolState.Opened) { RunspacePoolStateInfo newStateInfo = new RunspacePoolStateInfo(RunspacePoolState.Disconnecting, null); SetRunspacePoolState(newStateInfo); raiseEvents = true; } } // Raise events outside of lock. if (raiseEvents) { RaiseStateChangeEvent(this.stateInfo); } if (currentState == RunspacePoolState.Opened) { RunspacePoolAsyncResult asyncResult = new RunspacePoolAsyncResult( instanceId, callback, state, false); _disconnectAsyncResult = asyncResult; DataStructureHandler.DisconnectPoolAsync(); // Return local reference to async object since the class member can // be asynchronously nulled if the session closes suddenly. return asyncResult; } else { string message = StringUtil.Format(RunspacePoolStrings.InvalidRunspacePoolState, RunspacePoolState.Opened, stateInfo.State); InvalidRunspacePoolStateException invalidStateException = new InvalidRunspacePoolStateException(message, stateInfo.State, RunspacePoolState.Opened); throw invalidStateException; } }