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;
}
private IAsyncResult CoreClose(bool isAsync, AsyncCallback callback, object asyncState)
{
lock (this.syncObject)
{
if (((this.stateInfo.State == RunspacePoolState.Closed) || (this.stateInfo.State == RunspacePoolState.Broken)) || (((this.stateInfo.State == RunspacePoolState.Closing) || (this.stateInfo.State == RunspacePoolState.Disconnecting)) || (this.stateInfo.State == RunspacePoolState.Disconnected)))
{
if (isAsync)
{
RunspacePoolAsyncResult result = new RunspacePoolAsyncResult(this.instanceId, callback, asyncState, false);
result.SetAsCompleted(null);
return(result);
}
return(null);
}
this.stateInfo = new System.Management.Automation.RunspacePoolStateInfo(RunspacePoolState.Closing, null);
}
this.RaiseStateChangeEvent(this.stateInfo);
if (isAsync)
{
RunspacePoolAsyncResult state = new RunspacePoolAsyncResult(this.instanceId, callback, asyncState, false);
ThreadPool.QueueUserWorkItem(new WaitCallback(this.CloseThreadProc), state);
return(state);
}
this.CloseHelper();
return(null);
}
private void SetReconnectAsCompleted()
{
if ((this.reconnectAsyncResult != null) && !this.reconnectAsyncResult.IsCompleted)
{
this.reconnectAsyncResult.SetAsCompleted(base.stateInfo.Reason);
this.reconnectAsyncResult = null;
}
}
private void SetOpenAsCompleted()
{
using (RemoteRunspacePoolInternal.tracer.TraceMethod())
{
if (this.openAsyncResult == null || this.openAsyncResult.IsCompleted)
{
return;
}
this.openAsyncResult.SetAsCompleted(this.stateInfo.Reason);
this.openAsyncResult = (RunspacePoolAsyncResult)null;
}
}
private void SetCloseAsCompleted()
{
this.DispatchTable.AbortAllCalls();
if (this.closeAsyncResult != null)
{
this.closeAsyncResult.SetAsCompleted(base.stateInfo.Reason);
this.closeAsyncResult = null;
}
else
{
this.SetOpenAsCompleted();
}
}
public override IAsyncResult BeginClose(AsyncCallback callback, object asyncState)
{
bool flag = false;
bool flag2 = false;
RunspacePoolStateInfo stateInfo = new RunspacePoolStateInfo(RunspacePoolState.BeforeOpen, null);
RunspacePoolAsyncResult closeAsyncResult = null;
lock (base.syncObject)
{
if ((base.stateInfo.State == RunspacePoolState.Closed) || (base.stateInfo.State == RunspacePoolState.Broken))
{
flag2 = true;
closeAsyncResult = new RunspacePoolAsyncResult(base.instanceId, callback, asyncState, false);
}
else if (base.stateInfo.State == RunspacePoolState.BeforeOpen)
{
stateInfo = base.stateInfo = new RunspacePoolStateInfo(RunspacePoolState.Closed, null);
flag = true;
flag2 = true;
this.closeAsyncResult = null;
closeAsyncResult = new RunspacePoolAsyncResult(base.instanceId, callback, asyncState, false);
}
else if ((base.stateInfo.State == RunspacePoolState.Opened) || (base.stateInfo.State == RunspacePoolState.Opening))
{
stateInfo = base.stateInfo = new RunspacePoolStateInfo(RunspacePoolState.Closing, null);
this.closeAsyncResult = new RunspacePoolAsyncResult(base.instanceId, callback, asyncState, false);
closeAsyncResult = this.closeAsyncResult;
flag = true;
}
else if (((base.stateInfo.State == RunspacePoolState.Disconnected) || (base.stateInfo.State == RunspacePoolState.Disconnecting)) || (base.stateInfo.State == RunspacePoolState.Connecting))
{
this.closeAsyncResult = new RunspacePoolAsyncResult(base.instanceId, callback, asyncState, false);
closeAsyncResult = this.closeAsyncResult;
}
else if (base.stateInfo.State == RunspacePoolState.Closing)
{
return(this.closeAsyncResult);
}
}
if (flag)
{
base.RaiseStateChangeEvent(stateInfo);
}
if (!flag2)
{
this.dataStructureHandler.CloseRunspacePoolAsync();
return(closeAsyncResult);
}
closeAsyncResult.SetAsCompleted(null);
return(closeAsyncResult);
}
public void EndOpen(IAsyncResult asyncResult)
{
if (asyncResult == null)
{
throw PSTraceSource.NewArgumentNullException("asyncResult");
}
RunspacePoolAsyncResult result = asyncResult as RunspacePoolAsyncResult;
if (((result == null) || (result.OwnerId != this.instanceId)) || !result.IsAssociatedWithAsyncOpen)
{
throw PSTraceSource.NewArgumentException("asyncResult", resBaseName, "AsyncResultNotOwned", new object[] { "IAsyncResult", "BeginOpen" });
}
result.EndInvoke();
}
public override IAsyncResult BeginClose(AsyncCallback callback, object asyncState)
{
using (RemoteRunspacePoolInternal.tracer.TraceMethod())
{
bool flag1 = false;
bool flag2 = false;
RunspacePoolStateInfo stateInfo = new RunspacePoolStateInfo(RunspacePoolState.BeforeOpen, (Exception)null);
RunspacePoolAsyncResult runspacePoolAsyncResult = (RunspacePoolAsyncResult)null;
lock (this.syncObject)
{
if (this.stateInfo.State == RunspacePoolState.Closed || this.stateInfo.State == RunspacePoolState.Broken)
{
flag2 = true;
runspacePoolAsyncResult = new RunspacePoolAsyncResult(this.instanceId, callback, asyncState, false);
}
else if (this.stateInfo.State == RunspacePoolState.BeforeOpen)
{
stateInfo = this.stateInfo = new RunspacePoolStateInfo(RunspacePoolState.Closed, (Exception)null);
flag1 = true;
flag2 = true;
this.closeAsyncResult = (RunspacePoolAsyncResult)null;
runspacePoolAsyncResult = new RunspacePoolAsyncResult(this.instanceId, callback, asyncState, false);
}
else if (this.stateInfo.State == RunspacePoolState.Opened || this.stateInfo.State == RunspacePoolState.Opening)
{
stateInfo = this.stateInfo = new RunspacePoolStateInfo(RunspacePoolState.Closing, (Exception)null);
this.closeAsyncResult = new RunspacePoolAsyncResult(this.instanceId, callback, asyncState, false);
runspacePoolAsyncResult = this.closeAsyncResult;
flag1 = true;
}
else if (this.stateInfo.State == RunspacePoolState.Closing)
{
return((IAsyncResult)this.closeAsyncResult);
}
}
if (flag1)
{
this.RaiseStateChangeEvent(stateInfo);
}
if (!flag2)
{
this.dataStructureHandler.CloseRunspacePoolAsync();
}
else
{
runspacePoolAsyncResult.SetAsCompleted((Exception)null);
}
return((IAsyncResult)runspacePoolAsyncResult);
}
}
public override void EndDisconnect(IAsyncResult asyncResult)
{
if (asyncResult == null)
{
throw PSTraceSource.NewArgumentNullException("asyncResult");
}
RunspacePoolAsyncResult result = asyncResult as RunspacePoolAsyncResult;
if (((result == null) || (result.OwnerId != base.instanceId)) || result.IsAssociatedWithAsyncOpen)
{
throw PSTraceSource.NewArgumentException("asyncResult", RunspacePoolInternal.resBaseName, "AsyncResultNotOwned", new object[] { "IAsyncResult", "BeginOpen" });
}
result.EndInvoke();
}
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 SetCloseAsCompleted()
{
using (RemoteRunspacePoolInternal.tracer.TraceMethod())
{
this.DispatchTable.AbortAllCalls();
if (this.closeAsyncResult != null)
{
this.closeAsyncResult.SetAsCompleted(this.stateInfo.Reason);
this.closeAsyncResult = (RunspacePoolAsyncResult)null;
}
else
{
this.SetOpenAsCompleted();
}
}
}
protected override IAsyncResult CoreOpen(bool isAsync, AsyncCallback callback, object asyncState)
{
PSEtwLog.SetActivityIdForCurrentThread(base.InstanceId);
PSEtwLog.LogOperationalVerbose(PSEventId.RunspacePoolOpen, PSOpcode.Open, PSTask.CreateRunspace, PSKeyword.UseAlwaysOperational, new object[0]);
lock (base.syncObject)
{
base.AssertIfStateIsBeforeOpen();
base.stateInfo = new RunspacePoolStateInfo(RunspacePoolState.Opening, null);
}
base.RaiseStateChangeEvent(base.stateInfo);
RunspacePoolAsyncResult result = new RunspacePoolAsyncResult(base.instanceId, callback, asyncState, true);
this.openAsyncResult = result;
this.dataStructureHandler.CreateRunspacePoolAndOpenAsync();
return(result);
}
protected virtual IAsyncResult CoreOpen(bool isAsync, AsyncCallback callback, object asyncState)
{
lock (this.syncObject)
{
this.AssertIfStateIsBeforeOpen();
this.stateInfo = new System.Management.Automation.RunspacePoolStateInfo(RunspacePoolState.Opening, null);
}
this.RaiseStateChangeEvent(this.stateInfo);
if (isAsync)
{
AsyncResult state = new RunspacePoolAsyncResult(this.instanceId, callback, asyncState, true);
ThreadPool.QueueUserWorkItem(new WaitCallback(this.OpenThreadProc), state);
return(state);
}
this.OpenHelper();
return(null);
}
protected override IAsyncResult CoreOpen(
bool isAsync,
AsyncCallback callback,
object asyncState)
{
using (RemoteRunspacePoolInternal.tracer.TraceMethod())
{
this.etwTracer.OperationalChannel.WriteVerbose(PSEventId.RunspacePoolOpen, PSOpcode.Open, PSTask.CreateRunspace);
lock (this.syncObject)
{
this.AssertIfStateIsBeforeOpen();
this.stateInfo = new RunspacePoolStateInfo(RunspacePoolState.Opening, (Exception)null);
}
this.RaiseStateChangeEvent(this.stateInfo);
RunspacePoolAsyncResult runspacePoolAsyncResult = new RunspacePoolAsyncResult(this.instanceId, callback, asyncState, true);
this.openAsyncResult = runspacePoolAsyncResult;
this.dataStructureHandler.CreateRunspacePoolAndOpenAsync();
return((IAsyncResult)runspacePoolAsyncResult);
}
}
/// <summary>
/// Closes the RunspacePool asynchronously. To get the exceptions
/// that might have occurred, call EndOpen
/// </summary>
/// <param name="callback">
/// An AsyncCallback to call once the BeginClose completes
/// </param>
/// <param name="asyncState">
/// A user supplied state to call the <paramref name="callback"/>
/// with
/// </param>
/// <returns>
/// An AsyncResult object to monitor the state of the async
/// operation
/// </returns>
public override IAsyncResult BeginClose(AsyncCallback callback, object asyncState)
{
bool raiseEvents = false;
bool skipClosing = false;
RunspacePoolStateInfo copyState = new RunspacePoolStateInfo(RunspacePoolState.BeforeOpen, null);
RunspacePoolAsyncResult asyncResult = null;
lock (syncObject)
{
if ((stateInfo.State == RunspacePoolState.Closed) ||
(stateInfo.State == RunspacePoolState.Broken))
{
skipClosing = true;
asyncResult = new RunspacePoolAsyncResult(instanceId, callback, asyncState, false);
}
else if (stateInfo.State == RunspacePoolState.BeforeOpen)
{
copyState = stateInfo = new RunspacePoolStateInfo(RunspacePoolState.Closed, null);
raiseEvents = true;
skipClosing = true;
_closeAsyncResult = null;
asyncResult = new RunspacePoolAsyncResult(instanceId, callback, asyncState, false);
}
else if (stateInfo.State == RunspacePoolState.Opened ||
stateInfo.State == RunspacePoolState.Opening)
{
copyState = stateInfo = new RunspacePoolStateInfo(RunspacePoolState.Closing, null);
_closeAsyncResult = new RunspacePoolAsyncResult(instanceId, callback, asyncState, false);
asyncResult = _closeAsyncResult;
raiseEvents = true;
}
else if (stateInfo.State == RunspacePoolState.Disconnected ||
stateInfo.State == RunspacePoolState.Disconnecting ||
stateInfo.State == RunspacePoolState.Connecting)
{
// Continue with closing so the PSRP layer is aware that the client side session is
// being closed. This will result in a broken session on the client.
_closeAsyncResult = new RunspacePoolAsyncResult(instanceId, callback, asyncState, false);
asyncResult = _closeAsyncResult;
}
else if (stateInfo.State == RunspacePoolState.Closing)
{
return _closeAsyncResult;
}
}
// raise the events outside the lock
if (raiseEvents)
{
RaiseStateChangeEvent(copyState);
}
if (!skipClosing)
{
//SetRunspacePoolState(new RunspacePoolStateInfo(RunspacePoolState.Closing, null), true);
// send a message using the data structure handler to close the RunspacePool
// on the remote server
DataStructureHandler.CloseRunspacePoolAsync();
}
else
{
// signal the wait handle
asyncResult.SetAsCompleted(null);
}
return asyncResult;
}
/// <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;
}
}
/// <summary>
/// Closes the runspacepool synchronously / asynchronously.
/// </summary>
/// <param name="isAsync">
/// true to close asynchronously
/// </param>
/// <param name="callback">
/// A AsyncCallback to call once the BeginClose completes.
/// </param>
/// <param name="asyncState">
/// A user supplied state to call the <paramref name="callback"/>
/// with.
/// </param>
/// <returns>
/// asyncResult object to monitor status of the async
/// open operation. This is returned only if <paramref name="isAsync"/>
/// is true.
/// </returns>
private IAsyncResult CoreClose(bool isAsync, AsyncCallback callback, object asyncState)
{
lock (syncObject)
{
if ((stateInfo.State == RunspacePoolState.Closed) ||
(stateInfo.State == RunspacePoolState.Broken) ||
(stateInfo.State == RunspacePoolState.Closing) ||
(stateInfo.State == RunspacePoolState.Disconnecting) ||
(stateInfo.State == RunspacePoolState.Disconnected))
{
if (isAsync)
{
RunspacePoolAsyncResult asyncResult = new RunspacePoolAsyncResult(instanceId, callback, asyncState, false);
asyncResult.SetAsCompleted(null);
return asyncResult;
}
else
{
return null;
}
}
stateInfo = new RunspacePoolStateInfo(RunspacePoolState.Closing, null);
}
// only one thread will reach here.
RaiseStateChangeEvent(stateInfo);
if (isAsync)
{
RunspacePoolAsyncResult asyncResult = new RunspacePoolAsyncResult(instanceId, callback, asyncState, false);
//Open pool in another thread
ThreadPool.QueueUserWorkItem(new WaitCallback(CloseThreadProc), asyncResult);
return asyncResult;
}
// open the runspace synchronously
CloseHelper();
return null;
}
/// <summary>
/// Opens the runspacepool synchronously / asynchronously.
/// Runspace pool must be opened before it can be used.
/// </summary>
/// <param name="isAsync">
/// true to open asynchronously
/// </param>
/// <param name="callback">
/// A AsyncCallback to call once the BeginOpen completes.
/// </param>
/// <param name="asyncState">
/// A user supplied state to call the <paramref name="callback"/>
/// with.
/// </param>
/// <returns>
/// asyncResult object to monitor status of the async
/// open operation. This is returned only if <paramref name="isAsync"/>
/// is true.
/// </returns>
/// <exception cref="InvalidRunspacePoolStateException">
/// Cannot open RunspacePool because RunspacePool is not in
/// the BeforeOpen state.
/// </exception>
/// <exception cref="OutOfMemoryException">
/// There is not enough memory available to start this asynchronously.
/// </exception>
protected virtual IAsyncResult CoreOpen(bool isAsync, AsyncCallback callback,
object asyncState)
{
lock (syncObject)
{
AssertIfStateIsBeforeOpen();
stateInfo = new RunspacePoolStateInfo(RunspacePoolState.Opening, null);
}
// only one thread will reach here, so no
// need to lock.
RaiseStateChangeEvent(stateInfo);
if (isAsync)
{
AsyncResult asyncResult = new RunspacePoolAsyncResult(instanceId, callback, asyncState, true);
//Open pool in another thread
ThreadPool.QueueUserWorkItem(new WaitCallback(OpenThreadProc), asyncResult);
return asyncResult;
}
// open the runspace synchronously
OpenHelper();
return null;
}
/// <summary>
/// Opens the runspacepool synchronously / asynchronously.
/// Runspace pool must be opened before it can be used.
/// </summary>
/// <param name="isAsync">
/// true to open asynchronously
/// </param>
/// <param name="callback">
/// A AsyncCallback to call once the BeginOpen completes.
/// </param>
/// <param name="asyncState">
/// A user supplied state to call the <paramref name="callback"/>
/// with.
/// </param>
/// <returns>
/// asyncResult object to monitor status of the async
/// open operation. This is returned only if <paramref name="isAsync"/>
/// is true.
/// </returns>
/// <exception cref="InvalidRunspacePoolStateException">
/// Cannot open RunspacePool because RunspacePool is not in
/// the BeforeOpen state.
/// </exception>
/// <exception cref="OutOfMemoryException">
/// There is not enough memory available to start this asynchronously.
/// </exception>
protected override IAsyncResult CoreOpen(bool isAsync, AsyncCallback callback,
object asyncState)
{
PSEtwLog.SetActivityIdForCurrentThread(this.InstanceId);
PSEtwLog.LogOperationalVerbose(PSEventId.RunspacePoolOpen, PSOpcode.Open,
PSTask.CreateRunspace, PSKeyword.UseAlwaysOperational);
TelemetryAPI.ReportRemoteSessionCreated(_connectionInfo);
lock (syncObject)
{
AssertIfStateIsBeforeOpen();
stateInfo = new RunspacePoolStateInfo(RunspacePoolState.Opening, null);
}
// BUGBUG: the following comment needs to be validated
// only one thread will reach here, so no need
// to lock
RaiseStateChangeEvent(stateInfo);
RunspacePoolAsyncResult asyncResult = new RunspacePoolAsyncResult(
instanceId, callback, asyncState, true);
_openAsyncResult = asyncResult;
// send a message using the data structure handler to open the RunspacePool
// on the remote server
DataStructureHandler.CreateRunspacePoolAndOpenAsync();
return asyncResult;
}
/// <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;
}
}
