private void SendStopComplete()
{
OperationStateEventArgs operationStateEventArgs = new OperationStateEventArgs();
operationStateEventArgs.OperationState = OperationState.StopComplete;
OperationComplete.SafeInvoke(this, operationStateEventArgs);
}
internal override void StopOperation()
{
OperationStateEventArgs operationStateEventArgs = null;
lock (this._syncObject)
{
if (this.startComplete)
{
this.stopComplete = true;
this.startComplete = true;
operationStateEventArgs = new OperationStateEventArgs {
BaseEvent = new RunspaceStateEventArgs(this.runspace.RunspaceStateInfo),
OperationState = OperationState.StopComplete
};
}
else
{
this.stopComplete = false;
}
}
if (operationStateEventArgs != null)
{
this.FireEvent(operationStateEventArgs);
}
else
{
this.runspace.CloseAsync();
}
}
private void HandleRunspaceStateChanged(object source, RunspaceStateEventArgs stateEventArgs)
{
switch (stateEventArgs.RunspaceStateInfo.State)
{
case RunspaceState.BeforeOpen:
break;
case RunspaceState.Opening:
break;
case RunspaceState.Closing:
break;
default:
OperationStateEventArgs e = new OperationStateEventArgs();
e.BaseEvent = (EventArgs)stateEventArgs;
if (stateEventArgs.RunspaceStateInfo.State == RunspaceState.Opened)
{
e.OperationState = OperationState.StartComplete;
OpenRunspaceOperation.tracer.WriteLine("Runspace opened for {0}", (object)this.runspace.InstanceId);
}
else
{
e.OperationState = OperationState.StopComplete;
OpenRunspaceOperation.tracer.WriteLine("Runspace closed for {0}", (object)this.runspace.InstanceId);
}
this.OperationComplete((object)this, e);
break;
}
}
private void SendStopComplete()
{
OperationStateEventArgs operationStateEventArg = new OperationStateEventArgs();
operationStateEventArg.OperationState = OperationState.StopComplete;
this.OperationComplete.SafeInvoke <OperationStateEventArgs>(this, operationStateEventArg);
}
internal void RaiseOperationCompleteEvent(EventArgs baseEventArgs, OperationState state)
{
OperationStateEventArgs operationStateEventArg = new OperationStateEventArgs();
operationStateEventArg.OperationState = state;
this.OperationComplete.SafeInvoke <OperationStateEventArgs>(this, operationStateEventArg);
}
private void SendStopComplete()
{
OperationStateEventArgs eventArgs = new OperationStateEventArgs {
OperationState = OperationState.StopComplete
};
this.OperationComplete.SafeInvoke <OperationStateEventArgs>(this, eventArgs);
}
private void SendStopComplete(EventArgs eventArgs = null)
{
OperationStateEventArgs args = new OperationStateEventArgs {
BaseEvent = eventArgs,
OperationState = OperationState.StopComplete
};
this.OperationComplete.SafeInvoke <OperationStateEventArgs>(this, args);
}
internal override void StopOperation()
{
this.RemoveEventCallback();
OperationStateEventArgs eventArgs = new OperationStateEventArgs {
OperationState = OperationState.StopComplete
};
this.OperationComplete.SafeInvoke <OperationStateEventArgs>(this, eventArgs);
}
private void RaiseOperationCompleteEvent()
{
this.job.StateChanged -= new EventHandler <JobStateEventArgs>(this.HandleJobStateChanged);
OperationStateEventArgs eventArgs = new OperationStateEventArgs {
OperationState = OperationState.StartComplete,
BaseEvent = EventArgs.Empty
};
this.OperationComplete.SafeInvoke <OperationStateEventArgs>(this, eventArgs);
}
protected override void HandleOperationComplete(object sender, OperationStateEventArgs stateEventArgs)
{
Exception exception;
ErrorRecord record;
ExecutionCmdletHelper helper = sender as ExecutionCmdletHelper;
base.ProcessJobFailure(helper, out exception, out record);
if (record != null)
{
this.WriteError(record);
}
}
private void RaiseOperationCompleteEvent(EventArgs baseEventArgs)
{
this.pipeline.Dispose();
OperationStateEventArgs e = new OperationStateEventArgs();
e.OperationState = OperationState.StopComplete;
e.BaseEvent = baseEventArgs;
if (this.OperationComplete == null)
{
return;
}
this.OperationComplete((object)this, e);
}
protected override void HandleOperationComplete(
object sender,
OperationStateEventArgs stateEventArgs)
{
Exception failureException;
ErrorRecord failureErrorRecord;
this.ProcessJobFailure(sender as ExecutionCmdletHelper, out failureException, out failureErrorRecord);
if (failureException == null)
{
return;
}
this.Results.Add(new PSStreamObject(PSStreamObjectType.Error, (object)failureErrorRecord));
}
private void RaiseOperationCompleteEvent(EventArgs baseEventArgs)
{
if (base.pipeline != null)
{
base.pipeline.StateChanged -= new EventHandler <PipelineStateEventArgs>(this.HandlePipelineStateChanged);
base.pipeline.Dispose();
}
OperationStateEventArgs eventArgs = new OperationStateEventArgs {
OperationState = OperationState.StopComplete,
BaseEvent = baseEventArgs
};
if (this.OperationComplete != null)
{
this.OperationComplete.SafeInvoke <OperationStateEventArgs>(this, eventArgs);
}
}
private void FireEvent(OperationStateEventArgs operationStateEventArgs)
{
EventHandler <OperationStateEventArgs>[] handlerArray;
lock (this._internalCallbacks)
{
handlerArray = new EventHandler <OperationStateEventArgs> [this._internalCallbacks.Count];
this._internalCallbacks.CopyTo(handlerArray);
}
foreach (EventHandler <OperationStateEventArgs> handler in handlerArray)
{
try
{
handler.SafeInvoke <OperationStateEventArgs>(this, operationStateEventArgs);
}
catch (Exception exception)
{
CommandProcessorBase.CheckForSevereException(exception);
}
}
}
private void HandleOperationComplete(object sender, OperationStateEventArgs stateEventArgs)
{
WmiAsyncCmdletHelper wmiAsyncCmdletHelper = (WmiAsyncCmdletHelper)sender;
if (wmiAsyncCmdletHelper.State != WmiState.NotStarted)
{
if (wmiAsyncCmdletHelper.State != WmiState.Running)
{
if (wmiAsyncCmdletHelper.State != WmiState.Completed)
{
if (wmiAsyncCmdletHelper.State != WmiState.Failed)
{
base.SetJobState(JobState.Stopped, wmiAsyncCmdletHelper.InternalException);
return;
}
else
{
base.SetJobState(JobState.Failed, wmiAsyncCmdletHelper.InternalException);
return;
}
}
else
{
base.SetJobState(JobState.Completed, wmiAsyncCmdletHelper.InternalException);
return;
}
}
else
{
base.SetJobState(JobState.Running, wmiAsyncCmdletHelper.InternalException);
return;
}
}
else
{
base.SetJobState(JobState.Stopped, wmiAsyncCmdletHelper.InternalException);
return;
}
}
private void HandleRunspaceStateChanged(object source, RunspaceStateEventArgs stateEventArgs)
{
switch (stateEventArgs.RunspaceStateInfo.State)
{
case RunspaceState.BeforeOpen:
case RunspaceState.Opening:
case RunspaceState.Closing:
return;
}
OperationStateEventArgs operationStateEventArgs = null;
lock (this._syncObject)
{
if (!this.stopComplete)
{
this.stopComplete = true;
this.startComplete = true;
operationStateEventArgs = new OperationStateEventArgs {
BaseEvent = stateEventArgs,
OperationState = OperationState.StopComplete
};
}
else if (!this.startComplete)
{
this.startComplete = true;
operationStateEventArgs = new OperationStateEventArgs {
BaseEvent = stateEventArgs,
OperationState = OperationState.StartComplete
};
}
}
if (operationStateEventArgs != null)
{
this.FireEvent(operationStateEventArgs);
}
}
private void HandleRunspaceStateChanged(object sender, OperationStateEventArgs stateEventArgs)
{
ErrorRecord errorRecord;
PSRemotingTransportException exception2;
string str;
if (sender == null)
{
throw PSTraceSource.NewArgumentNullException("sender");
}
if (stateEventArgs == null)
{
throw PSTraceSource.NewArgumentNullException("stateEventArgs");
}
RunspaceStateEventArgs baseEvent = stateEventArgs.BaseEvent as RunspaceStateEventArgs;
RunspaceState state = baseEvent.RunspaceStateInfo.State;
OpenRunspaceOperation operation = sender as OpenRunspaceOperation;
RemoteRunspace operatedRunspace = operation.OperatedRunspace;
if (operatedRunspace != null)
{
operatedRunspace.URIRedirectionReported -= new EventHandler <RemoteDataEventArgs <Uri> >(this.HandleURIDirectionReported);
}
PipelineWriter objectWriter = this.stream.ObjectWriter;
Exception reason = baseEvent.RunspaceStateInfo.Reason;
switch (state)
{
case RunspaceState.Opened:
{
PSSession remoteRunspaceInfo = new PSSession(operatedRunspace);
base.RunspaceRepository.Add(remoteRunspaceInfo);
Action <Cmdlet> action = cmdlet => cmdlet.WriteObject(remoteRunspaceInfo);
if (objectWriter.IsOpen)
{
objectWriter.Write(action);
}
return;
}
case RunspaceState.Closed:
{
Uri uri = WSManConnectionInfo.ExtractPropertyAsWsManConnectionInfo <Uri>(operatedRunspace.ConnectionInfo, "ConnectionUri", null);
string message = base.GetMessage(RemotingErrorIdStrings.RemoteRunspaceClosed, new object[] { (uri != null) ? uri.AbsoluteUri : string.Empty });
Action <Cmdlet> action3 = cmdlet => cmdlet.WriteVerbose(message);
if (objectWriter.IsOpen)
{
objectWriter.Write(action3);
}
if (reason != null)
{
ErrorRecord errorRecord2 = new ErrorRecord(reason, "PSSessionStateClosed", ErrorCategory.OpenError, operatedRunspace);
Action <Cmdlet> action4 = cmdlet => cmdlet.WriteError(errorRecord2);
if (objectWriter.IsOpen)
{
objectWriter.Write(action4);
}
}
return;
}
case RunspaceState.Closing:
return;
case RunspaceState.Broken:
exception2 = reason as PSRemotingTransportException;
str = null;
if (exception2 != null)
{
OpenRunspaceOperation operation2 = sender as OpenRunspaceOperation;
if (operation2 != null)
{
string computerName = operation2.OperatedRunspace.ConnectionInfo.ComputerName;
if (exception2.ErrorCode != -2144108135)
{
str = "[" + computerName + "] ";
if (!string.IsNullOrEmpty(exception2.Message))
{
str = str + exception2.Message;
}
else if (!string.IsNullOrEmpty(exception2.TransportMessage))
{
str = str + exception2.TransportMessage;
}
break;
}
string str3 = PSRemotingErrorInvariants.FormatResourceString(RemotingErrorIdStrings.URIRedirectionReported, new object[] { exception2.Message, "MaximumConnectionRedirectionCount", "PSSessionOption", "AllowRedirection" });
str = "[" + computerName + "] " + str3;
}
}
break;
default:
return;
}
PSRemotingDataStructureException exception3 = reason as PSRemotingDataStructureException;
if (exception3 != null)
{
OpenRunspaceOperation operation3 = sender as OpenRunspaceOperation;
if (operation3 != null)
{
string str4 = operation3.OperatedRunspace.ConnectionInfo.ComputerName;
str = "[" + str4 + "] " + exception3.Message;
}
}
if (reason == null)
{
reason = new RuntimeException(base.GetMessage(RemotingErrorIdStrings.RemoteRunspaceOpenUnknownState, new object[] { state }));
}
string fQEIDFromTransportError = WSManTransportManagerUtils.GetFQEIDFromTransportError((exception2 != null) ? exception2.ErrorCode : 0, this._defaultFQEID);
errorRecord = new ErrorRecord(reason, operatedRunspace, fQEIDFromTransportError, ErrorCategory.OpenError, null, null, null, null, null, str, null);
Action <Cmdlet> action2 = cmdlet => cmdlet.WriteError(errorRecord);
if (objectWriter.IsOpen)
{
objectWriter.Write(action2);
}
this.toDispose.Add(operatedRunspace);
}
protected virtual void HandleOperationComplete(object sender, OperationStateEventArgs stateEventArgs)
{
ExecutionCmdletHelper helper = sender as ExecutionCmdletHelper;
this.DeterminedAndSetJobState(helper);
}
