} // CreateHelpersForSpecifiedUris
/// <summary>
/// Creates helper objects with the command for the specified
/// VM GUIDs or VM names.
/// </summary>
protected virtual void CreateHelpersForSpecifiedVMSession()
{
int inputArraySize;
int index;
string command;
bool[] vmIsRunning;
Collection<PSObject> results;
if ((ParameterSetName == PSExecutionCmdlet.VMIdParameterSet) ||
(ParameterSetName == PSExecutionCmdlet.FilePathVMIdParameterSet))
{
inputArraySize = this.VMId.Length;
this.VMName = new string[inputArraySize];
vmIsRunning = new bool[inputArraySize];
for (index = 0; index < inputArraySize; index++)
{
vmIsRunning[index] = false;
command = "Get-VM -Id $args[0]";
try
{
results = this.InvokeCommand.InvokeScript(
command, false, PipelineResultTypes.None, null, this.VMId[index]);
}
catch (CommandNotFoundException)
{
ThrowTerminatingError(
new ErrorRecord(
new ArgumentException(RemotingErrorIdStrings.HyperVModuleNotAvailable),
PSRemotingErrorId.HyperVModuleNotAvailable.ToString(),
ErrorCategory.NotInstalled,
null));
return;
}
if (results.Count != 1)
{
this.VMName[index] = string.Empty;
}
else
{
this.VMName[index] = (string)results[0].Properties["VMName"].Value;
if ((VMState)results[0].Properties["State"].Value == VMState.Running)
{
vmIsRunning[index] = true;
}
}
}
}
else
{
Dbg.Assert((ParameterSetName == PSExecutionCmdlet.VMNameParameterSet) ||
(ParameterSetName == PSExecutionCmdlet.FilePathVMNameParameterSet),
"Expected ParameterSetName == VMName or FilePathVMName");
inputArraySize = this.VMName.Length;
this.VMId = new Guid[inputArraySize];
vmIsRunning = new bool[inputArraySize];
for (index = 0; index < inputArraySize; index++)
{
vmIsRunning[index] = false;
command = "Get-VM -Name $args";
try
{
results = this.InvokeCommand.InvokeScript(
command, false, PipelineResultTypes.None, null, this.VMName[index]);
}
catch (CommandNotFoundException)
{
ThrowTerminatingError(
new ErrorRecord(
new ArgumentException(RemotingErrorIdStrings.HyperVModuleNotAvailable),
PSRemotingErrorId.HyperVModuleNotAvailable.ToString(),
ErrorCategory.NotInstalled,
null));
return;
}
if (results.Count != 1)
{
this.VMId[index] = Guid.Empty;
}
else
{
this.VMId[index] = (Guid)results[0].Properties["VMId"].Value;
this.VMName[index] = (string)results[0].Properties["VMName"].Value;
if ((VMState)results[0].Properties["State"].Value == VMState.Running)
{
vmIsRunning[index] = true;
}
}
}
}
ResolvedComputerNames = this.VMName;
for (index = 0; index < ResolvedComputerNames.Length; index++)
{
if ((this.VMId[index] == Guid.Empty) &&
((ParameterSetName == PSExecutionCmdlet.VMNameParameterSet) ||
(ParameterSetName == PSExecutionCmdlet.FilePathVMNameParameterSet)))
{
WriteError(
new ErrorRecord(
new ArgumentException(GetMessage(RemotingErrorIdStrings.InvalidVMNameNotSingle,
this.VMName[index])),
PSRemotingErrorId.InvalidVMNameNotSingle.ToString(),
ErrorCategory.InvalidArgument,
null));
continue;
}
else if ((this.VMName[index] == string.Empty) &&
((ParameterSetName == PSExecutionCmdlet.VMIdParameterSet) ||
(ParameterSetName == PSExecutionCmdlet.FilePathVMIdParameterSet)))
{
WriteError(
new ErrorRecord(
new ArgumentException(GetMessage(RemotingErrorIdStrings.InvalidVMIdNotSingle,
this.VMId[index].ToString(null))),
PSRemotingErrorId.InvalidVMIdNotSingle.ToString(),
ErrorCategory.InvalidArgument,
null));
continue;
}
else if (!vmIsRunning[index])
{
WriteError(
new ErrorRecord(
new ArgumentException(GetMessage(RemotingErrorIdStrings.InvalidVMState,
this.VMName[index])),
PSRemotingErrorId.InvalidVMState.ToString(),
ErrorCategory.InvalidArgument,
null));
continue;
}
// create helper objects for VM GUIDs or names
RemoteRunspace remoteRunspace = null;
VMConnectionInfo connectionInfo;
try
{
connectionInfo = new VMConnectionInfo(this.Credential, this.VMId[index], this.VMName[index], this.ConfigurationName);
remoteRunspace = new RemoteRunspace(Utils.GetTypeTableFromExecutionContextTLS(),
connectionInfo, this.Host, null, null, -1);
remoteRunspace.Events.ReceivedEvents.PSEventReceived += OnRunspacePSEventReceived;
}
catch (InvalidOperationException e)
{
ErrorRecord errorRecord = new ErrorRecord(e,
"CreateRemoteRunspaceForVMFailed",
ErrorCategory.InvalidOperation,
null);
WriteError(errorRecord);
}
catch (ArgumentException e)
{
ErrorRecord errorRecord = new ErrorRecord(e,
"CreateRemoteRunspaceForVMFailed",
ErrorCategory.InvalidArgument,
null);
WriteError(errorRecord);
}
Pipeline pipeline = CreatePipeline(remoteRunspace);
IThrottleOperation operation =
new ExecutionCmdletHelperComputerName(remoteRunspace, pipeline, false);
Operations.Add(operation);
}
}// CreateHelpersForSpecifiedVMSession
}// CreateRunspacesWhenComputerNameParameterSpecified
/// <summary>
/// Creates the remote runspace objects when the VMId or VMName parameter
/// is specified
/// </summary>
private List<RemoteRunspace> CreateRunspacesWhenVMParameterSpecified()
{
int inputArraySize;
bool isVMIdSet = false;
int index;
string command;
Collection<PSObject> results;
List<RemoteRunspace> remoteRunspaces = new List<RemoteRunspace>();
if (ParameterSetName == PSExecutionCmdlet.VMIdParameterSet)
{
isVMIdSet = true;
inputArraySize = this.VMId.Length;
this.VMName = new string[inputArraySize];
command = "Get-VM -Id $args[0]";
}
else
{
Dbg.Assert((ParameterSetName == PSExecutionCmdlet.VMNameParameterSet),
"Expected ParameterSetName == VMId or VMName");
inputArraySize = this.VMName.Length;
this.VMId = new Guid[inputArraySize];
command = "Get-VM -Name $args";
}
for (index = 0; index < inputArraySize; index++)
{
try
{
results = this.InvokeCommand.InvokeScript(
command, false, PipelineResultTypes.None, null,
isVMIdSet ? this.VMId[index].ToString() : this.VMName[index]);
}
catch (CommandNotFoundException)
{
ThrowTerminatingError(
new ErrorRecord(
new ArgumentException(RemotingErrorIdStrings.HyperVModuleNotAvailable),
PSRemotingErrorId.HyperVModuleNotAvailable.ToString(),
ErrorCategory.NotInstalled,
null));
return null;
}
// handle invalid input
if (results.Count != 1)
{
if (isVMIdSet)
{
this.VMName[index] = string.Empty;
WriteError(
new ErrorRecord(
new ArgumentException(GetMessage(RemotingErrorIdStrings.InvalidVMIdNotSingle,
this.VMId[index].ToString(null))),
PSRemotingErrorId.InvalidVMIdNotSingle.ToString(),
ErrorCategory.InvalidArgument,
null));
continue;
}
else
{
this.VMId[index] = Guid.Empty;
WriteError(
new ErrorRecord(
new ArgumentException(GetMessage(RemotingErrorIdStrings.InvalidVMNameNotSingle,
this.VMName[index])),
PSRemotingErrorId.InvalidVMNameNotSingle.ToString(),
ErrorCategory.InvalidArgument,
null));
continue;
}
}
else
{
this.VMId[index] = (Guid)results[0].Properties["VMId"].Value;
this.VMName[index] = (string)results[0].Properties["VMName"].Value;
//
// VM should be in running state.
//
if ((VMState)results[0].Properties["State"].Value != VMState.Running)
{
WriteError(
new ErrorRecord(
new ArgumentException(GetMessage(RemotingErrorIdStrings.InvalidVMState,
this.VMName[index])),
PSRemotingErrorId.InvalidVMState.ToString(),
ErrorCategory.InvalidArgument,
null));
continue;
}
}
// create helper objects for VM GUIDs or names
RemoteRunspace runspace = null;
VMConnectionInfo connectionInfo;
int rsId;
string rsName = GetRunspaceName(index, out rsId);
try
{
connectionInfo = new VMConnectionInfo(this.Credential, this.VMId[index], this.VMName[index], this.ConfigurationName);
runspace = new RemoteRunspace(Utils.GetTypeTableFromExecutionContextTLS(),
connectionInfo, this.Host, null, rsName, rsId);
remoteRunspaces.Add(runspace);
}
catch (InvalidOperationException e)
{
ErrorRecord errorRecord = new ErrorRecord(e,
"CreateRemoteRunspaceForVMFailed",
ErrorCategory.InvalidOperation,
null);
WriteError(errorRecord);
}
catch (ArgumentException e)
{
ErrorRecord errorRecord = new ErrorRecord(e,
"CreateRemoteRunspaceForVMFailed",
ErrorCategory.InvalidArgument,
null);
WriteError(errorRecord);
}
}
ResolvedComputerNames = this.VMName;
return remoteRunspaces;
}// CreateRunspacesWhenVMParameterSpecified
internal VMHyperVSocketClientSessionTransportManager(
VMConnectionInfo connectionInfo,
Guid runspaceId,
PSRemotingCryptoHelper cryptoHelper,
Guid vmGuid,
string configurationName)
: base(runspaceId, cryptoHelper)
{
if (connectionInfo == null)
{
throw new PSArgumentNullException("connectionInfo");
}
_connectionInfo = connectionInfo;
_vmGuid = vmGuid;
_configurationName = configurationName;
if (connectionInfo.Credential == null)
{
_networkCredential = CredentialCache.DefaultNetworkCredentials;
}
else
{
_networkCredential = connectionInfo.Credential.GetNetworkCredential();
}
}
/// <summary>
/// This constructor will be used to created a remote runspace info
/// object with a auto generated name
/// </summary>
/// <param name="remoteRunspace">Remote runspace object for which
/// the info object need to be created</param>
internal PSSession(RemoteRunspace remoteRunspace)
{
_remoteRunspace = remoteRunspace;
// Use passed in session Id, if available.
if (remoteRunspace.PSSessionId != -1)
{
Id = remoteRunspace.PSSessionId;
}
else
{
Id = System.Threading.Interlocked.Increment(ref s_seed);
remoteRunspace.PSSessionId = Id;
}
// Use passed in friendly name, if available.
if (!string.IsNullOrEmpty(remoteRunspace.PSSessionName))
{
Name = remoteRunspace.PSSessionName;
}
else
{
Name = "Runspace" + Id;
remoteRunspace.PSSessionName = Name;
}
// WSMan session
if (remoteRunspace.ConnectionInfo is WSManConnectionInfo)
{
ComputerType = TargetMachineType.RemoteMachine;
string fullShellName = WSManConnectionInfo.ExtractPropertyAsWsManConnectionInfo <string>(
remoteRunspace.ConnectionInfo,
"ShellUri", string.Empty);
ConfigurationName = GetDisplayShellName(fullShellName);
return;
}
// VM session
VMConnectionInfo vmConnectionInfo = remoteRunspace.ConnectionInfo as VMConnectionInfo;
if (vmConnectionInfo != null)
{
ComputerType = TargetMachineType.VirtualMachine;
ConfigurationName = vmConnectionInfo.ConfigurationName;
return;
}
// Container session
ContainerConnectionInfo containerConnectionInfo = remoteRunspace.ConnectionInfo as ContainerConnectionInfo;
if (containerConnectionInfo != null)
{
ComputerType = TargetMachineType.Container;
ConfigurationName = containerConnectionInfo.ContainerProc.ConfigurationName;
return;
}
// SSH session
SSHConnectionInfo sshConnectionInfo = remoteRunspace.ConnectionInfo as SSHConnectionInfo;
if (sshConnectionInfo != null)
{
ComputerType = TargetMachineType.RemoteMachine;
ConfigurationName = "DefaultShell";
return;
}
// We only support WSMan/VM/Container sessions now.
Dbg.Assert(false, "Invalid Runspace");
}
/// <summary>
/// Create runspace for VM session.
/// </summary>
private RemoteRunspace GetRunspaceForVMSession()
{
RemoteRunspace remoteRunspace = null;
string command;
Collection<PSObject> results;
if (ParameterSetName == VMIdParameterSet)
{
command = "Get-VM -Id $args[0]";
try
{
results = this.InvokeCommand.InvokeScript(
command, false, PipelineResultTypes.None, null, this.VMId);
}
catch (CommandNotFoundException)
{
WriteError(
new ErrorRecord(
new ArgumentException(RemotingErrorIdStrings.HyperVModuleNotAvailable),
PSRemotingErrorId.HyperVModuleNotAvailable.ToString(),
ErrorCategory.NotInstalled,
null));
return null;
}
if (results.Count != 1)
{
WriteError(
new ErrorRecord(
new ArgumentException(RemotingErrorIdStrings.InvalidVMId),
PSRemotingErrorId.InvalidVMId.ToString(),
ErrorCategory.InvalidArgument,
null));
return null;
}
this.VMName = (string)results[0].Properties["VMName"].Value;
}
else
{
Dbg.Assert(ParameterSetName == VMNameParameterSet, "Expected ParameterSetName == VMName");
command = "Get-VM -Name $args";
try
{
results = this.InvokeCommand.InvokeScript(
command, false, PipelineResultTypes.None, null, this.VMName);
}
catch (CommandNotFoundException)
{
WriteError(
new ErrorRecord(
new ArgumentException(RemotingErrorIdStrings.HyperVModuleNotAvailable),
PSRemotingErrorId.HyperVModuleNotAvailable.ToString(),
ErrorCategory.NotInstalled,
null));
return null;
}
if (results.Count == 0)
{
WriteError(
new ErrorRecord(
new ArgumentException(RemotingErrorIdStrings.InvalidVMNameNoVM),
PSRemotingErrorId.InvalidVMNameNoVM.ToString(),
ErrorCategory.InvalidArgument,
null));
return null;
}
else if (results.Count > 1)
{
WriteError(
new ErrorRecord(
new ArgumentException(RemotingErrorIdStrings.InvalidVMNameMultipleVM),
PSRemotingErrorId.InvalidVMNameMultipleVM.ToString(),
ErrorCategory.InvalidArgument,
null));
return null;
}
this.VMId = (Guid)results[0].Properties["VMId"].Value;
this.VMName = (string)results[0].Properties["VMName"].Value;
}
//
// VM should be in running state.
//
if ((VMState)results[0].Properties["State"].Value != VMState.Running)
{
WriteError(
new ErrorRecord(
new ArgumentException(GetMessage(RemotingErrorIdStrings.InvalidVMState,
this.VMName)),
PSRemotingErrorId.InvalidVMState.ToString(),
ErrorCategory.InvalidArgument,
null));
return null;
}
try
{
VMConnectionInfo connectionInfo;
connectionInfo = new VMConnectionInfo(this.Credential, this.VMId, this.VMName, this.ConfigurationName);
remoteRunspace = CreateTemporaryRemoteRunspaceForPowerShellDirect(this.Host, connectionInfo);
}
catch (InvalidOperationException e)
{
ErrorRecord errorRecord = new ErrorRecord(e,
"CreateRemoteRunspaceForVMFailed",
ErrorCategory.InvalidOperation,
null);
WriteError(errorRecord);
}
catch (ArgumentException e)
{
ErrorRecord errorRecord = new ErrorRecord(e,
"CreateRemoteRunspaceForVMFailed",
ErrorCategory.InvalidArgument,
null);
WriteError(errorRecord);
}
catch (PSRemotingDataStructureException e)
{
ErrorRecord errorRecord;
//
// In case of PSDirectException, we should output the precise error message
// in inner exception instead of the generic one in outer exception.
//
if ((e.InnerException != null) && (e.InnerException is PSDirectException))
{
errorRecord = new ErrorRecord(e.InnerException,
"CreateRemoteRunspaceForVMFailed",
ErrorCategory.InvalidArgument,
null);
}
else
{
errorRecord = new ErrorRecord(e,
"CreateRemoteRunspaceForVMFailed",
ErrorCategory.InvalidOperation,
null);
}
WriteError(errorRecord);
}
catch (Exception e)
{
ErrorRecord errorRecord = new ErrorRecord(e,
"CreateRemoteRunspaceForVMFailed",
ErrorCategory.InvalidOperation,
null);
WriteError(errorRecord);
}
return remoteRunspace;
}
