internal static bool HasRepeatingRunspaces(PSSession[] runspaceInfos)
{
if (runspaceInfos == null)
{
throw PSTraceSource.NewArgumentNullException("runspaceInfos");
}
if (runspaceInfos.GetLength(0) == 0)
{
throw PSTraceSource.NewArgumentException("runspaceInfos");
}
for (int i = 0; i < runspaceInfos.GetLength(0); i++)
{
for (int k = 0; k < runspaceInfos.GetLength(0); k++)
{
if (i != k)
{
if (runspaceInfos[i].Runspace.InstanceId == runspaceInfos[k].Runspace.InstanceId)
{
return true;
}
}
}
}
return false;
}
private PSSession ConnectSession(PSSession session, out Exception ex)
{
ex = null;
if ((session == null) || ((session.Runspace.RunspaceStateInfo.State != RunspaceState.Opened) && (session.Runspace.RunspaceStateInfo.State != RunspaceState.Disconnected)))
{
return null;
}
if (session.Runspace.RunspaceStateInfo.State != RunspaceState.Opened)
{
try
{
session.Runspace.Connect();
}
catch (PSInvalidOperationException exception)
{
ex = exception;
}
catch (InvalidRunspaceStateException exception2)
{
ex = exception2;
}
catch (RuntimeException exception3)
{
ex = exception3;
}
if (ex != null)
{
return null;
}
}
return session;
}
private void GetAvailableViaPsrpSession(string[] moduleNames, System.Management.Automation.Runspaces.PSSession session)
{
foreach (PSModuleInfo info in this.GetAvailableViaPsrpSessionCore(moduleNames, session.Runspace))
{
RemoteDiscoveryHelper.AssociatePSModuleInfoWithSession(info, session);
base.WriteObject(info);
}
}
internal static bool ExceedMaximumAllowableRunspaces(PSSession[] runspaceInfos)
{
if (runspaceInfos == null)
{
throw PSTraceSource.NewArgumentNullException("runspaceInfos");
}
if (runspaceInfos.GetLength(0) == 0)
{
throw PSTraceSource.NewArgumentException("runspaceInfos");
}
return false;
}
internal PSRemotingJob(PSSession[] remoteRunspaceInfos, List<IThrottleOperation> runspaceHelpers, string remoteCommand, int throttleLimit, string name) : base(remoteCommand, name)
{
this.moreData = true;
this.hideComputerName = true;
this.throttleManager = new ThrottleManager();
this._syncObject = new object();
for (int i = 0; i < remoteRunspaceInfos.Length; i++)
{
ExecutionCmdletHelperRunspace helper = (ExecutionCmdletHelperRunspace) runspaceHelpers[i];
PSRemotingChildJob item = new PSRemotingChildJob(remoteCommand, helper, this.throttleManager);
item.StateChanged += new EventHandler<JobStateEventArgs>(this.HandleChildJobStateChanged);
item.JobUnblocked += new EventHandler(this.HandleJobUnblocked);
base.ChildJobs.Add(item);
}
this.CommonInit(throttleLimit, runspaceHelpers);
}
/// <summary>
/// Creates a PSSession object from the provided remote runspace object.
/// If psCmdlet argument is non-null, then the new PSSession object is added to the
/// session runspace repository (Get-PSSession).
/// </summary>
/// <param name="runspace">Runspace for the new PSSession.</param>
/// <param name="transportName">Optional transport name.</param>
/// <param name="psCmdlet">Optional cmdlet associated with the PSSession creation.</param>
public static PSSession Create(
Runspace runspace,
string transportName,
PSCmdlet psCmdlet)
{
if (!(runspace is RemoteRunspace remoteRunspace))
{
throw new PSArgumentException(RemotingErrorIdStrings.InvalidPSSessionArgument);
}
var psSession = new PSSession(remoteRunspace)
{
_transportName = transportName
};
if (psCmdlet != null)
{
psCmdlet.RunspaceRepository.Add(psSession);
}
return(psSession);
}
public PSModuleInfo ImportPSSession(PSSession session, Action<PSDataStreams> psDataStreamAction)
{
if (session == null)
{
throw new ArgumentOutOfRangeException("session");
}
var command = new PSCommand();
command.AddCommand(Constants.SessionScripts.ImportPSSession);
command.AddParameter(Constants.ParameterNameStrings.Session, session);
Collection<PSModuleInfo> modules;
try
{
modules = this.runspace.ExecuteCommand<PSModuleInfo>(command, psDataStreamAction);
if (modules.Count > 0) return modules[0];
}
catch (Exception)
{
return null;
}
return null;
}
private void WriteRemoteObject(PSObject psObject, PSSession session)
{
if (psObject != null)
{
if (psObject.Properties[RemotingConstants.ComputerNameNoteProperty] == null)
{
psObject.Properties.Add(new PSNoteProperty(RemotingConstants.ComputerNameNoteProperty, session.ComputerName));
}
if (psObject.Properties[RemotingConstants.RunspaceIdNoteProperty] == null)
{
psObject.Properties.Add(new PSNoteProperty(RemotingConstants.RunspaceIdNoteProperty, session.InstanceId));
}
if (psObject.Properties[RemotingConstants.ShowComputerNameNoteProperty] == null)
{
psObject.Properties.Add(new PSNoteProperty(RemotingConstants.ShowComputerNameNoteProperty, true));
}
base.WriteObject(psObject);
}
}
private PSRemotingJob FindJobForSession(PSSession session)
{
PSRemotingJob job = null;
RemoteRunspace runspace = session.Runspace as RemoteRunspace;
if ((runspace == null) || (runspace.RemoteCommand != null))
{
return null;
}
foreach (Job job2 in base.JobRepository.Jobs)
{
if (!(job2 is PSRemotingJob))
{
continue;
}
foreach (PSRemotingChildJob job3 in job2.ChildJobs)
{
if (job3.Runspace.InstanceId.Equals(session.InstanceId) && (job3.JobStateInfo.State == JobState.Disconnected))
{
job = (PSRemotingJob) job2;
break;
}
}
if (job != null)
{
return job;
}
}
return job;
}
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);
}
private IList<PSModuleInfo> ImportModule_RemotelyViaPsrpSession(
ImportModuleOptions importModuleOptions,
string moduleName,
ModuleSpecification fullyQualifiedName,
PSSession psSession)
{
//
// import the module in the remote session first
//
List<PSObject> remotelyImportedModules;
using (var powerShell = System.Management.Automation.PowerShell.Create())
{
powerShell.Runspace = psSession.Runspace;
powerShell.AddCommand("Import-Module");
powerShell.AddParameter("DisableNameChecking", this.DisableNameChecking);
powerShell.AddParameter("PassThru", true);
if (fullyQualifiedName != null)
{
powerShell.AddParameter("FullyQualifiedName", fullyQualifiedName);
}
else
{
powerShell.AddParameter("Name", moduleName);
if (this.MinimumVersion != null)
{
powerShell.AddParameter("Version", this.MinimumVersion);
}
if (this.RequiredVersion != null)
{
powerShell.AddParameter("RequiredVersion", this.RequiredVersion);
}
if (this.MaximumVersion != null)
{
powerShell.AddParameter("MaximumVersion", this.MaximumVersion);
}
}
if (this.ArgumentList != null)
{
powerShell.AddParameter("ArgumentList", this.ArgumentList);
}
if (this.BaseForce)
{
powerShell.AddParameter("Force", true);
}
string errorMessageTemplate = string.Format(
CultureInfo.InvariantCulture,
Modules.RemoteDiscoveryRemotePsrpCommandFailed,
string.Format(CultureInfo.InvariantCulture, "Import-Module -Name '{0}'", moduleName));
remotelyImportedModules = RemoteDiscoveryHelper.InvokePowerShell(
powerShell,
this.CancellationToken,
this,
errorMessageTemplate).ToList();
}
List<PSModuleInfo> result = new List<PSModuleInfo>();
foreach (PSObject remotelyImportedModule in remotelyImportedModules)
{
PSPropertyInfo nameProperty = remotelyImportedModule.Properties["Name"];
if (nameProperty != null)
{
string remoteModuleName = (string)LanguagePrimitives.ConvertTo(
nameProperty.Value,
typeof(string),
CultureInfo.InvariantCulture);
PSPropertyInfo helpInfoProperty = remotelyImportedModule.Properties["HelpInfoUri"];
string remoteHelpInfoUri = null;
if (helpInfoProperty != null)
{
remoteHelpInfoUri = (string)LanguagePrimitives.ConvertTo(
helpInfoProperty.Value,
typeof(string),
CultureInfo.InvariantCulture);
}
PSPropertyInfo guidProperty = remotelyImportedModule.Properties["Guid"];
Guid remoteModuleGuid = Guid.Empty;
if (guidProperty != null)
{
LanguagePrimitives.TryConvertTo(guidProperty.Value, out remoteModuleGuid);
}
PSPropertyInfo versionProperty = remotelyImportedModule.Properties["Version"];
Version remoteModuleVersion = null;
if (versionProperty != null)
{
Version tmp;
if (LanguagePrimitives.TryConvertTo<Version>(versionProperty.Value, CultureInfo.InvariantCulture, out tmp))
{
remoteModuleVersion = tmp;
}
}
PSModuleInfo moduleInfo = ImportModule_RemotelyViaPsrpSession_SinglePreimportedModule(
importModuleOptions,
remoteModuleName,
remoteModuleVersion,
psSession);
// Set the HelpInfoUri and Guid as necessary, so that Save-Help can work with this module object
// to retrieve help files from the remote site.
if (moduleInfo != null)
{
// set the HelpInfoUri if it's needed
if (string.IsNullOrEmpty(moduleInfo.HelpInfoUri) && !string.IsNullOrEmpty(remoteHelpInfoUri))
{
moduleInfo.SetHelpInfoUri(remoteHelpInfoUri);
}
// set the Guid if it's needed
if (remoteModuleGuid != Guid.Empty)
{
moduleInfo.SetGuid(remoteModuleGuid);
}
result.Add(moduleInfo);
}
}
}
return result;
}
private void GetAvailableViaPsrpSession(string[] names, IDictionary<string, ModuleSpecification> moduleSpecTable, PSSession session)
{
var remoteModules = GetAvailableViaPsrpSessionCore(names, session.Runspace);
foreach (var remoteModule in remoteModules.Where(remoteModule => ModuleMatch(remoteModule, moduleSpecTable, PSEdition))
)
{
RemoteDiscoveryHelper.AssociatePSModuleInfoWithSession(remoteModule, session);
this.WriteObject(remoteModule);
}
}
/// <summary>
/// Helper method to append computer name and session GUID
/// note properties to the PSObject before it is written.
/// </summary>
/// <param name="psObject">PSObject</param>
/// <param name="session">PSSession</param>
private void WriteRemoteObject(
PSObject psObject,
PSSession session)
{
if (psObject == null)
{
return;
}
// Add note properties for this session if they don't already exist.
if (psObject.Properties[RemotingConstants.ComputerNameNoteProperty] == null)
{
psObject.Properties.Add(new PSNoteProperty(RemotingConstants.ComputerNameNoteProperty, session.ComputerName));
}
if (psObject.Properties[RemotingConstants.RunspaceIdNoteProperty] == null)
{
psObject.Properties.Add(new PSNoteProperty(RemotingConstants.RunspaceIdNoteProperty, session.InstanceId));
}
if (psObject.Properties[RemotingConstants.ShowComputerNameNoteProperty] == null)
{
psObject.Properties.Add(new PSNoteProperty(RemotingConstants.ShowComputerNameNoteProperty, true));
}
WriteObject(psObject);
}
internal DisconnectRunspaceOperation(PSSession session, ObjectStream stream)
{
this.remoteSession = session;
this.writeStream = stream;
this.remoteSession.Runspace.StateChanged += new EventHandler<RunspaceStateEventArgs>(this.StateCallBackHandler);
}
private bool ValidateIdleTimeout(PSSession session)
{
int idleTimeout = session.Runspace.ConnectionInfo.IdleTimeout;
int maxIdleTimeout = session.Runspace.ConnectionInfo.MaxIdleTimeout;
int num3 = 0xea60;
if ((idleTimeout == -1) || ((idleTimeout <= maxIdleTimeout) && (idleTimeout >= num3)))
{
return true;
}
ErrorRecord errorRecord = new ErrorRecord(new RuntimeException(StringUtil.Format(RemotingErrorIdStrings.CannotDisconnectSessionWithInvalidIdleTimeout, new object[] { session.Name, idleTimeout / 0x3e8, maxIdleTimeout / 0x3e8, num3 / 0x3e8 })), "CannotDisconnectSessionWithInvalidIdleTimeout", ErrorCategory.InvalidArgument, session);
base.WriteError(errorRecord);
return false;
}
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);
}
}
internal DisconnectRunspaceOperation(PSSession session, ObjectStream stream)
{
_remoteSession = session;
_writeStream = stream;
_remoteSession.Runspace.StateChanged += StateCallBackHandler;
}
/// <summary>
/// Connects session, collects command output data in a job object.
/// If a PSRemotingJob object is passed in then that job will be
/// (re)connected. Otherwise a new job object will be created that
/// will be connected to the session's running command.
/// </summary>
/// <param name="session">PSSession object.</param>
/// <param name="job">Job object to connect to.</param>
private void ConnectSessionToJob(PSSession session, PSRemotingJob job = null)
{
// Otherwise create a new job object in the disconnected state for this
// session and then connect it.
bool newJobCreated = false;
if (job == null)
{
// The PSRemoting job object uses helper objects to track remote command execution.
List<IThrottleOperation> helpers = new List<IThrottleOperation>();
// Create the remote pipeline object that will represent the running command
// on the server machine. This object will be in the disconnected state.
Pipeline remotePipeline = session.Runspace.CreateDisconnectedPipeline();
// Create a disconnected runspace helper for this remote command.
helpers.Add(new DisconnectedJobOperation(remotePipeline));
// Create the job object in a disconnected state. Note that the job name
// will be autogenerated.
job = new PSRemotingJob(helpers, 0, JobName, false);
job.PSJobTypeName = InvokeCommandCommand.RemoteJobType;
job.HideComputerName = false;
newJobCreated = true;
}
if (job.JobStateInfo.State == JobState.Disconnected)
{
// Connect the job to the remote command running on the server.
job.ConnectJob(session.Runspace.InstanceId);
// Add the created job to the store if it was connected successfully.
if (newJobCreated)
{
JobRepository.Add(job);
}
}
if (CheckForDebugMode(session, true)) { return; }
// Write the job object to output.
WriteObject(job);
}
private IList<PSModuleInfo> ImportModule_RemotelyViaPsrpSession(
ImportModuleOptions importModuleOptions,
IEnumerable<string> moduleNames,
IEnumerable<ModuleSpecification> fullyQualifiedNames,
PSSession psSession)
{
var remotelyImportedModules = new List<PSModuleInfo>();
if (moduleNames != null)
{
foreach (string moduleName in moduleNames)
{
var tmp = ImportModule_RemotelyViaPsrpSession(importModuleOptions, moduleName, null, psSession);
remotelyImportedModules.AddRange(tmp);
}
}
if (fullyQualifiedNames != null)
{
foreach (var fullyQualifiedName in fullyQualifiedNames)
{
var tmp = ImportModule_RemotelyViaPsrpSession(importModuleOptions, null, fullyQualifiedName, psSession);
remotelyImportedModules.AddRange(tmp);
}
}
return remotelyImportedModules;
}
/// <summary>
/// Helper method to connect the runspace. If the session/runspace can't
/// be connected or fails to be connected then a null PSSessionobject is
/// returned.
/// </summary>
/// <param name="session">Session to connect.</param>
/// <param name="ex">Optional exception object.</param>
/// <returns>Connected session or null.</returns>
private PSSession ConnectSession(PSSession session, out Exception ex)
{
ex = null;
if (session == null ||
(session.Runspace.RunspaceStateInfo.State != RunspaceState.Opened &&
session.Runspace.RunspaceStateInfo.State != RunspaceState.Disconnected))
{
return null;
}
else if (session.Runspace.RunspaceStateInfo.State == RunspaceState.Opened)
{
return session;
}
try
{
session.Runspace.Connect();
}
catch (PSInvalidOperationException e)
{
ex = e;
}
catch (InvalidRunspaceStateException e)
{
ex = e;
}
catch (RuntimeException e)
{
ex = e;
}
return (ex == null) ? session : null;
}
private PSModuleInfo ImportModule_RemotelyViaPsrpSession_SinglePreimportedModule(
ImportModuleOptions importModuleOptions,
string remoteModuleName,
Version remoteModuleVersion,
PSSession psSession)
{
string temporaryModulePath = RemoteDiscoveryHelper.GetModulePath(
remoteModuleName,
remoteModuleVersion,
psSession.ComputerName,
this.Context.CurrentRunspace);
string wildcardEscapedPath = WildcardPattern.Escape(temporaryModulePath);
try
{
//
// avoid importing a module twice
//
string localPsm1File = Path.Combine(temporaryModulePath, Path.GetFileName(temporaryModulePath) + ".psm1");
PSModuleInfo alreadyImportedModule = this.IsModuleImportUnnecessaryBecauseModuleIsAlreadyLoaded(
localPsm1File, this.BasePrefix, importModuleOptions);
if (alreadyImportedModule != null)
{
return alreadyImportedModule;
}
//
// create proxy module in a temporary folder
//
using (var powerShell = System.Management.Automation.PowerShell.Create(RunspaceMode.CurrentRunspace))
{
powerShell.AddCommand("Export-PSSession");
powerShell.AddParameter("OutputModule", wildcardEscapedPath);
powerShell.AddParameter("AllowClobber", true);
powerShell.AddParameter("Module", remoteModuleName); // remoteModulePath is currently unsupported by Get-Command and implicit remoting
powerShell.AddParameter("Force", true);
powerShell.AddParameter("FormatTypeName", "*");
powerShell.AddParameter("Session", psSession);
string errorMessageTemplate = string.Format(
CultureInfo.InvariantCulture,
Modules.RemoteDiscoveryFailedToGenerateProxyForRemoteModule,
remoteModuleName);
int numberOfLocallyCreatedFiles = RemoteDiscoveryHelper.InvokePowerShell(powerShell, this.CancellationToken, this, errorMessageTemplate).Count();
if (numberOfLocallyCreatedFiles == 0)
{
return null;
}
}
//
// rename the psd1 file
//
string localPsd1File = Path.Combine(temporaryModulePath, remoteModuleName + ".psd1");
if (File.Exists(localPsd1File))
{
File.Delete(localPsd1File);
}
File.Move(
sourceFileName: Path.Combine(temporaryModulePath, Path.GetFileName(temporaryModulePath) + ".psd1"),
destFileName: localPsd1File);
string wildcardEscapedPsd1Path = WildcardPattern.Escape(localPsd1File);
//
// import the proxy module just as any other local module
//
object[] oldArgumentList = this.ArgumentList;
try
{
this.ArgumentList = new object[] { psSession };
ImportModule_LocallyViaName(importModuleOptions, wildcardEscapedPsd1Path);
}
finally
{
this.ArgumentList = oldArgumentList;
}
//
// make sure the temporary folder gets removed when the module is removed
//
PSModuleInfo moduleInfo;
string psm1Path = Path.Combine(temporaryModulePath, Path.GetFileName(temporaryModulePath) + ".psm1");
if (!this.Context.Modules.ModuleTable.TryGetValue(psm1Path, out moduleInfo))
{
if (Directory.Exists(temporaryModulePath))
{
Directory.Delete(temporaryModulePath, recursive: true);
}
return null;
}
const string onRemoveScriptBody = @"
Microsoft.PowerShell.Management\Remove-Item `
-LiteralPath $temporaryModulePath `
-Force `
-Recurse `
-ErrorAction SilentlyContinue
if ($previousOnRemoveScript -ne $null)
{
& $previousOnRemoveScript $args
}
";
ScriptBlock onRemoveScriptBlock = this.Context.Engine.ParseScriptBlock(onRemoveScriptBody, false);
onRemoveScriptBlock = onRemoveScriptBlock.GetNewClosure(); // create a separate scope for variables set below
onRemoveScriptBlock.Module.SessionState.PSVariable.Set("temporaryModulePath", temporaryModulePath);
onRemoveScriptBlock.Module.SessionState.PSVariable.Set("previousOnRemoveScript", moduleInfo.OnRemove);
moduleInfo.OnRemove = onRemoveScriptBlock;
return moduleInfo;
}
catch
{
if (Directory.Exists(temporaryModulePath))
{
Directory.Delete(temporaryModulePath, recursive: true);
}
throw;
}
}
/// <summary>
/// Helper method to attempt to retrieve a disconnected runspace object
/// from the server, based on the provided session object.
/// </summary>
/// <param name="session">PSSession</param>
/// <returns>PSSession</returns>
private PSSession TryGetSessionFromServer(PSSession session)
{
RemoteRunspace remoteRunspace = session.Runspace as RemoteRunspace;
if (remoteRunspace == null)
{
return null;
}
remoteRunspace = null;
Runspace[] runspaces = Runspace.GetRunspaces(session.Runspace.ConnectionInfo, this.Host, QueryRunspaces.BuiltInTypesTable);
foreach (Runspace runspace in runspaces)
{
if (runspace.InstanceId == session.Runspace.InstanceId)
{
remoteRunspace = runspace as RemoteRunspace;
break;
}
}
if (remoteRunspace != null)
{
// Try inserting connected runspace into existing PSSession.
session = session.InsertRunspace(remoteRunspace) ? session : new PSSession(remoteRunspace);
return session;
}
return null;
}
/// <summary>
/// Handles state changes for Runspace
/// </summary>
/// <param name="sender">Sender of this event</param>
/// <param name="stateEventArgs">Event information object which describes
/// the event which triggered this method</param>
private void HandleRunspaceStateChanged(object sender, OperationStateEventArgs stateEventArgs)
{
if (sender == null)
{
throw PSTraceSource.NewArgumentNullException("sender");
}
if (stateEventArgs == null)
{
throw PSTraceSource.NewArgumentNullException("stateEventArgs");
}
RunspaceStateEventArgs runspaceStateEventArgs =
stateEventArgs.BaseEvent as RunspaceStateEventArgs;
RunspaceStateInfo stateInfo = runspaceStateEventArgs.RunspaceStateInfo;
RunspaceState state = stateInfo.State;
OpenRunspaceOperation operation = sender as OpenRunspaceOperation;
RemoteRunspace remoteRunspace = operation.OperatedRunspace;
// since we got state changed event..we dont need to listen on
// URI redirections anymore
if (null != remoteRunspace)
{
remoteRunspace.URIRedirectionReported -= HandleURIDirectionReported;
}
PipelineWriter writer = _stream.ObjectWriter;
Exception reason = runspaceStateEventArgs.RunspaceStateInfo.Reason;
switch (state)
{
case RunspaceState.Opened:
{
// Indicates that runspace is successfully opened
// Write it to PipelineWriter to be handled in
// HandleRemoteRunspace
PSSession remoteRunspaceInfo = new PSSession(remoteRunspace);
this.RunspaceRepository.Add(remoteRunspaceInfo);
Action<Cmdlet> outputWriter = delegate (Cmdlet cmdlet)
{
cmdlet.WriteObject(remoteRunspaceInfo);
};
if (writer.IsOpen)
{
writer.Write(outputWriter);
}
}
break;
case RunspaceState.Broken:
{
// Open resulted in a broken state. Extract reason
// and write an error record
// set the transport message in the error detail so that
// the user can directly get to see the message without
// having to mine through the error record details
PSRemotingTransportException transException =
reason as PSRemotingTransportException;
String errorDetails = null;
int transErrorCode = 0;
if (transException != null)
{
OpenRunspaceOperation senderAsOp = sender as OpenRunspaceOperation;
transErrorCode = transException.ErrorCode;
if (senderAsOp != null)
{
String host = senderAsOp.OperatedRunspace.ConnectionInfo.ComputerName;
if (transException.ErrorCode ==
System.Management.Automation.Remoting.Client.WSManNativeApi.ERROR_WSMAN_REDIRECT_REQUESTED)
{
// Handling a special case for redirection..we should talk about
// AllowRedirection parameter and WSManMaxRedirectionCount preference
// variables
string message = PSRemotingErrorInvariants.FormatResourceString(
RemotingErrorIdStrings.URIRedirectionReported,
transException.Message,
"MaximumConnectionRedirectionCount",
Microsoft.PowerShell.Commands.PSRemotingBaseCmdlet.DEFAULT_SESSION_OPTION,
"AllowRedirection");
errorDetails = "[" + host + "] " + message;
}
else
{
errorDetails = "[" + host + "] ";
if (!String.IsNullOrEmpty(transException.Message))
{
errorDetails += transException.Message;
}
else if (!String.IsNullOrEmpty(transException.TransportMessage))
{
errorDetails += transException.TransportMessage;
}
}
}
}
// add host identification information in data structure handler message
PSRemotingDataStructureException protoExeption = reason as PSRemotingDataStructureException;
if (protoExeption != null)
{
OpenRunspaceOperation senderAsOp = sender as OpenRunspaceOperation;
if (senderAsOp != null)
{
String host = senderAsOp.OperatedRunspace.ConnectionInfo.ComputerName;
errorDetails = "[" + host + "] " + protoExeption.Message;
}
}
if (reason == null)
{
reason = new RuntimeException(this.GetMessage(RemotingErrorIdStrings.RemoteRunspaceOpenUnknownState, state));
}
string fullyQualifiedErrorId = WSManTransportManagerUtils.GetFQEIDFromTransportError(
transErrorCode,
_defaultFQEID);
if (WSManNativeApi.ERROR_WSMAN_NO_LOGON_SESSION_EXIST == transErrorCode)
{
errorDetails += System.Environment.NewLine + String.Format(System.Globalization.CultureInfo.CurrentCulture, RemotingErrorIdStrings.RemotingErrorNoLogonSessionExist);
}
ErrorRecord errorRecord = new ErrorRecord(reason,
remoteRunspace, fullyQualifiedErrorId,
ErrorCategory.OpenError, null, null,
null, null, null, errorDetails, null);
Action<Cmdlet> errorWriter = delegate (Cmdlet cmdlet)
{
//
// In case of PSDirectException, we should output the precise error message
// in inner exception instead of the generic one in outer exception.
//
if ((errorRecord.Exception != null) &&
(errorRecord.Exception.InnerException != null))
{
PSDirectException ex = errorRecord.Exception.InnerException as PSDirectException;
if (ex != null)
{
errorRecord = new ErrorRecord(errorRecord.Exception.InnerException,
errorRecord.FullyQualifiedErrorId,
errorRecord.CategoryInfo.Category,
errorRecord.TargetObject);
}
}
cmdlet.WriteError(errorRecord);
};
if (writer.IsOpen)
{
writer.Write(errorWriter);
}
_toDispose.Add(remoteRunspace);
}
break;
case RunspaceState.Closed:
{
// The runspace was closed possibly because the user
// hit ctrl-C when runspaces were being opened or Dispose has been
// called when there are open runspaces
Uri connectionUri = WSManConnectionInfo.ExtractPropertyAsWsManConnectionInfo<Uri>(remoteRunspace.ConnectionInfo,
"ConnectionUri", null);
String message =
GetMessage(RemotingErrorIdStrings.RemoteRunspaceClosed,
(connectionUri != null) ?
connectionUri.AbsoluteUri : string.Empty);
Action<Cmdlet> verboseWriter = delegate (Cmdlet cmdlet)
{
cmdlet.WriteVerbose(message);
};
if (writer.IsOpen)
{
writer.Write(verboseWriter);
}
// runspace may not have been opened in certain cases
// like when the max memory is set to 25MB, in such
// cases write an error record
if (reason != null)
{
ErrorRecord errorRecord = new ErrorRecord(reason,
"PSSessionStateClosed",
ErrorCategory.OpenError, remoteRunspace);
Action<Cmdlet> errorWriter = delegate (Cmdlet cmdlet)
{
cmdlet.WriteError(errorRecord);
};
if (writer.IsOpen)
{
writer.Write(errorWriter);
}
}
}
break;
}// switch
} // HandleRunspaceStateChanged
/// <summary>
/// Helper method to search the local PS client job repository
/// for a job associated with the provided session.
/// </summary>
/// <param name="session">PSSession object.</param>
/// <returns>Associated job object from the job repository.</returns>
private PSRemotingJob FindJobForSession(PSSession session)
{
PSRemotingJob job = null;
RemoteRunspace remoteSessionRunspace = session.Runspace as RemoteRunspace;
if (remoteSessionRunspace == null ||
remoteSessionRunspace.RemoteCommand != null)
{
// The provided session is created for *reconstruction* and we
// cannot connect a previous job even if one exists. A new job
// will have to be created.
return null;
}
foreach (Job repJob in this.JobRepository.Jobs)
{
if (repJob is PSRemotingJob)
{
foreach (PSRemotingChildJob childJob in repJob.ChildJobs)
{
if (childJob.Runspace.InstanceId.Equals(session.InstanceId) &&
(childJob.JobStateInfo.State == JobState.Disconnected))
{
job = (PSRemotingJob)repJob;
break;
}
}
if (job != null)
{
break;
}
}
}
return job;
}
private void ConnectSessionToJob(PSSession session, PSRemotingJob job = null)
{
bool flag = false;
if (job == null)
{
List<IThrottleOperation> helpers = new List<IThrottleOperation>();
Pipeline pipeline = session.Runspace.CreateDisconnectedPipeline();
helpers.Add(new DisconnectedJobOperation(pipeline));
job = new PSRemotingJob(helpers, 0, this.JobName, false);
job.PSJobTypeName = InvokeCommandCommand.RemoteJobType;
job.HideComputerName = false;
flag = true;
}
if (job.JobStateInfo.State == JobState.Disconnected)
{
job.ConnectJob(session.Runspace.InstanceId);
if (flag)
{
base.JobRepository.Add(job);
}
}
base.WriteObject(job);
}
/// <summary>
/// Queries the remote computer for the specified session, creates a disconnected
/// session object, connects the runspace/command and collects command data.
/// Command output is either returned (OutTarget.Host) or collected
/// in a job object that is returned (OutTarget.Job).
/// </summary>
/// <param name="name">Name of session to find.</param>
/// <param name="instanceId">Instance Id of session to find.</param>
private void QueryForAndConnectCommands(string name, Guid instanceId)
{
WSManConnectionInfo connectionInfo = GetConnectionObject();
// Retrieve all disconnected runspaces on the remote computer.
Runspace[] runspaces;
try
{
runspaces = Runspace.GetRunspaces(connectionInfo, this.Host, QueryRunspaces.BuiltInTypesTable);
}
catch (System.Management.Automation.RuntimeException e)
{
int errorCode;
string msg = StringUtil.Format(RemotingErrorIdStrings.QueryForRunspacesFailed, connectionInfo.ComputerName,
QueryRunspaces.ExtractMessage(e.InnerException, out errorCode));
string FQEID = WSManTransportManagerUtils.GetFQEIDFromTransportError(errorCode, "ReceivePSSessionQueryForSessionFailed");
Exception reason = new RuntimeException(msg, e.InnerException);
ErrorRecord errorRecord = new ErrorRecord(reason, FQEID, ErrorCategory.InvalidOperation, connectionInfo);
WriteError(errorRecord);
return;
}
// 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;
}
// Connect selected runspace/command and direct command output to host
// or job objects.
foreach (Runspace runspace in runspaces)
{
if (_stopProcessing)
{
break;
}
// 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;
}
}
// Find specified session.
bool haveMatch = false;
if (!string.IsNullOrEmpty(name) &&
string.Compare(name, ((RemoteRunspace)runspace).RunspacePool.RemoteRunspacePoolInternal.Name, StringComparison.OrdinalIgnoreCase) == 0)
{
// Selected by friendly name.
haveMatch = true;
}
else if (instanceId.Equals(runspace.InstanceId))
{
// Selected by instance Id (note that session/runspace/runspacepool instanceIds are identical.)
haveMatch = true;
}
if (haveMatch &&
ShouldProcess(((RemoteRunspace)runspace).PSSessionName, VerbsCommunications.Receive))
{
// Check the local repository for an existing viable session.
PSSession locSession = this.RunspaceRepository.GetItem(runspace.InstanceId);
// Connect the session here. If it fails (connectedSession == null) revert to the
// reconstruct method.
Exception ex;
PSSession connectedSession = ConnectSession(locSession, out ex);
if (connectedSession != null)
{
// Make sure that this connected session is included in the PSSession repository.
// If it already exists then replace it because we want the latest/connected session in the repository.
this.RunspaceRepository.AddOrReplace(connectedSession);
// Since we have a local runspace we will do a *reconnect* operation and will
// need the corresponding job object.
PSRemotingJob job = FindJobForSession(connectedSession);
if (this.OutTarget == OutTarget.Host)
{
ConnectSessionToHost(connectedSession, job);
}
else
{
// Connection to Job is default option.
ConnectSessionToJob(connectedSession, job);
}
}
else
{
// Otherwise create a new session from the queried runspace object.
// This will be a *reconstruct* operation.
// Create and connect session.
PSSession newSession = new PSSession(runspace as RemoteRunspace);
connectedSession = ConnectSession(newSession, out ex);
if (connectedSession != null)
{
// Try to reuse the existing local repository PSSession object.
if (locSession != null)
{
connectedSession = locSession.InsertRunspace(connectedSession.Runspace as RemoteRunspace) ? locSession : connectedSession;
}
// Make sure that this connected session is included in the PSSession repository.
// If it already exists then replace it because we want the latest/connected session in the repository.
this.RunspaceRepository.AddOrReplace(connectedSession);
if (this.OutTarget == OutTarget.Job)
{
ConnectSessionToJob(connectedSession);
}
else
{
// Connection to Host is default option.
ConnectSessionToHost(connectedSession);
}
}
else
{
String message = StringUtil.Format(RemotingErrorIdStrings.RunspaceCannotBeConnected, newSession.Name);
WriteError(new ErrorRecord(new ArgumentException(message, ex), "ReceivePSSessionCannotConnectSession",
ErrorCategory.InvalidOperation, newSession));
}
}
break;
}
}
}
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 bool CheckForDebugMode(PSSession session, bool monitorAvailabilityChange)
{
RemoteRunspace remoteRunspace = session.Runspace as RemoteRunspace;
if (remoteRunspace.RunspaceAvailability == RunspaceAvailability.RemoteDebug)
{
DisconnectAndStopRunningCmds(remoteRunspace);
WriteDebugStopWarning();
return true;
}
if (monitorAvailabilityChange)
{
// Monitor runspace availability transition to RemoteDebug
remoteRunspace.AvailabilityChanged += HandleRunspaceAvailabilityChanged;
}
return false;
}
private PSSession TryGetSessionFromServer(PSSession session)
{
if (session.Runspace is RemoteRunspace)
{
RemoteRunspace remoteRunspace = null;
foreach (Runspace runspace2 in Runspace.GetRunspaces(session.Runspace.ConnectionInfo, base.Host, QueryRunspaces.BuiltInTypesTable))
{
if (runspace2.InstanceId == session.Runspace.InstanceId)
{
remoteRunspace = runspace2 as RemoteRunspace;
break;
}
}
if (remoteRunspace != null)
{
session = session.InsertRunspace(remoteRunspace) ? session : new PSSession(remoteRunspace);
return session;
}
}
return null;
}
/// <summary>
/// Connects session, retrieves command output data and writes to host.
/// </summary>
/// <param name="session">PSSession object.</param>
/// <param name="job">Job object associated with session.</param>
private void ConnectSessionToHost(PSSession session, PSRemotingJob job = null)
{
RemoteRunspace remoteRunspace = session.Runspace as RemoteRunspace;
Dbg.Assert(remoteRunspace != null, "PS sessions can only contain RemoteRunspace type.");
if (job != null)
{
// If we have a job object associated with the session then this means
// the user explicitly chose to connect and return data synchronously.
// Reconnect the job object and stream data to host.
lock (_syncObject) { _job = job; _stopPipelineReceive = new ManualResetEvent(false); }
using (_stopPipelineReceive)
using (job)
{
Job childJob = job.ChildJobs[0];
job.ConnectJobs();
if (CheckForDebugMode(session, true)) { return; }
do
{
// Retrieve and display results from child job as they become
// available.
int index = WaitHandle.WaitAny(new WaitHandle[] {
_stopPipelineReceive,
childJob.Results.WaitHandle });
foreach (var result in childJob.ReadAll())
{
if (result != null)
{
result.WriteStreamObject(this);
}
}
if (index == 0)
{
WriteDebugStopWarning();
return;
}
}
while (!job.IsFinishedState(job.JobStateInfo.State));
}
lock (_syncObject) { _job = null; _stopPipelineReceive = null; }
return;
}
// Otherwise this must be a new disconnected session object that has a running command
// associated with it.
if (remoteRunspace.RemoteCommand == null)
{
// There is no associated running command for this runspace, so we cannot proceed.
// Check to see if session is in debug mode.
CheckForDebugMode(session, false);
return;
}
// Create a RemotePipeline object for this command and attempt to connect.
lock (_syncObject)
{
_remotePipeline = (RemotePipeline)session.Runspace.CreateDisconnectedPipeline();
_stopPipelineReceive = new ManualResetEvent(false);
}
using (_stopPipelineReceive)
{
using (_remotePipeline)
{
// Connect to remote running command.
ManualResetEvent pipelineConnectedEvent = new ManualResetEvent(false);
using (pipelineConnectedEvent)
{
_remotePipeline.StateChanged += (sender, args) =>
{
if (pipelineConnectedEvent != null &&
(args.PipelineStateInfo.State == PipelineState.Running ||
args.PipelineStateInfo.State == PipelineState.Stopped ||
args.PipelineStateInfo.State == PipelineState.Failed))
{
pipelineConnectedEvent.Set();
}
};
_remotePipeline.ConnectAsync();
pipelineConnectedEvent.WaitOne();
}
pipelineConnectedEvent = null;
if (CheckForDebugMode(session, true)) { return; }
// Wait for remote command to complete, while writing any available data.
while (!_remotePipeline.Output.EndOfPipeline)
{
if (_stopProcessing)
{
break;
}
int index = WaitHandle.WaitAny(new WaitHandle[] {
_stopPipelineReceive,
_remotePipeline.Output.WaitHandle });
if (index == 0)
{
WriteDebugStopWarning();
return;
}
while (_remotePipeline.Output.Count > 0)
{
if (_stopProcessing)
{
break;
}
PSObject psObject = _remotePipeline.Output.Read();
WriteRemoteObject(psObject, session);
}
}
// Write pipeline object errors.
if (_remotePipeline.Error.Count > 0)
{
while (!_remotePipeline.Error.EndOfPipeline)
{
object errorObj = _remotePipeline.Error.Read();
if (errorObj is Collection<ErrorRecord>)
{
Collection<ErrorRecord> errorCollection = (Collection<ErrorRecord>)errorObj;
foreach (ErrorRecord errorRecord in errorCollection)
{
WriteError(errorRecord);
}
}
else if (errorObj is ErrorRecord)
{
WriteError((ErrorRecord)errorObj);
}
else
{
Dbg.Assert(false, "Objects in pipeline Error collection must be ErrorRecord type.");
}
}
}
// Wait for pipeline to finish.
int wIndex = WaitHandle.WaitAny(new WaitHandle[] {
_stopPipelineReceive,
_remotePipeline.PipelineFinishedEvent });
if (wIndex == 0)
{
WriteDebugStopWarning();
return;
}
// Set the runspace RemoteCommand to null. It is not needed anymore and it
// allows the runspace to become available after pipeline completes.
remoteRunspace.RunspacePool.RemoteRunspacePoolInternal.ConnectCommands = null;
// Check for any terminating errors to report.
if (_remotePipeline.PipelineStateInfo.State == PipelineState.Failed)
{
Exception reason = _remotePipeline.PipelineStateInfo.Reason;
string msg;
if (reason != null && !string.IsNullOrEmpty(reason.Message))
{
msg = StringUtil.Format(RemotingErrorIdStrings.PipelineFailedWithReason, reason.Message);
}
else
{
msg = RemotingErrorIdStrings.PipelineFailedWithoutReason;
}
ErrorRecord errorRecord = new ErrorRecord(new RuntimeException(msg, reason),
"ReceivePSSessionPipelineFailed",
ErrorCategory.OperationStopped,
_remotePipeline
);
WriteError(errorRecord);
}
}
}
lock (_syncObject) { _remotePipeline = null; _stopPipelineReceive = null; }
}
private void ConnectSessionToHost(PSSession session, PSRemotingJob job = null)
{
RemoteRunspace runspace = session.Runspace as RemoteRunspace;
if (job != null)
{
lock (this._syncObject)
{
this._job = job;
}
using (job)
{
Job job2 = job.ChildJobs[0];
job.ConnectJobs();
do
{
job2.Results.WaitHandle.WaitOne();
foreach (PSStreamObject obj2 in job2.ReadAll())
{
if (obj2 != null)
{
obj2.WriteStreamObject(this, false);
}
}
}
while (!job.IsFinishedState(job.JobStateInfo.State));
}
lock (this._syncObject)
{
this._job = null;
}
}
else if (runspace.RemoteCommand != null)
{
lock (this._syncObject)
{
this._remotePipeline = (RemotePipeline) session.Runspace.CreateDisconnectedPipeline();
}
using (this._remotePipeline)
{
this._remotePipeline.ConnectAsync();
runspace.RunspacePool.RemoteRunspacePoolInternal.ConnectCommands = null;
while (!this._remotePipeline.Output.EndOfPipeline)
{
if (this._stopProcessing)
{
break;
}
this._remotePipeline.Output.WaitHandle.WaitOne();
while (this._remotePipeline.Output.Count > 0)
{
if (this._stopProcessing)
{
continue;
}
PSObject psObject = this._remotePipeline.Output.Read();
this.WriteRemoteObject(psObject, session);
}
}
if (this._remotePipeline.Error.Count > 0)
{
while (!this._remotePipeline.Error.EndOfPipeline)
{
object obj4 = this._remotePipeline.Error.Read();
if (obj4 is Collection<ErrorRecord>)
{
Collection<ErrorRecord> collection = (Collection<ErrorRecord>) obj4;
foreach (ErrorRecord record in collection)
{
base.WriteError(record);
}
}
else if (obj4 is ErrorRecord)
{
base.WriteError((ErrorRecord) obj4);
}
}
}
this._remotePipeline.PipelineFinishedEvent.WaitOne();
if (this._remotePipeline.PipelineStateInfo.State == PipelineState.Failed)
{
string pipelineFailedWithoutReason;
Exception reason = this._remotePipeline.PipelineStateInfo.Reason;
if ((reason != null) && !string.IsNullOrEmpty(reason.Message))
{
pipelineFailedWithoutReason = StringUtil.Format(RemotingErrorIdStrings.PipelineFailedWithReason, reason.Message);
}
else
{
pipelineFailedWithoutReason = RemotingErrorIdStrings.PipelineFailedWithoutReason;
}
ErrorRecord errorRecord = new ErrorRecord(new RuntimeException(pipelineFailedWithoutReason, reason), "ReceivePSSessionPipelineFailed", ErrorCategory.OperationStopped, this._remotePipeline);
base.WriteError(errorRecord);
}
}
lock (this._syncObject)
{
this._remotePipeline = null;
}
}
}
private bool ValidateIdleTimeout(PSSession session)
{
int idleTimeout = session.Runspace.ConnectionInfo.IdleTimeout;
int maxIdleTimeout = session.Runspace.ConnectionInfo.MaxIdleTimeout;
int minIdleTimeout = BaseTransportManager.MinimumIdleTimeout;
if (idleTimeout != BaseTransportManager.UseServerDefaultIdleTimeout &&
(idleTimeout > maxIdleTimeout || idleTimeout < minIdleTimeout))
{
string msg = StringUtil.Format(RemotingErrorIdStrings.CannotDisconnectSessionWithInvalidIdleTimeout,
session.Name, idleTimeout / 1000, maxIdleTimeout / 1000, minIdleTimeout / 1000);
ErrorRecord errorRecord = new ErrorRecord(new RuntimeException(msg),
"CannotDisconnectSessionWithInvalidIdleTimeout", ErrorCategory.InvalidArgument, session);
WriteError(errorRecord);
return false;
}
return true;
}
