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;
}
}
