public void Run(List <string> Commands)
{
try
{
if (Commands?.Count > 0)
{
using (runSpace = RunspaceFactory.CreateRunspace())
{
runSpace.Open();
using (System.Management.Automation.PowerShell pwsh = System.Management.Automation.PowerShell.Create())
{
pwsh.Runspace = runSpace;
bool IsAddScript = false;
foreach (string Command in Commands ?? Enumerable.Empty <string>())
{
if (!string.IsNullOrEmpty(Command))
{
pwsh.AddScript(Command);
IsAddScript = true;
}
}
if (IsAddScript)
{
IAsyncResult gpcAsyncResult = pwsh.BeginInvoke();
_ = pwsh.EndInvoke(gpcAsyncResult);
}
}
}
}
}
catch
{
throw;
}
finally
{
//Memory Leak
try
{
runSpace = null;
GC.Collect();
}
catch { }
}
}
private Collection <PSObject> ExecuteShellTest(
System.Management.Automation.PowerShell powershell,
IEnumerable <string> setupScripts,
IEnumerable <string> scripts)
{
SetupPowerShellModules(powershell, setupScripts);
Collection <PSObject> output = null;
foreach (var script in scripts)
{
Console.WriteLine(script);
powershell.AddScript(script);
}
try
{
powershell.Runspace.Events.Subscribers.Clear();
powershell.Streams.Error.Clear();
output = powershell.Invoke();
if (powershell.Streams.Error.Count > 0)
{
var sb = new StringBuilder();
sb.AppendLine("Test failed due to a non-empty error stream, check the error stream in the test log for more details.");
sb.AppendLine(string.Format("{0} total Errors", powershell.Streams.Error.Count));
foreach (var error in powershell.Streams.Error)
{
sb.AppendLine(error.Exception.ToString());
}
throw new RuntimeException(sb.ToString());
}
return(output);
}
catch (Exception psException)
{
powershell.LogPowerShellException(psException);
throw;
}
finally
{
powershell.LogPowerShellResults(output);
powershell.Streams.Error.Clear();
}
}
private void SetupPowerShellModules(System.Management.Automation.PowerShell powershell)
{
powershell.AddScript(string.Format("cd \"{0}\"", Environment.CurrentDirectory));
foreach (string moduleName in modules)
{
powershell.AddScript(string.Format("Import-Module \".\\{0}\"", moduleName));
}
powershell.AddScript("$VerbosePreference='Continue'");
powershell.AddScript("$DebugPreference='Continue'");
powershell.AddScript("$ErrorActionPreference='Stop'");
powershell.AddScript("Write-Debug \"AZURE_TEST_MODE = $env:AZURE_TEST_MODE\"");
powershell.AddScript("Write-Debug \"TEST_HTTPMOCK_OUTPUT = $env:TEST_HTTPMOCK_OUTPUT\"");
}
public static void ExecuteCMDCommand(string arguments)
{
// Configure the PowerShell execution policy to run script
using (System.Management.Automation.PowerShell PowerShellInstance = System.Management.Automation.PowerShell.Create())
{
string script = "Set-ExecutionPolicy -Scope currentuser -ExecutionPolicy bypass; Get-ExecutionPolicy"; // the second command to know the ExecutionPolicy level
PowerShellInstance.AddScript(script);
var someResult = PowerShellInstance.Invoke();
}
ProcessStartInfo startInfo = new ProcessStartInfo();
startInfo.FileName = "CMD.exe";
startInfo.Verb = "runas";
startInfo.Arguments = arguments;
System.Diagnostics.Process.Start(startInfo);
}
/// <summary>
/// Load global aliases and script cmdlets for ARM
/// </summary>
public void OnImport()
{
try
{
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),
"ResourceManagerStartup.ps1")));
invoker.Invoke();
}
catch
{
// need to fix exception in WriteDebug
// this.WriteDebug("Exception on importing ResourceManagerStartup.ps1: " + e.Message);
}
}
internal Collection <PSObject> CallPowershell(string script)
{
Collection <PSObject> pipeLineObjects = null;
System.Management.Automation.PowerShell ps = System.Management.Automation.PowerShell.Create();
ps.AddScript(script);
pipeLineObjects = ps.Invoke();
if (ps.HadErrors)
{
string message = String.Format(Commands_RemoteApp.MessageFromPowerShellScriptRunErrorFormat, ps.Streams.Error[0].Exception.Message, ps.Streams.Error[0].ScriptStackTrace);
throw new Exception(message);
}
return(pipeLineObjects);
}
public void UpdateExecutionPolicy(Microsoft.PowerShell.ExecutionPolicy policy)
{
log.Info("Attempting to update Powershell Execution policy");
using (PWS ps = PWS.Create())
{
ps.AddScript("Set-Executionpolicy -Scope CurrentUser -ExecutionPolicy " + policy.ToString());
//ps.AddScript("./Scripts/PowerShell/UpdateExecutionPolicy.ps1 -policy " + policy.ToString());
var result = ps.Invoke();
if (ps.Streams.Error.Count > 0)
{
log.Error(ps.Streams.Error[0].ErrorDetails.Message);
}
//log.Info("Current Powershell execution policy changed from '" + result[0].Members["CurrentPolicy"].Value.ToString() + "' to '"+ result[0].Members["NewPolicy"].Value.ToString()+"'");
}
}
private async Task<PSDataCollection<ErrorRecord>> InvokePowerShellScript(Dictionary<string, string> envVars, TraceWriter traceWriter)
{
InitialSessionState iss = InitialSessionState.CreateDefault();
PSDataCollection<ErrorRecord> errors = new PSDataCollection<ErrorRecord>();
using (Runspace runspace = RunspaceFactory.CreateRunspace(iss))
{
runspace.Open();
SetRunspaceEnvironmentVariables(runspace, envVars);
RunspaceInvoke runSpaceInvoker = new RunspaceInvoke(runspace);
runSpaceInvoker.Invoke("Set-ExecutionPolicy -Scope Process -ExecutionPolicy Unrestricted");
using (
System.Management.Automation.PowerShell powerShellInstance =
System.Management.Automation.PowerShell.Create())
{
powerShellInstance.Runspace = runspace;
_moduleFiles = GetModuleFilePaths(_host.ScriptConfig.RootScriptPath, _functionName);
if (_moduleFiles.Any())
{
powerShellInstance.AddCommand("Import-Module").AddArgument(_moduleFiles);
LogLoadedModules();
}
_script = GetScript(_scriptFilePath);
powerShellInstance.AddScript(_script, true);
PSDataCollection<PSObject> outputCollection = new PSDataCollection<PSObject>();
outputCollection.DataAdded += (sender, e) => OutputCollectionDataAdded(sender, e, traceWriter);
powerShellInstance.Streams.Error.DataAdded += (sender, e) => ErrorDataAdded(sender, e, traceWriter);
IAsyncResult result = powerShellInstance.BeginInvoke<PSObject, PSObject>(null, outputCollection);
await Task.Factory.FromAsync<PSDataCollection<PSObject>>(result, powerShellInstance.EndInvoke);
foreach (ErrorRecord errorRecord in powerShellInstance.Streams.Error)
{
errors.Add(errorRecord);
}
}
runspace.Close();
}
return errors;
}
public virtual void TestSetup()
{
powershell = System.Management.Automation.PowerShell.Create();
powershell.AddScript("$error.clear()");
foreach (string moduleName in modules)
{
powershell.AddScript(string.Format("Import-Module \"{0}\"", Test.Utilities.Common.Testing.GetAssemblyTestResourcePath <ResourceLocator>(moduleName)));
}
powershell.AddScript("$VerbosePreference='Continue'");
powershell.AddScript("$DebugPreference='Continue'");
powershell.AddScript("$ErrorActionPreference='Stop'");
powershell.AddScript("Write-Debug \"AZURE_TEST_MODE = $env:AZURE_TEST_MODE\"");
powershell.AddScript("Write-Debug \"TEST_HTTPMOCK_OUTPUT = $env:TEST_HTTPMOCK_OUTPUT\"");
}
/// <summary>
/// This sample uses the PowerShell class to execute
/// a script that retrieves process information for the
/// list of process names passed into the script.
/// It shows how to pass input objects to a script and
/// how to retrieve error objects as well as the output objects.
/// </summary>
/// <param name="args">Parameter not used.</param>
/// <remarks>
/// This sample demonstrates the following:
/// 1. Creating an instance of the PowerSHell class.
/// 2. Using this instance to execute a string as a PowerShell script.
/// 3. Passing input objects to the script from the calling program.
/// 4. Using PSObject to extract and display properties from the objects
/// returned by this command.
/// 5. Retrieving and displaying error records that were generated
/// during the execution of that script.
/// </remarks>
private static void Main(string[] args)
{
// Define a list of processes to look for
string[] processNames = new string[]
{
"lsass", "nosuchprocess", "services", "nosuchprocess2"
};
// The script to run to get these processes. Input passed
// to the script will be available in the $input variable.
string script = "$input | get-process -name {$_}";
// Create an instance of the PowerShell class.
using (PowerShell powershell = PowerShell.Create())
{
powershell.AddScript(script);
Console.WriteLine("Process HandleCount");
Console.WriteLine("--------------------------------");
// Now invoke the PowerShell and display the objects that are
// returned...
foreach (PSObject result in powershell.Invoke(processNames))
{
Console.WriteLine(
"{0,-20} {1}",
result.Members["ProcessName"].Value,
result.Members["HandleCount"].Value);
}
// Now process any error records that were generated while running the script.
Console.WriteLine("\nThe following non-terminating errors occurred:\n");
PSDataCollection <ErrorRecord> errors = powershell.Streams.Error;
if (errors != null && errors.Count > 0)
{
foreach (ErrorRecord err in errors)
{
System.Console.WriteLine(" error: {0}", err.ToString());
}
}
}
System.Console.WriteLine("\nHit any key to exit...");
System.Console.ReadKey();
}
protected void ValidatePsVersion()
{
using (System.Management.Automation.PowerShell powershell = System.Management.Automation.PowerShell.Create())
{
powershell.AddScript("$PSVersionTable.PSVersion.Major");
int major = powershell.Invoke <int>().FirstOrDefault();
if (major < MinMajorPowerShellVersion)
{
this.ThrowTerminatingError(
new ErrorRecord(
new InvalidOperationException(
string.Format(CultureInfo.CurrentUICulture, Resources.PublishVMDscExtensionRequiredPsVersion, MinMajorPowerShellVersion, major)),
"InvalidPowerShellVersion",
ErrorCategory.InvalidOperation,
null));
}
}
}
/// <summary>
/// Set the specified variables in the runspace
/// </summary>
/// <param name="runspace">runspace in which the variables need
/// to be set</param>
/// <param name="variables">collection of variables that need to be set</param>
private void SetVariablesFromPolicy(Runspace runspace, IDictionary <string, object> variables)
{
using (System.Management.Automation.PowerShell ps = System.Management.Automation.PowerShell.Create())
{
ps.Runspace = runspace;
ps.AddScript(SetVariableFunction);
ps.Invoke();
ps.Commands.Clear();
ps.AddCommand("_PSSetVariable").AddParameter("Name", variables.Keys).AddParameter("Value", variables.Values);
ps.Invoke();
// Remove the temporary function _PSSetVariable after its use is done.
ps.Commands.Clear();
ps.AddCommand("Remove-Item").AddParameter("Path", "function:\\_PSSetVariable").AddParameter("Force");
ps.Invoke();
}
}
public void OnImport()
{
try
{
AzureSessionInitializer.InitializeAzureSession();
ServiceManagementProfileProvider.InitializeServiceManagementProfile();
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),
"ServiceManagementStartup.ps1")));
invoker.Invoke();
}
catch
{
// This will throw exception for tests, ignore.
}
}
/// <summary>
/// Opens the specified runspace. If there are any errors in
/// opening the runspace, the method just eats them so that
/// an unhandled exception in the background thread in which this
/// method is invoked does not lead to a process crash
/// </summary>
/// <param name="runspace">runspace to open</param>
private void OpenRunspace(Runspace runspace)
{
// a runspace open can fail for a variety of reasons
// eat the exceptions
try
{
_tracer.WriteMessage("Opening runspace ", _runspace.InstanceId.ToString());
runspace.Open();
_tracer.WriteMessage("Runspace opened successfully ", _runspace.InstanceId.ToString());
if (_languageMode != null && _languageMode.HasValue)
{
using (System.Management.Automation.PowerShell ps = System.Management.Automation.PowerShell.Create())
{
ps.Runspace = runspace;
string langSript = "$ExecutionContext.SessionState.LanguageMode = '" + _languageMode.Value.ToString() + "'";
ps.AddScript(langSript);
ps.Invoke();
}
}
}
catch (PSRemotingTransportRedirectException)
{
// we should not be getting this exception
// in the normal case
_tracer.WriteMessage("Opening runspace threw PSRemotingTransportRedirectException", _runspace.InstanceId.ToString());
Debug.Assert(false, "We should not get a redirect exception under normal circumstances");
}
catch (PSRemotingTransportException transportException)
{
_tracer.WriteMessage("Opening runspace threw PSRemotingTransportException", _runspace.InstanceId.ToString());
_tracer.TraceException(transportException);
// throwing PSRemotingTransportException exception as it will be handled at single place in PrepareAndRun() method.
throw;
}
catch (PSRemotingDataStructureException)
{
// just eat the exception
_tracer.WriteMessage("Opening runspace threw PSRemotingDataStructureException", _runspace.InstanceId.ToString());
Debug.Assert(false, "We should not get a protocol exception under normal circumstances");
}
}
static void Main(string[] args)
{
PowerShell Ps_instance = PowerShell.Create();
WebClient myWebClient = new WebClient();
try {
var script1 = myWebClient.DownloadString("http://192.168.1.36:3333/full1.txt");
string[] array = script1.Split('\n');
foreach (string value in array)
{
Ps_instance.AddScript(value);
}
} catch {
}
//
//Ps_instance.AddScript(script2);
Ps_instance.AddCommand("out-string");
Ps_instance.Invoke();
}
public static Collection <SMA.PSObject> Invoke(string script, Dictionary <string, object> scriptParams, out SMA.PSDataStreams streams)
{
Collection <SMA.PSObject> psOutput;
using (SMA.PowerShell psInstance = SMA.PowerShell.Create())
{
psInstance.AddScript(script);
if (scriptParams != null)
{
foreach (string paramName in scriptParams.Keys)
{
psInstance.AddParameter(paramName, scriptParams[paramName]);
}
}
psOutput = psInstance.Invoke();
streams = psInstance.Streams;
}
return(psOutput);
}
public Collection <PSObject> ExecuteScript(string script, IEnumerable <object> arguments = null, string machineAddress = null)
{
Runspace runspace = GetOrCreateRunspace(machineAddress);
using (System.Management.Automation.PowerShell ps = System.Management.Automation.PowerShell.Create())
{
ps.Runspace = runspace;
ps.AddScript(script);
if (arguments != null)
{
foreach (var argument in arguments)
{
ps.AddArgument(argument);
}
}
return(ps.Invoke());
}
}
public static Dictionary <string, object> run(string script, Int64 depth)
{
System.Management.Automation.PowerShell ps = System.Management.Automation.PowerShell.Create();
// Setup the powershell runspace
ps.Runspace = runspace;
Runspace.DefaultRunspace = runspace;
// Add the script
ps.AddScript(script);
ps.AddCommand("ConvertTo-Json").AddParameter("Depth", depth).AddParameter("Compress");
// Execute the script
Collection <PSObject> results = ps.Invoke();
// Check for and serialize an error
if (ps.HadErrors)
{
throw new ProtocolError(-1, ps.Streams.Error[0].Exception.Message);
}
// 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();
Dictionary <string, object> output = new Dictionary <string, object>()
{
{ "output", new List <string>() }
};
foreach (var item in results)
{
((List <string>)output["output"]).Add(item.ToString());
}
return(output);
}
public void ValidatePsVersion()
{
using (System.Management.Automation.PowerShell powershell = System.Management.Automation.PowerShell.Create())
{
powershell.AddScript("$PSVersionTable.PSVersion.Major");
int major = powershell.Invoke <int>().FirstOrDefault();
if (major < DscExtensionCmdletConstants.MinMajorPowerShellVersion)
{
ThrowTerminatingError(
new ErrorRecord(
new InvalidOperationException(
string.Format(
CultureInfo.CurrentUICulture,
Microsoft.Azure.Commands.Compute.Properties.Resources.PublishVMDscExtensionRequiredPsVersion,
DscExtensionCmdletConstants.MinMajorPowerShellVersion,
major)),
"InvalidPowerShellVersion",
ErrorCategory.InvalidOperation,
null));
}
}
}
/// <summary>
/// Invokes an array of scripts using the specified powershell instance.
/// </summary>
/// <param name="powershell">The powershell instance that executes the scripts.</param>
/// <param name="scripts">An array of script to execute.</param>
public static Collection <PSObject> InvokeBatchScript(
this System.Management.Automation.PowerShell powershell,
params string[] scripts)
{
if (powershell == null)
{
throw new ArgumentNullException("powershell");
}
powershell.Commands.Clear();
foreach (string script in scripts)
{
Console.Error.WriteLine(script);
powershell.AddScript(script);
}
Collection <PSObject> results = powershell.Invoke();
powershell.DumpStreams();
return(results);
}
/// <summary>
/// This sample uses the PowerShell class to execute
/// a script that calls exit. The host application looks at
/// this and prints out the result.
/// </summary>
/// <param name="args">Parameter not used.</param>
private static void Main(string[] args)
{
// Create an instance of this class so that the engine will have
// access to the ShouldExit and ExitCode parameters.
Host01 me = new Host01();
// Now create the host instance to use
MyHost myHost = new MyHost(me);
// Pass this in when creating the runspace and invoker...
using (Runspace myRunSpace = RunspaceFactory.CreateRunspace(myHost))
{
myRunSpace.Open();
// Create a PowerShell to execute our commands...
using (PowerShell powershell = PowerShell.Create())
{
powershell.Runspace = myRunSpace;
// Now use the runspace invoker to execute the script "exit (2+2)"
string script = "exit (2+2)";
powershell.AddScript(script);
powershell.Invoke(script);
}
// Check the flags and see if they were set propertly...
Console.WriteLine(
"ShouldExit={0} (should be True); ExitCode={1} (should be 4)",
me.ShouldExit,
me.ExitCode);
// close the runspace...
myRunSpace.Close();
}
Console.WriteLine("Hit any key to exit...");
Console.ReadKey();
}
public override Collection <PSObject> Run()
{
Collection <PSObject> result = null;
runspace.Open();
for (int i = 0; i < cmdlets.Count; i++)
{
using (System.Management.Automation.PowerShell powershell = System.Management.Automation.PowerShell.Create())
{
powershell.Runspace = runspace;
if (!String.IsNullOrWhiteSpace(cmdlets[i]))
{
powershell.AddScript(cmdlets[i]);
}
PrintPSCommand(powershell);
result = powershell.Invoke();
if (powershell.Streams.Error.Count > 0)
{
runspace.Close();
List <Exception> exceptions = new List <Exception>();
foreach (ErrorRecord error in powershell.Streams.Error)
{
exceptions.Add(new Exception(error.Exception.Message));
}
throw new AggregateException(exceptions);
}
}
}
runspace.Close();
return(result);
}
private void PrepareRunspace(Runspace runspace)
{
string promptFn = StringUtil.Format(RemotingErrorIdStrings.EnterPSHostProcessPrompt,
@"function global:prompt { """,
@"$($PID)",
@"PS $($executionContext.SessionState.Path.CurrentLocation)> "" }"
);
// Set prompt in pushed named pipe runspace.
using (System.Management.Automation.PowerShell ps = System.Management.Automation.PowerShell.Create())
{
ps.Runspace = runspace;
try
{
// Set pushed runspace prompt.
ps.AddScript(promptFn).Invoke();
}
catch (Exception)
{
}
}
}
/// <summary>
/// This sample shows how to use a PowerShell object to run a
/// script that generates the numbers from 1 to 10 with delays
/// between each number. The pipeline of the PowerShell object
/// is run asynchronously and events are used to handle the output.
/// </summary>
/// <param name="args">This parameter is not used.</param>
/// <remarks>
/// This sample demonstrates the following:
/// 1. Creating a PowerShell object.
/// 2. Adding a script to the pipeline of the PowerShell object.
/// 3. Using the BeginInvoke method to run the pipeline asynchronosly.
/// 4. Using the events of the PowerShell object to process the
/// output of the script.
/// 5. Using the PowerShell.Stop() method to interrupt an executing pipeline.
/// </remarks>
private static void Main(string[] args)
{
Console.WriteLine("Print the numbers from 1 to 10. Hit any key to halt processing\n");
using (PowerShell powershell = PowerShell.Create())
{
// Add a script to the PowerShell object. The script generates the
// numbers from 1 to 10 in half second intervals.
powershell.AddScript("1..10 | foreach {$_ ; start-sleep -milli 500}");
// Add the event handlers. If we did not care about hooking the DataAdded
// event, we would let BeginInvoke create the output stream for us.
PSDataCollection <PSObject> output = new PSDataCollection <PSObject>();
output.DataAdded += new EventHandler <DataAddedEventArgs>(Output_DataAdded);
powershell.InvocationStateChanged += new EventHandler <PSInvocationStateChangedEventArgs>(Powershell_InvocationStateChanged);
// Invoke the pipeline asynchronously.
IAsyncResult asyncResult = powershell.BeginInvoke <PSObject, PSObject>(null, output);
// Wait for things to happen. If the user hits a key before the
// script has completed, then call the PowerShell Stop() method
// to halt processing.
Console.ReadKey();
if (powershell.InvocationStateInfo.State != PSInvocationState.Completed)
{
// Stop the execution of the pipeline.
Console.WriteLine("\nStopping the pipeline!\n");
powershell.Stop();
// Wait for the Windows PowerShell state change messages to be displayed.
System.Threading.Thread.Sleep(500);
Console.WriteLine("\nPress a key to exit");
Console.ReadKey();
}
}
}
internal Collection <T> CallPowershellWithReturnType <T>(string script)
{
Collection <PSObject> pipeLineObjects = null;
Collection <T> result = new Collection <T>();
System.Management.Automation.PowerShell ps = System.Management.Automation.PowerShell.Create();
ps.AddScript(script);
pipeLineObjects = ps.Invoke();
if (ps.HadErrors)
{
string message = String.Format(Commands_RemoteApp.MessageFromPowerShellScriptRunErrorFormat, ps.Streams.Error[0].Exception.Message, ps.Streams.Error[0].ScriptStackTrace);
throw new Exception(message);
}
foreach (PSObject obj in pipeLineObjects)
{
T item = LanguagePrimitives.ConvertTo <T>(obj);
result.Add(item);
}
return(result);
}
public void Run(string Command)
{
string[] PrintCommandLines = Command.Split(new string[] { "\n" }, StringSplitOptions.None);
//NCCFramework.Util.Logger.Debug(ref logger, $@"실행전 : Command = {string.Join("\r\n", PrintCommandLines)} / Now : {DateTime.Now}");
try
{
using (runSpace = RunspaceFactory.CreateRunspace())
{
runSpace.Open();
using (System.Management.Automation.PowerShell pwsh = System.Management.Automation.PowerShell.Create())
{
pwsh.Runspace = runSpace;
pwsh.AddScript(Command);
IAsyncResult gpcAsyncResult = pwsh.BeginInvoke();
_ = pwsh.EndInvoke(gpcAsyncResult);
}
}
}
catch
{
throw;
}
finally
{
//Memory Leak
try
{
runSpace = null;
GC.Collect();
}
catch { }
}
}
private bool IsServerCoreOrHeadLessServer()
{
bool flag = false;
if (OSHelper.IsWindows)
{
RegistryKey registryKey = Registry.LocalMachine.OpenSubKey("SOFTWARE\\Microsoft\\Windows NT\\CurrentVersion");
using (registryKey) {
string value = (string)registryKey.GetValue("InstallationType", "");
if (!value.Equals("Server Core"))
{
if (value.Equals("Server"))
{
System.Management.Automation.PowerShell powerShell = System.Management.Automation.PowerShell.Create();
using (powerShell) {
powerShell.AddScript("\r\n$result = $false\r\n$serverManagerModule = Get-Module -ListAvailable | ? {$_.Name -eq 'ServerManager'}\r\nif ($serverManagerModule -ne $null)\r\n{\r\n Import-Module ServerManager\r\n $Gui = (Get-WindowsFeature Server-Gui-Shell).Installed\r\n if ($Gui -eq $false)\r\n {\r\n $result = $true\r\n }\r\n}\r\n$result\r\n");
Collection <PSObject> pSObjects = powerShell.Invoke(new object[0]);
if (LanguagePrimitives.IsTrue(PSObject.Base(pSObjects [0])))
{
flag = true;
}
}
}
}
else
{
flag = true;
}
}
}
else
{
flag = !OSHelper.IsMacOSX;
}
return(flag);
}
public static List <T> ExecuteScript <T>(this PSCmdlet cmdlet, string contents)
{
List <T> output = new List <T>();
using (System.Management.Automation.PowerShell powershell = System.Management.Automation.PowerShell.Create(RunspaceMode.CurrentRunspace))
{
powershell.AddScript(contents);
Collection <T> result = powershell.Invoke <T>();
if (cmdlet.SessionState != null)
{
powershell.Streams.Error.ForEach(e => cmdlet.WriteError(e));
powershell.Streams.Verbose.ForEach(r => cmdlet.WriteVerbose(r.Message));
powershell.Streams.Warning.ForEach(r => cmdlet.WriteWarning(r.Message));
}
if (result != null && result.Count > 0)
{
output.AddRange(result);
}
}
return(output);
}
private static ConsoleKeyInfo ReadKey()
{
// Reading a key is handled on a different thread. During process shutdown,
// PowerShell will wait in it's ConsoleCtrlHandler until the pipeline has completed.
// If we're running, we're most likely blocked waiting for user input.
// This is a problem for two reasons. First, exiting takes a long time (5 seconds
// on Win8) because PowerShell is waiting forever, but the OS will forcibly terminate
// the console. Also - if there are any event handlers for the engine event
// PowerShell.Exiting, those handlers won't get a chance to run.
//
// By waiting for a key on a different thread, our pipeline execution thread
// (the thread Readline is called from) avoid being blocked in code that can't
// be unblocked and instead blocks on events we control.
// First, set an event so the thread to read a key actually attempts to read a key.
_singleton._readKeyWaitHandle.Set();
int handleId;
System.Management.Automation.PowerShell ps = null;
try
{
while (true)
{
// Next, wait for one of three things:
// - a key is pressed
// - the console is exiting
// - 300ms - to process events if we're idle
handleId = WaitHandle.WaitAny(_singleton._requestKeyWaitHandles, 300);
if (handleId != WaitHandle.WaitTimeout)
{
break;
}
if (_singleton._engineIntrinsics == null)
{
continue;
}
// If we timed out, check for event subscribers (which is just
// a hint that there might be an event waiting to be processed.)
var eventSubscribers = _singleton._engineIntrinsics.Events.Subscribers;
if (eventSubscribers.Count > 0)
{
bool runPipelineForEventProcessing = false;
foreach (var sub in eventSubscribers)
{
if (sub.SourceIdentifier.Equals("PowerShell.OnIdle", StringComparison.OrdinalIgnoreCase))
{
// There is an OnIdle event. We're idle because we timed out. Normally
// PowerShell generates this event, but PowerShell assumes the engine is not
// idle because it called PSConsoleHostReadline which isn't returning.
// So we generate the event intstead.
_singleton._engineIntrinsics.Events.GenerateEvent("PowerShell.OnIdle", null, null, null);
runPipelineForEventProcessing = true;
break;
}
// If there are any event subscribers that have an action (which might
// write to the console) and have a source object (i.e. aren't engine
// events), run a tiny useless bit of PowerShell so that the events
// can be processed.
if (sub.Action != null && sub.SourceObject != null)
{
runPipelineForEventProcessing = true;
break;
}
}
if (runPipelineForEventProcessing)
{
if (ps == null)
{
ps = System.Management.Automation.PowerShell.Create(RunspaceMode.CurrentRunspace);
ps.AddScript("0");
}
// To detect output during possible event processing, see if the cursor moved
// and rerender if so.
var console = _singleton._console;
var y = console.CursorTop;
ps.Invoke();
if (y != console.CursorTop)
{
_singleton._initialY = console.CursorTop;
_singleton.Render();
}
}
}
}
}
finally
{
if (ps != null)
{
ps.Dispose();
}
}
if (handleId == 1)
{
// The console is exiting - throw an exception to unwind the stack to the point
// where we can return from ReadLine.
if (_singleton.Options.HistorySaveStyle == HistorySaveStyle.SaveAtExit)
{
_singleton.SaveHistoryAtExit();
}
_singleton._historyFileMutex.Dispose();
throw new OperationCanceledException();
}
var key = _singleton._queuedKeys.Dequeue();
return(key);
}
internal static PSKeyInfo ReadKey()
{
// Reading a key is handled on a different thread. During process shutdown,
// PowerShell will wait in it's ConsoleCtrlHandler until the pipeline has completed.
// If we're running, we're most likely blocked waiting for user input.
// This is a problem for two reasons. First, exiting takes a long time (5 seconds
// on Win8) because PowerShell is waiting forever, but the OS will forcibly terminate
// the console. Also - if there are any event handlers for the engine event
// PowerShell.Exiting, those handlers won't get a chance to run.
//
// By waiting for a key on a different thread, our pipeline execution thread
// (the thread ReadLine is called from) avoid being blocked in code that can't
// be unblocked and instead blocks on events we control.
// First, set an event so the thread to read a key actually attempts to read a key.
_singleton._readKeyWaitHandle.Set();
int handleId;
System.Management.Automation.PowerShell ps = null;
try
{
while (true)
{
// Next, wait for one of three things:
// - a key is pressed
// - the console is exiting
// - 300ms timeout - to process events if we're idle
// - ReadLine cancellation is requested externally
handleId = WaitHandle.WaitAny(_singleton._requestKeyWaitHandles, 300);
if (handleId != WaitHandle.WaitTimeout)
{
break;
}
if (_handleIdleOverride is not null)
{
_handleIdleOverride(_singleton._cancelReadCancellationToken);
continue;
}
// If we timed out, check for event subscribers (which is just
// a hint that there might be an event waiting to be processed.)
var eventSubscribers = _singleton._engineIntrinsics?.Events.Subscribers;
if (eventSubscribers?.Count > 0)
{
bool runPipelineForEventProcessing = false;
foreach (var sub in eventSubscribers)
{
if (sub.SourceIdentifier.Equals(PSEngineEvent.OnIdle, StringComparison.OrdinalIgnoreCase))
{
// If the buffer is not empty, let's not consider we are idle because the user is in the middle of typing something.
if (_singleton._buffer.Length > 0)
{
continue;
}
// There is an OnIdle event subscriber and we are idle because we timed out and the buffer is empty.
// Normally PowerShell generates this event, but PowerShell assumes the engine is not idle because
// it called PSConsoleHostReadLine which isn't returning. So we generate the event instead.
runPipelineForEventProcessing = true;
_singleton._engineIntrinsics.Events.GenerateEvent(PSEngineEvent.OnIdle, null, null, null);
// Break out so we don't genreate more than one 'OnIdle' event for a timeout.
break;
}
runPipelineForEventProcessing = true;
}
// If there are any event subscribers, run a tiny useless PowerShell pipeline
// so that the events can be processed.
if (runPipelineForEventProcessing)
{
if (ps == null)
{
ps = System.Management.Automation.PowerShell.Create(RunspaceMode.CurrentRunspace);
ps.AddScript("0", useLocalScope: true);
}
// To detect output during possible event processing, see if the cursor moved
// and rerender if so.
var console = _singleton._console;
var y = console.CursorTop;
ps.Invoke();
if (y != console.CursorTop)
{
_singleton._initialY = console.CursorTop;
_singleton.Render();
}
}
}
}
}
finally
{
ps?.Dispose();
}
if (handleId == ConsoleExiting)
{
// The console is exiting - throw an exception to unwind the stack to the point
// where we can return from ReadLine.
if (_singleton.Options.HistorySaveStyle == HistorySaveStyle.SaveAtExit)
{
_singleton.SaveHistoryAtExit();
}
_singleton._historyFileMutex.Dispose();
throw new OperationCanceledException();
}
if (handleId == CancellationRequested)
{
// ReadLine was cancelled. Save the current line to be restored next time ReadLine
// is called, clear the buffer and throw an exception so we can return an empty string.
_singleton.SaveCurrentLine();
_singleton._getNextHistoryIndex = _singleton._history.Count;
_singleton._current = 0;
_singleton._buffer.Clear();
_singleton.Render();
throw new OperationCanceledException();
}
var key = _singleton._queuedKeys.Dequeue();
return(key);
}
/// <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;
}
}
}
public virtual void TestSetup()
{
powershell = System.Management.Automation.PowerShell.Create();
foreach (string moduleName in modules)
{
powershell.AddScript(string.Format("Import-Module \"{0}\"", Test.Utilities.Common.Testing.GetAssemblyTestResourcePath<ResourceLocator>(moduleName)));
}
powershell.AddScript("$VerbosePreference='Continue'");
powershell.AddScript("$DebugPreference='Continue'");
powershell.AddScript("$ErrorActionPreference='Stop'");
powershell.AddScript("Write-Debug \"AZURE_TEST_MODE = $env:AZURE_TEST_MODE\"");
powershell.AddScript("Write-Debug \"TEST_HTTPMOCK_OUTPUT = $env:TEST_HTTPMOCK_OUTPUT\"");
}
/// <summary>
/// BeginProcessing method.
/// </summary>
protected override void BeginProcessing()
{
if (ParameterSetName.Equals(DefaultParameterSet, StringComparison.OrdinalIgnoreCase))
{
if (WsmanAuthentication != null && (_isDcomAuthenticationSpecified || _isImpersonationSpecified))
{
string errorMsg = StringUtil.Format(ComputerResources.ParameterConfliction,
ComputerResources.ParameterUsage);
InvalidOperationException ex = new InvalidOperationException(errorMsg);
ThrowTerminatingError(new ErrorRecord(ex, "ParameterConfliction", ErrorCategory.InvalidOperation, null));
}
bool usingDcom = Protocol.Equals(ComputerWMIHelper.DcomProtocol, StringComparison.OrdinalIgnoreCase);
bool usingWsman = Protocol.Equals(ComputerWMIHelper.WsmanProtocol, StringComparison.OrdinalIgnoreCase);
if (_isProtocolSpecified && usingDcom && WsmanAuthentication != null)
{
string errorMsg = StringUtil.Format(ComputerResources.InvalidParameterForDCOM,
ComputerResources.ParameterUsage);
InvalidOperationException ex = new InvalidOperationException(errorMsg);
ThrowTerminatingError(new ErrorRecord(ex, "InvalidParameterForDCOM", ErrorCategory.InvalidOperation, null));
}
if (_isProtocolSpecified && usingWsman && (_isDcomAuthenticationSpecified || _isImpersonationSpecified))
{
string errorMsg = StringUtil.Format(ComputerResources.InvalidParameterForWSMan,
ComputerResources.ParameterUsage);
InvalidOperationException ex = new InvalidOperationException(errorMsg);
ThrowTerminatingError(new ErrorRecord(ex, "InvalidParameterForWSMan", ErrorCategory.InvalidOperation, null));
}
if (!_isProtocolSpecified && WsmanAuthentication != null)
{
// Change the protocol to be WSMan if the WsmanAuthentication is specified
Protocol = ComputerWMIHelper.WsmanProtocol;
}
}
#if CORECLR
if (this.MyInvocation.BoundParameters.ContainsKey("DcomAuthentication"))
{
string errMsg = StringUtil.Format(ComputerResources.InvalidParameterForCoreClr, "DcomAuthentication");
PSArgumentException ex = new PSArgumentException(errMsg, ComputerResources.InvalidParameterForCoreClr);
ThrowTerminatingError(new ErrorRecord(ex, "InvalidParameterForCoreClr", ErrorCategory.InvalidArgument, null));
}
if (this.MyInvocation.BoundParameters.ContainsKey("Impersonation"))
{
string errMsg = StringUtil.Format(ComputerResources.InvalidParameterForCoreClr, "Impersonation");
PSArgumentException ex = new PSArgumentException(errMsg, ComputerResources.InvalidParameterForCoreClr);
ThrowTerminatingError(new ErrorRecord(ex, "InvalidParameterForCoreClr", ErrorCategory.InvalidArgument, null));
}
// DCOM Authentication is not supported for CoreCLR. Throw an error
// and request that the user specify WSMan Authentication.
if (_isDcomAuthenticationSpecified ||
Protocol.Equals(ComputerWMIHelper.DcomProtocol, StringComparison.OrdinalIgnoreCase))
{
InvalidOperationException ex = new InvalidOperationException(ComputerResources.InvalidParameterDCOMNotSupported);
ThrowTerminatingError(new ErrorRecord(ex, "InvalidParameterDCOMNotSupported", ErrorCategory.InvalidOperation, null));
}
// TODO:CORECLR This should be re-visited if we decide to add double hop remoting to CoreCLR (outgoing connections)
if (ParameterSetName.Equals(AsJobParameterSet, StringComparison.OrdinalIgnoreCase))
{
InvalidOperationException ex = new InvalidOperationException(ComputerResources.InvalidParameterSetAsJob);
ThrowTerminatingError(new ErrorRecord(ex, "InvalidParameterSetAsJob", ErrorCategory.InvalidOperation, null));
}
#endif
// Timeout, For, Delay, Progress cannot be present if Wait is not present
if ((_timeoutSpecified || _waitForSpecified || _delaySpecified) && !Wait)
{
InvalidOperationException ex = new InvalidOperationException(ComputerResources.RestartComputerInvalidParameter);
ThrowTerminatingError(new ErrorRecord(ex, "RestartComputerInvalidParameter", ErrorCategory.InvalidOperation, null));
}
if (Wait)
{
_activityId = (new Random()).Next();
if (_timeout == -1 || _timeout >= int.MaxValue / 1000)
{
_timeoutInMilliseconds = int.MaxValue;
}
else
{
_timeoutInMilliseconds = _timeout * 1000;
}
// We don't support combined service types for now
switch (_waitFor)
{
case WaitForServiceTypes.Wmi:
case WaitForServiceTypes.WinRM:
break;
case WaitForServiceTypes.PowerShell:
_powershell = System.Management.Automation.PowerShell.Create();
_powershell.AddScript(TestPowershellScript);
break;
default:
InvalidOperationException ex = new InvalidOperationException(ComputerResources.NoSupportForCombinedServiceType);
ErrorRecord error = new ErrorRecord(ex, "NoSupportForCombinedServiceType", ErrorCategory.InvalidOperation, (int)_waitFor);
ThrowTerminatingError(error);
break;
}
}
}
