private void WriteConnectFailed(
Exception e,
PSSession session)
{
if (_writeStream.ObjectWriter.IsOpen)
{
string FQEID = "PSSessionConnectFailed";
Exception reason;
if (e != null && !string.IsNullOrEmpty(e.Message))
{
// Update fully qualified error Id if we have a transport error.
PSRemotingTransportException transportException = e as PSRemotingTransportException;
if (transportException != null)
{
FQEID = WSManTransportManagerUtils.GetFQEIDFromTransportError(transportException.ErrorCode, FQEID);
}
reason = new RuntimeException(
StringUtil.Format(RemotingErrorIdStrings.RunspaceConnectFailedWithMessage, session.Name, e.Message),
e);
}
else
{
reason = new RuntimeException(
StringUtil.Format(RemotingErrorIdStrings.RunspaceConnectFailed, session.Name,
session.Runspace.RunspaceStateInfo.State.ToString()), null);
}
ErrorRecord errorRecord = new ErrorRecord(reason, FQEID, ErrorCategory.InvalidOperation, null);
Action <Cmdlet> errorWriter = delegate(Cmdlet cmdlet)
{
cmdlet.WriteError(errorRecord);
};
_writeStream.ObjectWriter.Write(errorWriter);
}
}
private void WriteConnectFailed(Exception e, PSSession session)
{
Exception runtimeException;
if (this._writeStream.ObjectWriter.IsOpen)
{
string fQEIDFromTransportError = "PSSessionConnectFailed";
if (e == null || string.IsNullOrEmpty(e.Message))
{
runtimeException = new RuntimeException(StringUtil.Format(RemotingErrorIdStrings.RunspaceConnectFailed, session.Name, session.Runspace.RunspaceStateInfo.State.ToString()), null);
}
else
{
PSRemotingTransportException pSRemotingTransportException = e as PSRemotingTransportException;
if (pSRemotingTransportException != null)
{
fQEIDFromTransportError = WSManTransportManagerUtils.GetFQEIDFromTransportError(pSRemotingTransportException.ErrorCode, fQEIDFromTransportError);
}
runtimeException = new RuntimeException(StringUtil.Format(RemotingErrorIdStrings.RunspaceConnectFailedWithMessage, session.Name, e.Message), e);
}
ErrorRecord errorRecord = new ErrorRecord(runtimeException, fQEIDFromTransportError, ErrorCategory.InvalidOperation, null);
Action <Cmdlet> action = (Cmdlet cmdlet) => cmdlet.WriteError(errorRecord);
this._writeStream.ObjectWriter.Write(action);
}
}
internal static TransportErrorOccuredEventArgs ConstructTransportErrorEventArgs(
IntPtr wsmanAPIHandle,
IntPtr wsmanSessionHandle,
WSManNativeApi.WSManError errorStruct,
TransportMethodEnum transportMethodReportingError,
PSRemotingErrorId errorResourceID,
params object[] resourceArgs)
{
PSRemotingTransportException e;
if (errorStruct.errorCode == -2144108135)
{
string sessionOptionAsString = WSManNativeApi.WSManGetSessionOptionAsString(wsmanSessionHandle, WSManNativeApi.WSManSessionOption.WSMAN_OPTION_REDIRECT_LOCATION);
string str = WSManTransportManagerUtils.ParseEscapeWSManErrorMessage(WSManNativeApi.WSManGetErrorMessage(wsmanAPIHandle, errorStruct.errorCode)).Trim();
e = (PSRemotingTransportException) new PSRemotingTransportRedirectException(sessionOptionAsString, PSRemotingErrorId.URIEndPointNotResolved, new object[2]
{
(object)str,
(object)sessionOptionAsString
});
}
else
{
e = new PSRemotingTransportException(PSRemotingErrorId.TroubleShootingHelpTopic, new object[1]
{
(object)PSRemotingErrorInvariants.FormatResourceString(errorResourceID, resourceArgs)
});
e.TransportMessage = WSManTransportManagerUtils.ParseEscapeWSManErrorMessage(WSManNativeApi.WSManGetErrorMessage(wsmanAPIHandle, errorStruct.errorCode));
}
e.ErrorCode = errorStruct.errorCode;
return(new TransportErrorOccuredEventArgs(e, transportMethodReportingError));
}
internal Collection <PSSession> GetDisconnectedSessions(Collection <WSManConnectionInfo> connectionInfos, PSHost host, ObjectStream stream, RunspaceRepository runspaceRepository, int throttleLimit, SessionFilterState filterState, Guid[] matchIds, string[] matchNames, string configurationName)
{
Collection <PSSession> collection = new Collection <PSSession>();
foreach (WSManConnectionInfo info in connectionInfos)
{
Runspace[] runspaceArray = null;
try
{
runspaceArray = Runspace.GetRunspaces(info, host, BuiltInTypesTable);
}
catch (RuntimeException exception)
{
if (!(exception.InnerException is InvalidOperationException))
{
throw;
}
if ((stream.ObjectWriter != null) && stream.ObjectWriter.IsOpen)
{
int num;
string message = StringUtil.Format(RemotingErrorIdStrings.QueryForRunspacesFailed, info.ComputerName, ExtractMessage(exception.InnerException, out num));
string fQEIDFromTransportError = WSManTransportManagerUtils.GetFQEIDFromTransportError(num, "RemotePSSessionQueryFailed");
Exception exception2 = new RuntimeException(message, exception.InnerException);
ErrorRecord errorRecord = new ErrorRecord(exception2, fQEIDFromTransportError, ErrorCategory.InvalidOperation, info);
stream.ObjectWriter.Write(errorRecord);
/*
* stream.ObjectWriter.Write(delegate (Cmdlet cmdlet) {
* cmdlet.WriteError(errorRecord);
* });
*/
}
}
if (this.stopProcessing)
{
break;
}
if (runspaceArray != null)
{
string str3 = null;
if (!string.IsNullOrEmpty(configurationName))
{
str3 = (configurationName.IndexOf("http://schemas.microsoft.com/powershell/", StringComparison.OrdinalIgnoreCase) != -1) ? configurationName : ("http://schemas.microsoft.com/powershell/" + configurationName);
}
foreach (Runspace runspace in runspaceArray)
{
if (str3 != null)
{
WSManConnectionInfo connectionInfo = runspace.ConnectionInfo as WSManConnectionInfo;
if ((connectionInfo != null) && !str3.Equals(connectionInfo.ShellUri, StringComparison.OrdinalIgnoreCase))
{
continue;
}
}
PSSession item = null;
if (runspaceRepository != null)
{
item = runspaceRepository.GetItem(runspace.InstanceId);
}
if ((item != null) && UseExistingRunspace(item.Runspace, runspace))
{
if (this.TestRunspaceState(item.Runspace, filterState))
{
collection.Add(item);
}
}
else if (this.TestRunspaceState(runspace, filterState))
{
collection.Add(new PSSession(runspace as RemoteRunspace));
}
}
}
}
if ((matchIds != null) && (collection.Count > 0))
{
Collection <PSSession> collection2 = new Collection <PSSession>();
foreach (Guid guid in matchIds)
{
bool flag = false;
foreach (PSSession session2 in collection)
{
if (this.stopProcessing)
{
break;
}
if (session2.Runspace.InstanceId.Equals(guid))
{
flag = true;
collection2.Add(session2);
break;
}
}
if ((!flag && (stream.ObjectWriter != null)) && stream.ObjectWriter.IsOpen)
{
Exception exception3 = new RuntimeException(StringUtil.Format(RemotingErrorIdStrings.SessionIdMatchFailed, guid));
ErrorRecord errorRecord = new ErrorRecord(exception3, "PSSessionIdMatchFail", ErrorCategory.InvalidOperation, guid);
stream.ObjectWriter.Write(errorRecord);
/*
* stream.ObjectWriter.Write(delegate (Cmdlet cmdlet) {
* cmdlet.WriteError(errorRecord);
* });
*/
}
}
return(collection2);
}
if ((matchNames == null) || (collection.Count <= 0))
{
return(collection);
}
Collection <PSSession> collection3 = new Collection <PSSession>();
foreach (string str5 in matchNames)
{
WildcardPattern pattern = new WildcardPattern(str5, WildcardOptions.IgnoreCase);
bool flag2 = false;
foreach (PSSession session3 in collection)
{
if (this.stopProcessing)
{
break;
}
if (pattern.IsMatch(((RemoteRunspace)session3.Runspace).RunspacePool.RemoteRunspacePoolInternal.Name))
{
flag2 = true;
collection3.Add(session3);
}
}
if ((!flag2 && (stream.ObjectWriter != null)) && stream.ObjectWriter.IsOpen)
{
Exception exception4 = new RuntimeException(StringUtil.Format(RemotingErrorIdStrings.SessionNameMatchFailed, str5));
ErrorRecord errorRecord = new ErrorRecord(exception4, "PSSessionNameMatchFail", ErrorCategory.InvalidOperation, str5);
stream.ObjectWriter.Write(errorRecord);
/*
* stream.ObjectWriter.Write(delegate (Cmdlet cmdlet) {
* cmdlet.WriteError(errorRecord);
* });
*/
}
}
return(collection3);
}
private void QueryForAndConnectCommands(string name, Guid instanceId)
{
Runspace[] runspaceArray;
WSManConnectionInfo connectionObject = this.GetConnectionObject();
try
{
runspaceArray = Runspace.GetRunspaces(connectionObject, base.Host, QueryRunspaces.BuiltInTypesTable);
}
catch (RuntimeException exception)
{
int num;
string message = StringUtil.Format(RemotingErrorIdStrings.QueryForRunspacesFailed, connectionObject.ComputerName, QueryRunspaces.ExtractMessage(exception.InnerException, out num));
string fQEIDFromTransportError = WSManTransportManagerUtils.GetFQEIDFromTransportError(num, "ReceivePSSessionQueryForSessionFailed");
Exception exception2 = new RuntimeException(message, exception.InnerException);
ErrorRecord errorRecord = new ErrorRecord(exception2, fQEIDFromTransportError, ErrorCategory.InvalidOperation, connectionObject);
base.WriteError(errorRecord);
return;
}
string str3 = null;
if (!string.IsNullOrEmpty(this.ConfigurationName))
{
str3 = (this.ConfigurationName.IndexOf("http://schemas.microsoft.com/powershell/", StringComparison.OrdinalIgnoreCase) != -1) ? this.ConfigurationName : ("http://schemas.microsoft.com/powershell/" + this.ConfigurationName);
}
foreach (Runspace runspace in runspaceArray)
{
if (this._stopProcessing)
{
return;
}
if (str3 != null)
{
WSManConnectionInfo connectionInfo = runspace.ConnectionInfo as WSManConnectionInfo;
if ((connectionInfo != null) && !str3.Equals(connectionInfo.ShellUri, StringComparison.OrdinalIgnoreCase))
{
continue;
}
}
bool flag = false;
if (!string.IsNullOrEmpty(name) && (string.Compare(name, ((RemoteRunspace)runspace).RunspacePool.RemoteRunspacePoolInternal.Name, StringComparison.OrdinalIgnoreCase) == 0))
{
flag = true;
}
else if (instanceId.Equals(runspace.InstanceId))
{
flag = true;
}
if (flag && base.ShouldProcess(((RemoteRunspace)runspace).Name, "Receive"))
{
Exception exception3;
PSSession item = base.RunspaceRepository.GetItem(runspace.InstanceId);
PSSession session2 = this.ConnectSession(item, out exception3);
if (session2 != null)
{
base.RunspaceRepository.AddOrReplace(session2);
PSRemotingJob job = this.FindJobForSession(session2);
if (this.OutTarget == Microsoft.PowerShell.Commands.OutTarget.Host)
{
this.ConnectSessionToHost(session2, job);
return;
}
this.ConnectSessionToJob(session2, job);
return;
}
PSSession session = new PSSession(runspace as RemoteRunspace);
session2 = this.ConnectSession(session, out exception3);
if (session2 != null)
{
if (item != null)
{
session2 = item.InsertRunspace(session2.Runspace as RemoteRunspace) ? item : session2;
}
base.RunspaceRepository.AddOrReplace(session2);
if (this.OutTarget == Microsoft.PowerShell.Commands.OutTarget.Job)
{
this.ConnectSessionToJob(session2, null);
return;
}
this.ConnectSessionToHost(session2, null);
return;
}
string str4 = StringUtil.Format(RemotingErrorIdStrings.RunspaceCannotBeConnected, session.Name);
base.WriteError(new ErrorRecord(new ArgumentException(str4, exception3), "ReceivePSSessionCannotConnectSession", ErrorCategory.InvalidOperation, session));
return;
}
}
}
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 void ProcessJobFailure(ExecutionCmdletHelper helper, out Exception failureException, out ErrorRecord failureErrorRecord)
{
RemotePipeline pipeline = helper.Pipeline as RemotePipeline;
RemoteRunspace runspace = pipeline.GetRunspace() as RemoteRunspace;
failureException = null;
failureErrorRecord = null;
if (helper.InternalException != null)
{
string errorId = "RemotePipelineExecutionFailed";
failureException = helper.InternalException;
if ((failureException is InvalidRunspaceStateException) || (failureException is InvalidRunspacePoolStateException))
{
errorId = "InvalidSessionState";
if (!string.IsNullOrEmpty(failureException.Source))
{
errorId = string.Format(CultureInfo.InvariantCulture, "{0},{1}", new object[] { errorId, failureException.Source });
}
}
failureErrorRecord = new ErrorRecord(helper.InternalException, errorId, ErrorCategory.OperationStopped, helper);
}
else if (runspace.RunspaceStateInfo.State == RunspaceState.Broken)
{
failureException = runspace.RunspaceStateInfo.Reason;
object computerName = runspace.ConnectionInfo.ComputerName;
string str2 = null;
PSRemotingTransportException exception = failureException as PSRemotingTransportException;
string fQEIDFromTransportError = WSManTransportManagerUtils.GetFQEIDFromTransportError((exception != null) ? exception.ErrorCode : 0, "PSSessionStateBroken");
if (exception != null)
{
str2 = "[" + runspace.ConnectionInfo.ComputerName + "] ";
if (exception.ErrorCode == -2144108135)
{
string str4 = PSRemotingErrorInvariants.FormatResourceString(RemotingErrorIdStrings.URIRedirectionReported, new object[] { exception.Message, "MaximumConnectionRedirectionCount", "PSSessionOption", "AllowRedirection" });
str2 = str2 + str4;
}
else if (!string.IsNullOrEmpty(exception.Message))
{
str2 = str2 + exception.Message;
}
else if (!string.IsNullOrEmpty(exception.TransportMessage))
{
str2 = str2 + exception.TransportMessage;
}
}
if (failureException == null)
{
failureException = new RuntimeException(PSRemotingErrorInvariants.FormatResourceString(RemotingErrorIdStrings.RemoteRunspaceOpenUnknownState, new object[] { runspace.RunspaceStateInfo.State }));
}
failureErrorRecord = new ErrorRecord(failureException, computerName, fQEIDFromTransportError, ErrorCategory.OpenError, null, null, null, null, null, str2, null);
}
else if (pipeline.PipelineStateInfo.State == PipelineState.Failed)
{
object targetObject = runspace.ConnectionInfo.ComputerName;
failureException = pipeline.PipelineStateInfo.Reason;
if (failureException != null)
{
RemoteException exception2 = failureException as RemoteException;
ErrorRecord errorRecord = null;
if (exception2 != null)
{
errorRecord = exception2.ErrorRecord;
}
else
{
errorRecord = new ErrorRecord(pipeline.PipelineStateInfo.Reason, "JobFailure", ErrorCategory.OperationStopped, targetObject);
}
string str5 = ((RemoteRunspace)pipeline.GetRunspace()).ConnectionInfo.ComputerName;
Guid instanceId = pipeline.GetRunspace().InstanceId;
OriginInfo originInfo = new OriginInfo(str5, instanceId);
failureErrorRecord = new RemotingErrorRecord(errorRecord, originInfo);
}
}
}
