/// <summary>
/// Execute the given cmdlet in powershell with the given parameters after injecting the given exception. It is expected that the cmdlet has a runtime that can be used for receiving output
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="cmdlet">The cmdlet to execute</param>
/// <param name="name">The name of the cmdlet</param>
/// <param name="exception">The exception to inject into the error stream</param>
/// <param name="cmdletParameters">The parameters to pass to the cmdlet on the pipeline</param>
public static void ExecuteCmdletWithExceptionInPipeline <T>(this PSCmdlet cmdlet, string name, Exception exception, params KeyValuePair <string, object>[] cmdletParameters)
{
List <T> output = new List <T>();
using (System.Management.Automation.PowerShell powershell = System.Management.Automation.PowerShell.Create(RunspaceMode.NewRunspace))
{
var info = new CmdletInfo(name, cmdlet.GetType());
powershell.AddCommand("Write-Error");
powershell.AddParameter("Exception", exception);
powershell.Invoke();
powershell.Commands.Clear();
powershell.AddCommand(info);
foreach (var pair in cmdletParameters)
{
if (pair.Value == null)
{
powershell.AddParameter(pair.Key);
}
else
{
powershell.AddParameter(pair.Key, pair.Value);
}
}
Collection <T> result = powershell.Invoke <T>();
powershell.Streams.Error.ForEach(cmdlet.WriteError);
powershell.Streams.Debug.ForEach(d => cmdlet.WriteDebug(d.Message));
powershell.Streams.Verbose.ForEach(v => cmdlet.WriteWarning(v.Message));
powershell.Streams.Warning.ForEach(w => cmdlet.WriteWarning(w.Message));
if (result != null && result.Count > 0)
{
result.ForEach(r => cmdlet.WriteObject(r));
}
}
}
private void LoadPowerShellProfile()
{
BuildShell();
try
{
shell.Runspace = host.Runspace;
PSCommand[] profileCommands = HostUtilities.GetProfileCommands("TexoUI");
foreach (PSCommand command in profileCommands)
{
shell.Commands = command;
shell.Invoke();
}
}
catch (Exception e)
{
// Set-ExecutionPolicy -ExecutionPolicy RemoteSigned -Scope CurrentUser
logger.Error("Error during of profile loading in PowerShell.", e);
}
finally
{
ReleaseShell();
}
}
public void FindAzModuleV2()
{
pwsh.Commands.Clear();
pwsh.AddScript("Find-Module -Name Az -Repository LocalRepo");
pwsh.Invoke();
}
/// <summary>
/// A helper class that builds and executes a pipeline that writes to the default output path, depending on the value of <paramref name="quiet"/>. Any
/// exceptions that are thrown are just passed to the caller.
/// </summary>
/// <param name="command">The script to run.</param>
/// <param name="input">Any input arguments to pass to the script. If null then nothing is passed in.</param>
/// <param name="quiet">Whether or not the results of the call should be written to the console.</param>
/// <returns>The results of the call to _currentPowerShell.<see cref="PowerShell.Invoke()"/>.</returns>
protected Collection <PSObject> ExecuteHelper(string command, object input, bool quiet = false)
{
// Ignore empty command lines.
if (String.IsNullOrEmpty(command))
{
return(null);
}
lock (_executionLock)
{
// Create the pipeline object and make it available to the Ctrl-C handle through the _currentPowerShell instance variable.
lock (_instanceLock)
{
_currentPowerShell = Shell.Create();
}
// Create a pipeline for this execution, and then place the result in the _currentPowerShell variable so it is available to be stopped.
try
{
_currentPowerShell.Runspace = Runspace;
_currentPowerShell.AddScript(command);
if (!quiet)
{
// Add the default outputter to the end of the pipe and then call the MergeMyResults method to merge the output and error streams from
// the pipeline. This will result in the output being written using the PSHost and PSHostUserInterface classes instead of returning
// objects to the host application.
_currentPowerShell.AddCommand("out-default");
_currentPowerShell.Commands.Commands[0].MergeMyResults(PipelineResultTypes.Error, PipelineResultTypes.Output);
}
// If there is any input pass it in, otherwise just invoke the the pipeline.
if (input != null)
{
return(_currentPowerShell.Invoke(
new object[]
{
input
}));
}
else
{
return(_currentPowerShell.Invoke());
}
}
finally
{
// Dispose the PowerShell object and set _currentPowerShell to null. It is locked because _currentPowerShell may be accessed by the Ctrl-C
// handler.
lock (_instanceLock)
{
_currentPowerShell.Dispose();
_currentPowerShell = null;
}
}
}
}
private Collection <PSObject> InvokeCommand(string cmdLet, Dictionary <string, object> parameters)
{
powerShell.Commands.Clear();
powerShell.AddCommand(cmdLet, false);
if (parameters != null)
{
powerShell.AddParameters(parameters);
}
return(powerShell.Invoke());
}
internal bool ValidStorageAccountCred(string storageAccountName, string storageAccountKey, string endpoint)
{
using (System.Management.Automation.PowerShell ps = System.Management.Automation.PowerShell.Create())
{
bool valid = true;
Random rnd = new Random();
string testContainerName = string.Format("storsimplesdkvalidation{0}", rnd.Next());
//create a storage container and then delete it
string validateScript = string.Format(
@"$context = New-AzureStorageContext -StorageAccountName {0} -StorageAccountKey {1} -Endpoint {2};"
+ @"New-AzureStorageContainer -Name {3} -Context $context;"
+ @"Remove-AzureStorageContainer -Name {3} -Context $context -Force;",
storageAccountName, storageAccountKey, endpoint, testContainerName);
ps.AddScript(validateScript);
ps.Invoke();
if (ps.HadErrors)
{
var exception = ps.Streams.Error[0].Exception;
string getScript = string.Format(
@"$context = New-AzureStorageContext -StorageAccountName {0} -StorageAccountKey {1};"
+ @"Get-AzureStorageContainer -Name {2} -Context $context;",
storageAccountName, storageAccountKey, testContainerName);
ps.AddScript(getScript);
var result = ps.Invoke();
if (result != null && result.Count > 0)
{
//storage container successfully created and still exists, retry deleting it
int retryCount = 1;
string removeScript = string.Format(
@"$context = New-AzureStorageContext -StorageAccountName {0} -StorageAccountKey {1};"
+ @"Remove-AzureStorageContainer -Name {2} -Context $context -Force;",
storageAccountName, storageAccountKey, testContainerName);
do
{
WriteVerbose(string.Format(Resources.StorageAccountCleanupRetryMessage, retryCount));
ps.AddScript(removeScript);
ps.Invoke();
Thread.Sleep(retryCount * 1000);
ps.AddScript(getScript);
result = ps.Invoke();
} while (result != null && result.Count > 0 && ++retryCount <= 5);
}
else
{
valid = false;
HandleException(exception);
}
}
return(valid);
}
}
private List <string> CopyRequiredModules(String configurationPath, String tempZipFolder)
{
WriteVerbose(
String.Format(
CultureInfo.CurrentUICulture,
Microsoft.Azure.Commands.Compute.Properties.Resources.AzureVMDscParsingConfiguration,
configurationPath));
var requiredModules = GetRequiredModules(configurationPath);
var metadataModules = new List <string>();
foreach (var module in requiredModules)
{
metadataModules.Add(module.Key);
using (System.Management.Automation.PowerShell powershell = System.Management.Automation.PowerShell.Create())
{
// Wrapping script in a function to prevent script injection via $module variable.
powershell.AddScript(
@"function Copy-Module([string]$moduleName, [string]$moduleVersion, [string]$tempZipFolder)
{
if([String]::IsNullOrEmpty($moduleVersion))
{
$module = Get-Module -List -Name $moduleName
}
else
{
$module = (Get-Module -List -Name $moduleName) | Where-Object{$_.Version -eq $moduleVersion}
}
$moduleFolder = Split-Path $module.Path
Copy-Item -Recurse -Path $moduleFolder -Destination ""$tempZipFolder\$($module.Name)""
}"
);
powershell.Invoke();
powershell.Commands.Clear();
powershell.AddCommand("Copy-Module")
.AddParameter("moduleName", module.Key)
.AddParameter("moduleVersion", module.Value)
.AddParameter("tempZipFolder", tempZipFolder);
WriteVerbose(String.Format(
CultureInfo.CurrentUICulture,
Microsoft.Azure.Commands.Compute.Properties.Resources.PublishVMDscExtensionCopyModuleVerbose,
module,
tempZipFolder));
powershell.Invoke();
}
}
return(metadataModules);
}
public void TranslatePSPathThatShouldExist()
{
string psPath = "mytemp:\\" + Path.GetFileName(_tempFilePath);
// test against PSDrive
_ps.Commands.AddScript(String.Format(ScriptTemplate, psPath));
Hashtable result = _ps.Invoke <Hashtable>().SingleOrDefault();
Assert.NotNull(result);
Assert.True(_ps.Streams.Error.Count == 0);
Assert.True((bool)result["success"]);
Assert.True((bool)result["exists"]);
Assert.Equal(_tempFilePath, (string)result["path"], StringComparer.OrdinalIgnoreCase);
}
/// <summary>
/// Execute PSScriptAnalyzer cmdlets in PowerShell while preserving the PSModulePath.
/// Attempts to prevent PSModulePath mutation by runspace creation within the PSScriptAnalyzer module.
/// </summary>
/// <param name="powershell">The PowerShell instance to execute.</param>
/// <returns>The output of PowerShell execution.</returns>
private Collection <PSObject> InvokePowerShellWithModulePathPreservation(System.Management.Automation.PowerShell powershell)
{
using (PSModulePathPreserver.Take())
{
return(powershell.Invoke());
}
}
public static string GetModuleNameForDscResource(string resourceName)
{
string moduleName;
if (!_resourceName2ModuleNameCache.TryGetValue(resourceName, out moduleName))
{
try
{
using (System.Management.Automation.PowerShell powershell = System.Management.Automation.PowerShell.Create())
{
powershell.AddCommand("Get-DscResource").
AddCommand("Where-Object").AddParameter("Property", "ResourceType").AddParameter("Value", resourceName).AddParameter("EQ", true).
AddCommand("Foreach-Object").AddParameter("MemberName", "Module").
AddCommand("Foreach-Object").AddParameter("MemberName", "Name");
moduleName = powershell.Invoke <string>().First();
}
}
catch (InvalidOperationException e)
{
throw new GetDscResourceException(resourceName, e);
}
_resourceName2ModuleNameCache.TryAdd(resourceName, moduleName);
}
return(moduleName);
}
static Settings Load()
{
var path = Scripts.GetSettings;
var settings = new Settings();
using (var runspace = RunspaceFactory.CreateRunspace())
{
runspace.Open();
using (A.PowerShell ps = A.PowerShell.Create())
{
ps.Runspace = runspace;
var script = String.Format("new-object -property ({0}) -typename '{1}'",
path,
typeof(Settings).FullName);
ps.AddScript(script);
try
{
var results = ps.Invoke();
if (results.Any())
{
settings = (results.First().BaseObject as Settings) ?? settings;
}
}
catch
{
}
}
}
return(settings);
}
private List <object> ExecuteCommand(bool stringOutput, bool marshallResults = true)
{
var jobManager = TypeResolver.ResolveFromCache <IJobManager>();
var job = jobManager.GetContextJob();
JobName = job?.Name;
if (stringOutput)
{
powerShell.Commands.AddCommand(OutDefaultCommand);
}
if (Runspace.DefaultRunspace == null)
{
Runspace.DefaultRunspace = host.Runspace;
}
if (Debugging)
{
host.Runspace.Debugger.DebuggerStop += DebuggerOnDebuggerStop;
host.Runspace.Debugger.BreakpointUpdated += DebuggerOnBreakpointUpdated;
SetVariable("SpeDebug", true);
if (Interactive)
{
var message = Message.Parse(this, "ise:debugstart");
SendUiMessage(message);
}
}
else
{
Engine.SessionState.PSVariable.Remove("SpeDebug");
}
abortRequested = false;
LastErrors?.Clear();
// execute the commands in the pipeline now
var execResults = powerShell.Invoke();
if (powerShell.HadErrors)
{
LastErrors = powerShell.Streams.Error.ToList();
}
LogErrors(powerShell, execResults);
if (Interactive && Debugging)
{
host.Runspace.Debugger.DebuggerStop -= DebuggerOnDebuggerStop;
host.Runspace.Debugger.BreakpointUpdated -= DebuggerOnBreakpointUpdated;
var message = Message.Parse(this, "ise:debugend");
SendUiMessage(message);
Debugging = false;
}
JobName = string.Empty;
return(marshallResults
? execResults?.Select(p => p?.BaseObject).ToList()
: execResults?.Cast <object>().ToList());
}
/// <summary>
/// Invoke script with parameters.
/// </summary>
/// <param name="script">Script command to be invoked.</param>
/// <param name="parameters">Parameters for the command.</param>
public void Invoke(string script, params PowerShellScriptParameter[] parameters)
{
using (PowerShell powerShell = PowerShell.Create())
{
powerShell.AddScript(script);
if (parameters != null)
{
foreach (var parameter in parameters)
{
powerShell.AddParameter(parameter.Name, parameter.Value);
}
}
// invoke execution on the pipeline (collecting output)
var output = powerShell.Invoke();
foreach (var outputItem in output)
{
if (outputItem != null)
{
this.logger.LogDebug(outputItem.BaseObject.GetType().FullName);
this.logger.LogDebug(outputItem.BaseObject.ToString() + "\n");
}
}
this.ProcessPowerShellStreams(powerShell);
}
}
public void GetLocalAdminPassword(string computerName)
{
IComputer computer = directory.GetComputer(computerName);
this.provider.ClearPassword(computer);
this.provider.ClearPasswordHistory(computer);
CollectionAssert.IsEmpty(this.provider.GetPasswordHistory(computer));
Assert.IsNull(this.provider.GetCurrentPassword(computer, null));
DateTime created = DateTime.UtcNow.Trim(TimeSpan.TicksPerSecond);
DateTime expired = DateTime.UtcNow.AddDays(-5).Trim(TimeSpan.TicksPerSecond);
string password = Guid.NewGuid().ToString();
this.provider.UpdateCurrentPassword(computer, password, created, expired, 0, MsMcsAdmPwdBehaviour.Ignore);
System.Management.Automation.PowerShell ps = System.Management.Automation.PowerShell.Create();
ps.AddCommand(new CmdletInfo("Get-LithnetLocalAdminPassword", typeof(GetLocalAdminPassword)));
ps.AddParameter("ComputerName", computerName);
var output = ps.Invoke();
Assert.AreEqual(1, output.Count);
var result = output[0];
Assert.AreEqual(password, result.Properties["Password"].Value);
}
public static Collection <PSObject> Invoke(this Runspace runspace, string script, IDictionary parameters = null, Action <PSDataStreams> psDataStreamAction = null)
{
if (script == null)
{
throw new ArgumentOutOfRangeException("script");
}
if (runspace == null)
{
throw new ArgumentOutOfRangeException("runspace");
}
using (System.Management.Automation.PowerShell ps = System.Management.Automation.PowerShell.Create())
{
ps.Runspace = runspace;
ps.AddScript(script);
if (parameters != null && parameters.Count > 0)
{
ps.AddParameters(parameters);
}
psDataStreamAction?.Invoke(ps.Streams);
return(ps.Invoke());
}
}
public PSPathTranslationTests()
{
// create temp file
_tempFilePath = Path.GetTempFileName();
// initialize
var state = InitialSessionState.CreateDefault();
state.ThreadOptions = PSThreadOptions.UseCurrentThread;
state.ApartmentState = ApartmentState.STA;
_ps = System.Management.Automation.PowerShell.Create();
_ps.Runspace = RunspaceFactory.CreateRunspace(state);
_ps.Runspace.Open();
// create a new PSDrive for translation tests
_ps.AddCommand("New-PSDrive")
.AddParameter("Name", "mytemp")
.AddParameter("PSProvider", FileSystemProvider.ProviderName)
.AddParameter("Root", Path.GetTempPath());
_ps.Invoke();
Assert.True(_ps.Streams.Error.Count == 0, "Failed to create mytemp psdrive.");
_ps.Streams.ClearStreams();
_ps.Commands.Clear();
}
/// <summary>
/// Load global aliases for ARM
/// </summary>
public void OnImport()
{
#if DEBUG
try
{
#endif
AzureSessionInitializer.InitializeAzureSession();
ResourceManagerProfileProvider.InitializeResourceManagerProfile();
#if DEBUG
if (!TestMockSupport.RunningMocked)
{
#endif
AzureSession.Instance.DataStore = new DiskDataStore();
#if DEBUG
}
#endif
System.Management.Automation.PowerShell invoker = null;
invoker = System.Management.Automation.PowerShell.Create(RunspaceMode.CurrentRunspace);
invoker.AddScript(File.ReadAllText(FileUtilities.GetContentFilePath(
Path.GetDirectoryName(Assembly.GetExecutingAssembly().Location),
"AzureRmProfileStartup.ps1")));
invoker.Invoke();
#if DEBUG
}
catch (Exception) when(TestMockSupport.RunningMocked)
{
// This will throw exception for tests, ignore.
}
#endif
}
public static Dictionary <string, object> start()
{
// We need to be explicit that we got this far.
System.Console.WriteLine("INTERACTIVE_START");
// Enter the shell
ConsoleHost.GetMethod("EnterNestedPrompt").Invoke(pshost, new object[] { });
// This ensures that we won't immediately exit next time we enter a prompt
// with the same Runspace/ConsoleHost
ConsoleHost.GetProperty("ShouldEndSession", BindingFlags.NonPublic | BindingFlags.Instance).SetValue(pshost, false);
// Let pwncat know we exited the shell
System.Console.WriteLine("\nINTERACTIVE_COMPLETE");
// Match our CWD w/ powershell
System.Management.Automation.PowerShell ps2 = System.Management.Automation.PowerShell.Create();
ps2.Runspace = runspace;
Runspace.DefaultRunspace = runspace;
ps2.AddScript("[System.IO.Directory]::SetCurrentDirectory($ExecutionContext.SessionState.Path.CurrentFileSystemLocation)");
ps2.Invoke();
return(new Dictionary <string, object>()
{
});
}
public void AddToPasswordHistory(string computerName)
{
IComputer computer = directory.GetComputer(computerName);
provider.ClearPassword(computer);
provider.ClearPasswordHistory(computer);
CollectionAssert.IsEmpty(provider.GetPasswordHistory(computer));
DateTime firstCreated = DateTime.UtcNow.Trim(TimeSpan.TicksPerSecond);
DateTime firstExpiry = DateTime.UtcNow.AddDays(-3).Trim(TimeSpan.TicksPerSecond);
string firstPassword = Guid.NewGuid().ToString();
provider.UpdateCurrentPassword(computer, firstPassword, firstCreated, firstExpiry, 0, MsMcsAdmPwdBehaviour.Ignore);
DateTime secondCreated = DateTime.UtcNow.AddDays(2).Trim(TimeSpan.TicksPerSecond);
DateTime secondExpiry = DateTime.UtcNow.AddDays(-5).Trim(TimeSpan.TicksPerSecond);
string secondPassword = Guid.NewGuid().ToString();
provider.UpdateCurrentPassword(computer, secondPassword, secondCreated, secondExpiry, 30, MsMcsAdmPwdBehaviour.Ignore);
System.Management.Automation.PowerShell ps = System.Management.Automation.PowerShell.Create();
ps.AddCommand(new CmdletInfo("Get-LithnetLocalAdminPasswordHistory", typeof(GetLocalAdminPasswordHistory)));
ps.AddParameter("ComputerName", computerName);
var output = ps.Invoke();
Assert.AreEqual(1, output.Count);
var passwords = output.Select(t => t.Properties["Password"].Value as string).ToList();
CollectionAssert.AreEquivalent(new[] { firstPassword }, passwords);
}
public override void ExecuteCmdlet()
{
System.Management.Automation.PowerShell ps = System.Management.Automation.PowerShell.Create();
ps.AddCommand("Connect-AzAccount");
if (MyInvocation.BoundParameters.ContainsKey(nameof(Credential)))
{
ps.AddParameter("Credential", Credential);
}
if (MyInvocation.BoundParameters.ContainsKey(nameof(ServicePrincipal)))
{
ps.AddParameter("ServicePrincipal", ServicePrincipal);
}
if (MyInvocation.BoundParameters.ContainsKey(nameof(TenantId)))
{
ps.AddParameter("Tenant", TenantId);
}
if (MyInvocation.BoundParameters.ContainsKey(nameof(ApplicationId)))
{
ps.AddParameter("ApplicationId", ApplicationId);
}
if (MyInvocation.BoundParameters.ContainsKey(nameof(CertificateThumbprint)))
{
ps.AddParameter("CertificateThumbprint", CertificateThumbprint);
}
ps.Invoke();
}
public void OnImport()
{
System.Management.Automation.PowerShell invoker = null;
invoker = System.Management.Automation.PowerShell.Create(RunspaceMode.CurrentRunspace);
invoker.AddScript(File.ReadAllText(FileUtilities.GetContentFilePath("ServiceManagementStartup.ps1")));
invoker.Invoke();
}
public string GetPowershellVersion()
{
log.Info("Checking to see what version of Powershell is installed");
string version = String.Empty;
using (PWS ps = PWS.Create())
{
ps.AddScript("./Scripts/PowerShell/PSVersion.ps1");
if (ps.Streams.Error.Count > 0)
{
foreach (var item in ps.Streams.Error)
{
log.Error(item.ErrorDetails.Message.ToString());
version = "ERROR";
}
}
else
{
foreach (PSObject item in ps.Invoke())
{
version = item.Members["Major"].Value + "." + item.Members["Minor"].Value;
log.Info("Powershell version: " + version);
}
}
}
return(version);
}
/// <summary>
/// Invokes a PowerShell script block.
/// </summary>
/// <param name="script">A script to be invoked.</param>
/// <param name="powerShell">PowerShell instance.</param>
/// <param name="errorAction">Error callback function.</param>
/// <returns></returns>
internal static ICollection <PSObject> CallPowerShellScript(
string script,
System.Management.Automation.PowerShell powerShell,
EventHandler <DataAddedEventArgs> errorAction)
{
try
{
powerShell.Clear();
var input = new PSDataCollection <PSObject>();
input.Complete();
var output = new PSDataCollection <PSObject>();
output.DataAdded += output_DataAdded;
if (errorAction != null)
{
powerShell.Streams.Error.DataAdded += errorAction;
}
powerShell.AddScript(script);
powerShell.Invoke(null, output, new PSInvocationSettings());
return(output.Count == 0 ? null : output);
}
finally
{
powerShell.Streams.Error.DataAdded -= errorAction;
}
}
public object InvokeFunction(string name, List <object> arguments)
{
try
{
var command = GetFunction(name);
powershell.AddCommand(command);
foreach (var argument in arguments)
{
powershell.AddArgument(argument);
}
var result = powershell.Invoke();
if (result.Count == 1)
{
return(result[0].BaseObject);
}
else
{
return(result.Select(a => a?.BaseObject).ToList());
}
}
finally
{
powershell.Streams.ClearStreams();
powershell.Commands.Clear();
}
}
private Process GetProcessByName(string name)
{
Collection <Process> foundProcesses;
using (System.Management.Automation.PowerShell ps = System.Management.Automation.PowerShell.Create(RunspaceMode.CurrentRunspace))
{
ps.AddCommand("Get-Process").AddParameter("Name", name);
foundProcesses = ps.Invoke <Process>();
}
if (foundProcesses.Count == 0)
{
ThrowTerminatingError(
new ErrorRecord(
new PSArgumentException(StringUtil.Format(RemotingErrorIdStrings.EnterPSHostProcessNoProcessFoundWithName, name)),
"EnterPSHostProcessNoProcessFoundWithName",
ErrorCategory.InvalidArgument,
this)
);
}
else if (foundProcesses.Count > 1)
{
ThrowTerminatingError(
new ErrorRecord(
new PSArgumentException(StringUtil.Format(RemotingErrorIdStrings.EnterPSHostProcessMultipleProcessesFoundWithName, name)),
"EnterPSHostProcessMultipleProcessesFoundWithName",
ErrorCategory.InvalidArgument,
this)
);
}
return(foundProcesses[0]);
}
private static PowerShellResult ExecutePowershell(System.Management.Automation.PowerShell powershell, bool logInformationStream)
{
try
{
var execution = powershell.Invoke();
var result = new PowerShellResult
{
// Powershell return values are usually wrapped inside of a powershell object, unwrap it or if it does not have a baseObject, return the actual object
Result = execution?.Select(GetResultObject).ToList(),
Errors = GetErrorMessages(powershell.Streams.Error),
Log = logInformationStream == false ? "" : string.Join("\n", powershell.Streams.Information.Select(info => info.MessageData.ToString()))
};
return(result);
}
catch (Exception e)
{
throw new Exception($"Encountered terminating error while executing powershell: \n{e}\nErrors:\n{string.Join("\n", GetErrorMessages(powershell.Streams.Error))}");
}
finally
{
powershell.Commands.Clear(); // Clear the executed commands from the session so they do not get executed again
powershell.Streams.ClearStreams();
}
}
public void OnImport()
{
DebugHelper.WriteLogEx();
System.Management.Automation.PowerShell powerShell = System.Management.Automation.PowerShell.Create(RunspaceMode.CurrentRunspace);
using (powerShell)
{
CimCmdletsAssemblyInitializer.CimCmdletAliasEntry[] aliases = CimCmdletsAssemblyInitializer.Aliases;
for (int i = 0; i < (int)aliases.Length; i++)
{
CimCmdletsAssemblyInitializer.CimCmdletAliasEntry cimCmdletAliasEntry = aliases[i];
object[] name = new object[3];
name[0] = cimCmdletAliasEntry.Name;
name[1] = cimCmdletAliasEntry.Value;
name[2] = cimCmdletAliasEntry.Options;
powerShell.AddScript(string.Format(CultureInfo.CurrentUICulture, "New-Alias -Name {0} -Value {1} -Option {2}", name));
object[] value = new object[3];
value[0] = cimCmdletAliasEntry.Name;
value[1] = cimCmdletAliasEntry.Value;
value[2] = cimCmdletAliasEntry.Options;
DebugHelper.WriteLog("Add commands {0} of {1} with option {2} to current runspace.", 1, value);
}
Collection <PSObject> pSObjects = powerShell.Invoke();
object[] count = new object[1];
count[0] = pSObjects.Count;
DebugHelper.WriteLog("Invoke results {0}.", 1, count);
}
}
/// <summary>
/// This method creates the form where the output is displayed.
/// </summary>
private static void CreateForm()
{
Form form = new Form();
DataGridView grid = new DataGridView();
form.Controls.Add(grid);
grid.Dock = DockStyle.Fill;
// Create a PowerShell object. Creating this object takes care of
// building all of the other data structures needed to run the command.
using (PowerShell powershell = PowerShell.Create())
{
powershell.AddCommand("get-process").AddCommand("sort-object").AddArgument("ID");
if (Runspace.DefaultRunspace == null)
{
Runspace.DefaultRunspace = powershell.Runspace;
}
Collection <PSObject> results = powershell.Invoke();
// The generic collection needs to be re-wrapped in an ArrayList
// for data-binding to work.
ArrayList objects = new ArrayList();
objects.AddRange(results);
// The DataGridView will use the PSObjectTypeDescriptor type
// to retrieve the properties.
grid.DataSource = objects;
}
form.ShowDialog();
}
/// <summary>
/// IsServerCoreORHeadLessServer is a helper function that checks if the current SKU is a
/// Server Core machine or if the Server-GUI-Shell feature is removed on the machine.
/// </summary>
/// <returns>True if the current SKU is a Server Core machine or if the Server-GUI-Shell
/// feature is removed on the machine or else returns false.</returns>
private bool IsServerCoreOrHeadLessServer()
{
bool result = false;
using (RegistryKey installation = Registry.LocalMachine.OpenSubKey("SOFTWARE\\Microsoft\\Windows NT\\CurrentVersion"))
{
Dbg.Assert(installation != null, "the CurrentVersion subkey should exist");
string installationType = (string)installation.GetValue("InstallationType", string.Empty);
if (installationType.Equals("Server Core"))
{
result = true;
}
else if (installationType.Equals("Server"))
{
using (System.Management.Automation.PowerShell ps = System.Management.Automation.PowerShell.Create())
{
ps.AddScript(TestHeadlessServerScript);
Collection <PSObject> psObjectCollection = ps.Invoke(new object[0]);
Dbg.Assert(psObjectCollection != null && psObjectCollection.Count == 1, "invoke should never return null, there should be only one return item");
if (LanguagePrimitives.IsTrue(PSObject.Base(psObjectCollection[0])))
{
result = true;
}
}
}
}
return(result);
}
public virtual Collection <PSObject> RunPowerShellTest(params string[] scripts)
{
Collection <PSObject> output = null;
for (int i = 0; i < scripts.Length; ++i)
{
Console.WriteLine(scripts[i]);
powershell.AddScript(scripts[i]);
}
try
{
output = powershell.Invoke();
if (powershell.Streams.Error.Count > 0)
{
throw new RuntimeException(ErrorIsNotEmptyException);
}
return(output);
}
catch (Exception psException)
{
powershell.LogPowerShellException(psException, this.TestContext);
throw;
}
finally
{
powershell.LogPowerShellResults(output, this.TestContext);
powershell.Streams.Error.Clear();
}
}
public PSPathTranslationTests()
{
// create temp file
_tempFilePath = Path.GetTempFileName();
// initialize
var state = InitialSessionState.CreateDefault();
state.ThreadOptions = PSThreadOptions.UseCurrentThread;
state.ApartmentState = ApartmentState.STA;
_ps = System.Management.Automation.PowerShell.Create();
_ps.Runspace = RunspaceFactory.CreateRunspace(state);
_ps.Runspace.Open();
// create a new PSDrive for translation tests
_ps.AddCommand("New-PSDrive")
.AddParameter("Name", "mytemp")
.AddParameter("PSProvider", FileSystemProvider.ProviderName)
.AddParameter("Root", Path.GetTempPath());
_ps.Invoke();
Assert.True(_ps.Streams.Error.Count == 0, "Failed to create mytemp psdrive.");
_ps.Streams.ClearStreams();
_ps.Commands.Clear();
}
/// <summary>
/// A helper class that builds and executes a pipeline that writes to the
/// default output path. Any exceptions that are thrown are just passed to
/// the caller. Since all output goes to the default outter, this method()
/// won't return anything.
/// </summary>
/// <param name="cmd">The script to run</param>
/// <param name="input">Any input arguments to pass to the script. If null
/// then nothing is passed in.</param>
void executeHelper(string cmd, object input)
{
// Just ignore empty command lines...
if (String.IsNullOrEmpty(cmd))
return;
// Create the pipeline object and make it available
// to the ctrl-C handle through the currentPowerShell instance
// variable
lock (instanceLock)
{
currentPowerShell = PowerShell.Create();
}
currentPowerShell.Runspace = myRunSpace;
// Create a pipeline for this execution - place the result in the currentPowerShell
// instance variable so it is available to be stopped.
try
{
currentPowerShell.AddScript(cmd);
// Now add the default outputter to the end of the pipe and indicate
// that it should handle both output and errors from the previous
// commands. This will result in the output being written using the PSHost
// and PSHostUserInterface classes instead of returning objects to the hosting
// application.
currentPowerShell.AddCommand("out-default");
currentPowerShell.Commands.Commands[0].MergeMyResults(PipelineResultTypes.Error, PipelineResultTypes.Output);
// If there was any input specified, pass it in, otherwise just
// execute the pipeline...
if (input != null)
{
currentPowerShell.Invoke(new object[] { input });
}
else
{
currentPowerShell.Invoke();
}
}
finally
{
// Dispose of the pipeline line and set it to null, locked because currentPowerShell
// may be accessed by the ctrl-C handler...
lock (instanceLock)
{
currentPowerShell.Dispose();
currentPowerShell = null;
}
}
}
