private bool TestRunspaceState(Runspace runspace, SessionFilterState filterState)
{
switch (filterState)
{
case SessionFilterState.All:
return(true);
case SessionFilterState.Opened:
return(runspace.RunspaceStateInfo.State == RunspaceState.Opened);
case SessionFilterState.Disconnected:
return(runspace.RunspaceStateInfo.State == RunspaceState.Disconnected);
case SessionFilterState.Closed:
return(runspace.RunspaceStateInfo.State == RunspaceState.Closed);
case SessionFilterState.Broken:
return(runspace.RunspaceStateInfo.State == RunspaceState.Broken);
}
return(false);
}
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);
}
/// <summary>
/// Gets the matching runspaces by vm guid and session instanceid
/// </summary>
/// <param name="writeobject">if true write the object down the pipeline</param>
/// <param name="filterState">Runspace state filter value.</param>
/// <param name="configurationName">Runspace configuration name filter value.</param>
/// <returns>list of matching runspaces</returns>
private Dictionary<Guid, PSSession> GetMatchingRunspacesByVMIdSessionInstanceId(bool writeobject,
SessionFilterState filterState,
String configurationName)
{
WildcardPattern configurationNamePattern =
String.IsNullOrEmpty(configurationName) ? null : WildcardPattern.Get(configurationName, WildcardOptions.IgnoreCase);
Dictionary<Guid, PSSession> matches = new Dictionary<Guid, PSSession>();
List<PSSession> remoteRunspaceInfos = this.RunspaceRepository.Runspaces;
foreach (Guid vmId in VMId)
{
foreach (Guid sessionInstanceId in InstanceId)
{
var matchingRunspaceInfos = remoteRunspaceInfos
.Where<PSSession>(session => vmId.Equals(session.VMId) &&
sessionInstanceId.Equals(session.InstanceId) &&
QueryRunspaces.TestRunspaceState(session.Runspace, filterState) &&
((configurationNamePattern == null) ? true : configurationNamePattern.IsMatch(session.ConfigurationName)) &&
(session.ComputerType == TargetMachineType.VirtualMachine))
.ToList<PSSession>();
WriteOrAddMatches(matchingRunspaceInfos, writeobject, ref matches);
}
}
return matches;
}
/// <summary>
/// Gets the matching runspaces by vm name or container id with session instanceid
/// </summary>
/// <param name="writeobject">if true write the object down the pipeline</param>
/// <param name="filterState">Runspace state filter value.</param>
/// <param name="configurationName">Runspace configuration name filter value.</param>
/// <param name="isContainer">if true the target is a container instead of virtual machine</param>
/// <returns>list of matching runspaces</returns>
private Dictionary<Guid, PSSession> GetMatchingRunspacesByVMNameContainerIdSessionInstanceId(bool writeobject,
SessionFilterState filterState,
String configurationName,
bool isContainer)
{
String[] inputNames;
TargetMachineType computerType;
bool supportWildChar;
WildcardPattern configurationNamePattern =
String.IsNullOrEmpty(configurationName) ? null : WildcardPattern.Get(configurationName, WildcardOptions.IgnoreCase);
Dictionary<Guid, PSSession> matches = new Dictionary<Guid, PSSession>();
List<PSSession> remoteRunspaceInfos = this.RunspaceRepository.Runspaces;
// vm name support wild characters, while container id does not.
// vm id does not apply in this method, which does not support wild characters either.
if (isContainer)
{
inputNames = ContainerId;
computerType = TargetMachineType.Container;
supportWildChar = false;
}
else
{
inputNames = VMName;
computerType = TargetMachineType.VirtualMachine;
supportWildChar = true;
}
foreach (string inputName in inputNames)
{
WildcardPattern inputNamePattern = WildcardPattern.Get(inputName, WildcardOptions.IgnoreCase);
foreach (Guid sessionInstanceId in InstanceId)
{
var matchingRunspaceInfos = remoteRunspaceInfos
.Where<PSSession>(session => (supportWildChar ? inputNamePattern.IsMatch(session.VMName)
: inputName.Equals(session.ContainerId)) &&
sessionInstanceId.Equals(session.InstanceId) &&
QueryRunspaces.TestRunspaceState(session.Runspace, filterState) &&
((configurationNamePattern == null) ? true : configurationNamePattern.IsMatch(session.ConfigurationName)) &&
(session.ComputerType == computerType))
.ToList<PSSession>();
WriteOrAddMatches(matchingRunspaceInfos, writeobject, ref matches);
}
}
return matches;
}
/// <summary>
/// Gets the matching runspaces by vm guid and optional session name
/// </summary>
/// <param name="writeobject">if true write the object down the pipeline</param>
/// <param name="filterState">Runspace state filter value.</param>
/// <param name="configurationName">Runspace configuration name filter value.</param>
/// <returns>list of matching runspaces</returns>
private Dictionary<Guid, PSSession> GetMatchingRunspacesByVMId(bool writeobject,
SessionFilterState filterState,
String configurationName)
{
String[] sessionNames = { "*" };
WildcardPattern configurationNamePattern =
String.IsNullOrEmpty(configurationName) ? null : WildcardPattern.Get(configurationName, WildcardOptions.IgnoreCase);
Dictionary<Guid, PSSession> matches = new Dictionary<Guid, PSSession>();
List<PSSession> remoteRunspaceInfos = this.RunspaceRepository.Runspaces;
// When "-name" is not set, we use "*" that means matching all .
if (Name != null)
{
sessionNames = Name;
}
foreach (Guid vmId in VMId)
{
foreach (string sessionName in sessionNames)
{
WildcardPattern sessionNamePattern =
String.IsNullOrEmpty(sessionName) ? null : WildcardPattern.Get(sessionName, WildcardOptions.IgnoreCase);
var matchingRunspaceInfos = remoteRunspaceInfos
.Where<PSSession>(session => vmId.Equals(session.VMId) &&
((sessionNamePattern == null) ? true : sessionNamePattern.IsMatch(session.Name)) &&
QueryRunspaces.TestRunspaceState(session.Runspace, filterState) &&
((configurationNamePattern == null) ? true : configurationNamePattern.IsMatch(session.ConfigurationName)) &&
(session.ComputerType == TargetMachineType.VirtualMachine))
.ToList<PSSession>();
WriteOrAddMatches(matchingRunspaceInfos, writeobject, ref matches);
}
}
return matches;
}
protected Dictionary<Guid, PSSession> GetMatchingRunspaces(bool writeobject,
bool writeErrorOnNoMatch,
SessionFilterState filterState,
String configurationName)
{
switch (ParameterSetName)
{
case PSRunspaceCmdlet.ComputerNameParameterSet:
{
return GetMatchingRunspacesByComputerName(writeobject, writeErrorOnNoMatch);
}
case PSRunspaceCmdlet.InstanceIdParameterSet:
{
return GetMatchingRunspacesByRunspaceId(writeobject, writeErrorOnNoMatch);
}
case PSRunspaceCmdlet.NameParameterSet:
{
return GetMatchingRunspacesByName(writeobject, writeErrorOnNoMatch);
}
case PSRunspaceCmdlet.IdParameterSet:
{
return GetMatchingRunspacesBySessionId(writeobject, writeErrorOnNoMatch);
}
//
// writeErrorOnNoMatch should always be false for container/vm id/name inputs
// in Get-PSSession/Remove-PSSession cmdlets
//
// container id + optional session name
case PSRunspaceCmdlet.ContainerIdParameterSet:
{
return GetMatchingRunspacesByVMNameContainerId(writeobject, filterState, configurationName, true);
}
// container id + session instanceid
case PSRunspaceCmdlet.ContainerIdInstanceIdParameterSet:
{
return GetMatchingRunspacesByVMNameContainerIdSessionInstanceId(writeobject, filterState, configurationName, true);
}
// vm Guid + optional session name
case PSRunspaceCmdlet.VMIdParameterSet:
{
return GetMatchingRunspacesByVMId(writeobject, filterState, configurationName);
}
// vm Guid + session instanceid
case PSRunspaceCmdlet.VMIdInstanceIdParameterSet:
{
return GetMatchingRunspacesByVMIdSessionInstanceId(writeobject, filterState, configurationName);
}
// vm name + optional session name
case PSRunspaceCmdlet.VMNameParameterSet:
{
return GetMatchingRunspacesByVMNameContainerId(writeobject, filterState, configurationName, false);
}
// vm name + session instanceid
case PSRunspaceCmdlet.VMNameInstanceIdParameterSet:
{
return GetMatchingRunspacesByVMNameContainerIdSessionInstanceId(writeobject, filterState, configurationName, false);
}
}
return null;
}
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 bool TestRunspaceState(Runspace runspace, SessionFilterState filterState)
{
switch (filterState)
{
case SessionFilterState.All:
return true;
case SessionFilterState.Opened:
return (runspace.RunspaceStateInfo.State == RunspaceState.Opened);
case SessionFilterState.Disconnected:
return (runspace.RunspaceStateInfo.State == RunspaceState.Disconnected);
case SessionFilterState.Closed:
return (runspace.RunspaceStateInfo.State == RunspaceState.Closed);
case SessionFilterState.Broken:
return (runspace.RunspaceStateInfo.State == RunspaceState.Broken);
}
return false;
}
/// <summary>
/// Compares the runspace filter state with the runspace state.
/// </summary>
/// <param name="runspace">Runspace object to test.</param>
/// <param name="filterState">Filter state to compare.</param>
/// <returns>Result of test.</returns>
public static bool TestRunspaceState(Runspace runspace, SessionFilterState filterState)
{
bool result;
switch (filterState)
{
case SessionFilterState.All:
result = true;
break;
case SessionFilterState.Opened:
result = (runspace.RunspaceStateInfo.State == RunspaceState.Opened);
break;
case SessionFilterState.Closed:
result = (runspace.RunspaceStateInfo.State == RunspaceState.Closed);
break;
case SessionFilterState.Disconnected:
result = (runspace.RunspaceStateInfo.State == RunspaceState.Disconnected);
break;
case SessionFilterState.Broken:
result = (runspace.RunspaceStateInfo.State == RunspaceState.Broken);
break;
default:
Dbg.Assert(false, "Invalid SessionFilterState value.");
result = false;
break;
}
return result;
}
/// <summary>
/// Queries all remote computers specified in collection of WSManConnectionInfo objects
/// and returns disconnected PSSession objects ready for connection to server.
/// Returned sessions can be matched to Guids or Names.
/// </summary>
/// <param name="connectionInfos">Collection of WSManConnectionInfo objects.</param>
/// <param name="host">Host for PSSession objects.</param>
/// <param name="stream">Out stream object.</param>
/// <param name="runspaceRepository">Runspace repository.</param>
/// <param name="throttleLimit">Throttle limit.</param>
/// <param name="filterState">Runspace state filter value.</param>
/// <param name="matchIds">Array of session Guids to match to.</param>
/// <param name="matchNames">Array of session Names to match to.</param>
/// <param name="configurationName">Configuration name to match to.</param>
/// <returns>Collection of disconnected PSSession objects.</returns>
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> filteredPSSesions = new Collection<PSSession>();
// Create a query operation for each connection information object.
foreach (WSManConnectionInfo connectionInfo in connectionInfos)
{
Runspace[] runspaces = null;
try
{
runspaces = Runspace.GetRunspaces(connectionInfo, host, BuiltInTypesTable);
}
catch (System.Management.Automation.RuntimeException e)
{
if (e.InnerException is InvalidOperationException)
{
// The Get-WSManInstance cmdlet used to query remote computers for runspaces will throw
// an Invalid Operation (inner) exception if the connectInfo object is invalid, including
// invalid computer names.
// We don't want to propagate the exception so just write error here.
if (stream.ObjectWriter != null && stream.ObjectWriter.IsOpen)
{
int errorCode;
string msg = StringUtil.Format(RemotingErrorIdStrings.QueryForRunspacesFailed, connectionInfo.ComputerName, ExtractMessage(e.InnerException, out errorCode));
string FQEID = WSManTransportManagerUtils.GetFQEIDFromTransportError(errorCode, "RemotePSSessionQueryFailed");
Exception reason = new RuntimeException(msg, e.InnerException);
ErrorRecord errorRecord = new ErrorRecord(reason, FQEID, ErrorCategory.InvalidOperation, connectionInfo);
stream.ObjectWriter.Write((Action<Cmdlet>)(cmdlet => cmdlet.WriteError(errorRecord)));
}
}
else
{
throw;
}
}
if (_stopProcessing)
{
break;
}
// Add all runspaces meeting filter criteria to collection.
if (runspaces != null)
{
// Convert configuration name into shell Uri for comparison.
string shellUri = null;
if (!string.IsNullOrEmpty(configurationName))
{
shellUri = (configurationName.IndexOf(
System.Management.Automation.Remoting.Client.WSManNativeApi.ResourceURIPrefix, StringComparison.OrdinalIgnoreCase) != -1) ?
configurationName : System.Management.Automation.Remoting.Client.WSManNativeApi.ResourceURIPrefix + configurationName;
}
foreach (Runspace runspace in runspaces)
{
// Filter returned runspaces by ConfigurationName if provided.
if (shellUri != null)
{
// Compare with returned shell Uri in connection info.
WSManConnectionInfo wsmanConnectionInfo = runspace.ConnectionInfo as WSManConnectionInfo;
if (wsmanConnectionInfo != null &&
!shellUri.Equals(wsmanConnectionInfo.ShellUri, StringComparison.OrdinalIgnoreCase))
{
continue;
}
}
// Check the repository for an existing viable PSSession for
// this runspace (based on instanceId). Use the existing
// local runspace instead of the one returned from the server
// query.
PSSession existingPSSession = null;
if (runspaceRepository != null)
{
existingPSSession = runspaceRepository.GetItem(runspace.InstanceId);
}
if (existingPSSession != null &&
UseExistingRunspace(existingPSSession.Runspace, runspace))
{
if (TestRunspaceState(existingPSSession.Runspace, filterState))
{
filteredPSSesions.Add(existingPSSession);
}
}
else if (TestRunspaceState(runspace, filterState))
{
filteredPSSesions.Add(new PSSession(runspace as RemoteRunspace));
}
}
}
}
// Return only PSSessions that match provided Ids or Names.
if ((matchIds != null) && (filteredPSSesions.Count > 0))
{
Collection<PSSession> matchIdsSessions = new Collection<PSSession>();
foreach (Guid id in matchIds)
{
bool matchFound = false;
foreach (PSSession psSession in filteredPSSesions)
{
if (_stopProcessing)
{
break;
}
if (psSession.Runspace.InstanceId.Equals(id))
{
matchFound = true;
matchIdsSessions.Add(psSession);
break;
}
}
if (!matchFound && stream.ObjectWriter != null && stream.ObjectWriter.IsOpen)
{
string msg = StringUtil.Format(RemotingErrorIdStrings.SessionIdMatchFailed, id);
Exception reason = new RuntimeException(msg);
ErrorRecord errorRecord = new ErrorRecord(reason, "PSSessionIdMatchFail", ErrorCategory.InvalidOperation, id);
stream.ObjectWriter.Write((Action<Cmdlet>)(cmdlet => cmdlet.WriteError(errorRecord)));
}
}
// Return all found sessions.
return matchIdsSessions;
}
else if ((matchNames != null) && (filteredPSSesions.Count > 0))
{
Collection<PSSession> matchNamesSessions = new Collection<PSSession>();
foreach (string name in matchNames)
{
WildcardPattern namePattern = WildcardPattern.Get(name, WildcardOptions.IgnoreCase);
bool matchFound = false;
foreach (PSSession psSession in filteredPSSesions)
{
if (_stopProcessing)
{
break;
}
if (namePattern.IsMatch(((RemoteRunspace)psSession.Runspace).RunspacePool.RemoteRunspacePoolInternal.Name))
{
matchFound = true;
matchNamesSessions.Add(psSession);
}
}
if (!matchFound && stream.ObjectWriter != null && stream.ObjectWriter.IsOpen)
{
string msg = StringUtil.Format(RemotingErrorIdStrings.SessionNameMatchFailed, name);
Exception reason = new RuntimeException(msg);
ErrorRecord errorRecord = new ErrorRecord(reason, "PSSessionNameMatchFail", ErrorCategory.InvalidOperation, name);
stream.ObjectWriter.Write((Action<Cmdlet>)(cmdlet => cmdlet.WriteError(errorRecord)));
}
}
return matchNamesSessions;
}
else
{
// Return all collected sessions.
return filteredPSSesions;
}
}
