public override async Task InitializeAsync() { using var client = new HttpClient(); var script = await client.GetStringAsync("https://chocolatey.org/install.ps1"); var initialSessionState = InitialSessionState.CreateDefault(); initialSessionState.ExecutionPolicy = ExecutionPolicy.Unrestricted; using var powershell = PowerShell.Create(initialSessionState); powershell.AddScript(script); await powershell.InvokeAsync(); if (operatingSystemProvider is WindowsOperatingSystemProvider windowsOperatingSystemProvider) { windowsOperatingSystemProvider.UpdatePathEnvironmentVariable(); } }
internal RestService(string serviceName, List <string> urls, List <RestCommand> commands, IEnumerable <string> modules) : base(serviceName, typeof(DynamicPowershell).Assembly) { // we have to give it at least one assembly, even if there isn't any services in it. // so I'm giving it a really small assembly _serviceName = serviceName; _activeCommands = commands; _listenOnUrls = urls; ReverseLookup.Clear(); var ss = InitialSessionState.CreateDefault(); ss.ImportPSModule(modules.ToArray()); RunspacePool = RunspaceFactory.CreateRunspacePool(ss); RunspacePool.Open(); }
protected virtual Runspace OpenRunspace() { Log.WriteStart("OpenRunspace"); if (session == null) { session = InitialSessionState.CreateDefault(); session.ImportPSModule(new string[] { "FileServerResourceManager" }); } Runspace runSpace = RunspaceFactory.CreateRunspace(session); // runSpace.Open(); // runSpace.SessionStateProxy.SetVariable("ConfirmPreference", "none"); Log.WriteEnd("OpenRunspace"); return(runSpace); }
private Runspace InitializeRunspace(string directory = "ConvertToSARIFModule") { InitialSessionState initialSessionState = InitialSessionState.CreateDefault(); // The command will fail for linux and macOS if (RuntimeInformation.IsOSPlatform(OSPlatform.Windows)) { initialSessionState.ExecutionPolicy = Microsoft.PowerShell.ExecutionPolicy.Unrestricted; } var fullPath = Path.GetFullPath($"{directory}/ConvertToSARIF.dll"); initialSessionState.ImportPSModule(fullPath); Runspace runspace = RunspaceFactory.CreateRunspace(initialSessionState); return(runspace); }
protected override void EndProcessing() { var initialSessionState = InitialSessionState.CreateDefault(); if (Variable != null) { foreach (var variable in Variable) { var value = SessionState.PSVariable.GetValue(variable); initialSessionState.Variables.Add(new SessionStateVariableEntry(variable, value, string.Empty)); } } if (Module != null) { var resolvedModules = new List <string>(); foreach (var module in Module) { if (Path.IsPathRooted(module)) { resolvedModules.Add(module); } else { var resolvedPath = Path.Combine(MyInvocation.PSScriptRoot, module); resolvedModules.Add(resolvedPath); } } initialSessionState.ImportPSModule(resolvedModules.ToArray()); } if (Function != null) { foreach (var function in Function) { var functionInfo = SessionState.InvokeCommand.GetCommand(function, CommandTypes.Function); initialSessionState.Commands.Add(new SessionStateFunctionEntry(function, functionInfo.Definition)); } } WriteObject(initialSessionState); }
private static Tuple <RunspaceDispatcher, NuGetPSHost> CreateRunspace(IConsole console, string hostName) { DTE dte = ServiceLocator.GetInstance <DTE>(); InitialSessionState initialSessionState = InitialSessionState.CreateDefault(); initialSessionState.Variables.Add( new SessionStateVariableEntry( "DTE", (DTE2)dte, "Visual Studio DTE automation object", ScopedItemOptions.AllScope | ScopedItemOptions.Constant) ); // this is used by the functional tests var sourceRepositoryProvider = ServiceLocator.GetInstance <ISourceRepositoryProvider>(); var solutionManager = ServiceLocator.GetInstance <ISolutionManager>(); var settings = ServiceLocator.GetInstance <ISettings>(); var sourceRepoTuple = Tuple.Create <string, object>("SourceRepositoryProvider", sourceRepositoryProvider); var solutionManagerTuple = Tuple.Create <string, object>("VsSolutionManager", solutionManager); Tuple <string, object>[] privateData = new Tuple <string, object>[] { sourceRepoTuple, solutionManagerTuple }; var host = new NuGetPSHost(hostName, privateData) { ActiveConsole = console }; var runspace = RunspaceFactory.CreateRunspace(host, initialSessionState); runspace.ThreadOptions = PSThreadOptions.Default; runspace.Open(); // // Set this runspace as DefaultRunspace so I can script DTE events. // // WARNING: MSDN says this is unsafe. The runspace must not be shared across // threads. I need this to be able to use ScriptBlock for DTE events. The // ScriptBlock event handlers execute on DefaultRunspace. // Runspace.DefaultRunspace = runspace; return(Tuple.Create(new RunspaceDispatcher(runspace), host)); }
private Runspace CreateRunspace() { var assemblyBasePath = Path.GetDirectoryName(this.GetType().GetTypeInfo().Assembly.Location); #if DEBUG var tempPath = Path.Combine(assemblyBasePath, "UniversalDashboard.psd1"); #else var tempPath = Path.Combine(assemblyBasePath, "..\\UniversalDashboard.psd1"); #endif var initialSessionState = InitialSessionState.CreateDefault(); initialSessionState.Variables.Add(new SessionStateVariableEntry("DashboardService", _dashboardService, "DashboardService", ScopedItemOptions.ReadOnly)); var runspace = RunspaceFactory.CreateRunspace(new UDHost(), initialSessionState); runspace.Open(); using (var powerShell = PowerShell.Create()) { powerShell.Runspace = runspace; Log.Debug($"Loading UD module from {tempPath}"); powerShell.AddStatement().AddCommand("Import-Module").AddParameter("Name", tempPath); powerShell.Invoke(); } if (_initializationScript != null) { using (var powerShell = PowerShell.Create()) { powerShell.Runspace = runspace; try { SetVariables(powerShell, _initializationScript.Variables); powerShell.AddStatement().AddScript(_initializationScript.ScriptBlock.ToString()); powerShell.Invoke(); } catch (Exception ex) { Log.Error(ex, "Error running endpoint initialization script."); } } } return(runspace); }
public void Run(string name, Dictionary <string, string> psParams) { // Executionpolicy Bypass - Thanks to @ducke // InitialSessionState initial = InitialSessionState.CreateDefault(); // Replace PSAuthorizationManager with a null manager // which ignores execution policy initial.AuthorizationManager = new AuthorizationManager("Microsoft.PowerShell"); //Create Runspace using (var runspace = RunspaceFactory.CreateRunspace(initial)) { runspace.Open(); //Create Pipeline using (Pipeline pipeline = runspace.CreatePipeline()) { //TODO: Testing - Please REMOVE! var command = new Command(_scriptIO.FileLocation(name)); if (psParams != null) { //TODO: DoEs This Need Item Key or Will Params Run in Order? foreach (var item in psParams) { command.Parameters.Add(null, item.Value); } } pipeline.Commands.Add(command); //Pass in the Scripts text //pipeline.Commands.AddScript(scriptContents); //Previous Way - would allow for script storage in DB pipeline.Commands.Add("Out-String"); //Invoke and Save Results var results = pipeline.Invoke(); SaveResults(name, results); runspace.Close(); } } }
/// <summary> /// Creates a Powershell cmdlet with parameters /// </summary> /// <param name="cmdletName">Name of the cmdlet to invoke</param> /// <param name="cmdletType">Class type of the cmdlet to invoke</param> /// <param name="parameters">Parameters to pass to the cmdlet</param> /// <returns></returns> public PowerShell CreatePowershellcmdlet(string cmdletName, Type cmdletType, List <OctoposhCli.CmdletParameter> parameters) { var initialsessionState = InitialSessionState.CreateDefault(); initialsessionState.Commands.Add( new SessionStateCmdletEntry( cmdletName, cmdletType, null) ); var runspace = RunspaceFactory.CreateRunspace(initialsessionState); runspace.Open(); var powershell = PowerShell.Create(); powershell.Runspace = runspace; var command = new Command(cmdletName); foreach (var parameter in parameters) { if (parameter.MultipleValue != null) { command.Parameters.Add(new CommandParameter(parameter.Name, parameter.MultipleValue)); } else if (parameter.SingleValue != null) { command.Parameters.Add(new CommandParameter(parameter.Name, parameter.SingleValue)); } else if (parameter.Resource != null) { command.Parameters.Add(new CommandParameter(parameter.Name, parameter.Resource)); } else { command.Parameters.Add(new CommandParameter(parameter.Name)); } } powershell.Commands.AddCommand(command); return(powershell); }
public PowershellManager(string workingDirectory, List <ActionLogItem> actionLogs) { this.ActionLogs = actionLogs; InitialSessionState initial = InitialSessionState.CreateDefault(); initial.ImportPSModule(new string[] { "ACMESharp" }); Runspace runspace = RunspaceFactory.CreateRunspace(initial); runspace.Open(); ps = PowerShell.Create(); ps.Runspace = runspace; if (System.IO.Directory.Exists(workingDirectory)) { SetWorkingDirectory(workingDirectory); } }
public async Task <object> CreateRunspacePool(object input) { var inputDict = input as IDictionary <string, object>; if (inputDict == null) { throw new ArgumentException("input"); } var runspaceKey = (string)inputDict["RunspaceKey"]; var startupScript = (string)inputDict["StartupScript"]; if (runspacePools.ContainsKey(runspaceKey)) { throw new InvalidOperationException("Runspace already created with key" + runspaceKey); } if (string.IsNullOrEmpty(startupScript)) { // Assign a dummy script if not provided. startupScript = "Out-Null"; } var initialState = InitialSessionState.CreateDefault(); var promptHandler = (Func <object, Task <object> >)inputDict["PromptHandler"]; PSEdgeRawUI rawUI = new PSEdgeRawUI(); PSEdgeHostUI hostUI = new PSEdgeHostUI(rawUI, promptHandler); PSEdgeHost host = new PSEdgeHost(hostUI); // inject the startup script in the runspace so it is invoked automatically. initialState.Variables.Add( new SessionStateVariableEntry("orbPrivate_RunspaceStartupScript", startupScript, "", ScopedItemOptions.AllScope)); var runspace = RunspaceFactory.CreateRunspacePool(MinRunspacesPerKey, MaxRunspacesPerKey, initialState, host); await Task.Factory.FromAsync(runspace.BeginOpen, runspace.EndOpen, null); runspacePools[runspaceKey] = runspace; return(true); }
public static async Task <string> ExecuteCommandAsync(string command, string host) { var initial = InitialSessionState.CreateDefault(); using var runSpace = RunspaceFactory.CreateRunspace(initial); runSpace.Open(); var scriptBlock = ScriptBlock.Create(command); using var results = await PowerShell.Create(runSpace) .AddCommand("Invoke-Command") .AddParameter("ComputerName", host) .AddParameter("ScriptBlock", scriptBlock) .InvokeAsync(); runSpace.Close(); return(JsonConvert.SerializeObject(results)); }
protected void OpenRunspace() { HostedSolutionLog.LogStart("OpenRunspace"); if (session == null) { session = InitialSessionState.CreateDefault(); session.ImportPSModule(new[] { "virtualmachinemanager" }); } Runspace runSpace = RunspaceFactory.CreateRunspace(session); runSpace.Open(); runSpace.SessionStateProxy.SetVariable("ConfirmPreference", "none"); RunSpace = runSpace; HostedSolutionLog.LogEnd("OpenRunspace"); }
/// <summary> /// This sample uses an initial session state to create a runspace. /// The sample invokes a command from binary module that is loaded by the /// initial session state. /// </summary> /// <param name="args">Parameter not used.</param> /// <remarks> /// This sample assumes that user has the GetProcessSample02.dll that is /// produced by the GetProcessSample02 sample copied to the current directory. /// This sample demonstrates the following: /// 1. Creating a default initial session state. /// 2. Creating a runspace using the initial session state. /// 3. Creating a PowerShell object that uses the runspace. /// 4. Adding the get-proc cmdlet to the PowerShell object from a /// module. /// 5. Using PSObject objects to extract and display properties from /// the objects returned by the cmdlet. /// </remarks> private static void Main(string[] args) { // Create an initial session state. InitialSessionState iss = InitialSessionState.CreateDefault(); iss.ImportPSModule(new string[] { @".\GetProcessSample02.dll" }); // Create a runspace. Notice that no PSHost object is supplied to the // CreateRunspace method so the default host is used. See the Host // samples for more information on creating your own custom host. using (Runspace myRunSpace = RunspaceFactory.CreateRunspace(iss)) { myRunSpace.Open(); // Create a PowerShell object. using (PowerShell powershell = PowerShell.Create()) { // Add the cmdlet and specify the runspace. powershell.AddCommand(@"GetProcessSample02\get-proc"); powershell.Runspace = myRunSpace; Collection <PSObject> results = powershell.Invoke(); Console.WriteLine("Process HandleCount"); Console.WriteLine("--------------------------------"); // Display the results. foreach (PSObject result in results) { Console.WriteLine( "{0,-20} {1}", result.Members["ProcessName"].Value, result.Members["HandleCount"].Value); } } // Close the runspace to release any resources. myRunSpace.Close(); } System.Console.WriteLine("Hit any key to exit..."); System.Console.ReadKey(); }
private Runspace CreateRunspace() { var initial = InitialSessionState.CreateDefault(); initial.ExecutionPolicy = ExecutionPolicy.Unrestricted; if (_runnerConfiguration.IsRemote) { var connectionInfo = new WSManConnectionInfo { ComputerName = _runnerConfiguration.RemoteHostName, AuthenticationMechanism = AuthenticationMechanism.Negotiate }; return(RunspaceFactory.CreateRunspace(connectionInfo)); } return(RunspaceFactory.CreateRunspace(initial)); }
private static Tuple <Runspace, DagentPSHost> CreateRunspace(IConsole console, string hostName) { var initialSessionState = InitialSessionState.CreateDefault(); var privateData = new Tuple <string, object>[] { }; var host = new DagentPSHost(hostName, privateData) { ActiveConsole = console }; var runspace = RunspaceFactory.CreateRunspace(host, initialSessionState); runspace.ThreadOptions = PSThreadOptions.Default; runspace.Open(); // // Set this runspace as DefaultRunspace so I can script DTE events. // WARNING: MSDN says this is unsafe. The runspace must not be shared across threads. I need this to be able to use ScriptBlock for DTE events. The ScriptBlock event handlers execute on DefaultRunspace. // Runspace.DefaultRunspace = runspace; return(Tuple.Create(runspace, host)); }
private static InitialSessionState CreateInitialSessionState() { var state = InitialSessionState.CreateDefault(); if (RuntimeInformation.IsOSPlatform(OSPlatform.Windows)) { state.ExecutionPolicy = ExecutionPolicy.RemoteSigned; } state.Variables.Add(new SessionStateVariableEntry( "ErrorActionPreference", "Stop", description: null )); state.ImportPSModule( Path.Combine(TestPath, "PSql.psd1") ); return(state); }
private string RunScript() { // Create a default initial session state and set the execution policy. InitialSessionState initialSessionState = InitialSessionState.CreateDefault(); initialSessionState.ExecutionPolicy = ExecutionPolicy.Unrestricted; // Create a runspace and open it. This example uses C#8 simplified using statements using Runspace runspace = RunspaceFactory.CreateRunspace(initialSessionState); runspace.Open(); string outputString = ""; using (PowerShell ps = PowerShell.Create()) { ps.Runspace = runspace; string scriptPath = Environment.GetEnvironmentVariable("ScriptPath"); // specify the script code to run. ps.AddScript(scriptPath); // execute the script and await the result. var output = ps.Invoke(); // print the resulting pipeline objects to the console. foreach (var item in output) { Console.WriteLine(item.ToString()); outputString += item.ToString() + "\n"; } } runspace.Close(); string responseMessage = string.IsNullOrEmpty(outputString) ? $"NO OUTPUT in {Environment.GetEnvironmentVariable("ScriptPath")}" : $"Connect to {Environment.GetEnvironmentVariable("ScriptPath")} with OUTPUT: \n\n{outputString}"; return(responseMessage); }
public static async Task <ConsoleOutput> ConvertToGif(this GifOptions model) { try { InitialSessionState iss = InitialSessionState.CreateDefault(); // iss.ExecutionPolicy = Microsoft.PowerShell.ExecutionPolicy.Unrestricted; using (Runspace rs = RunspaceFactory.CreateRunspace(iss)) { rs.Open(); var script = await(".Scripts.Create-Gif.ps1").GetTextFromEmbeddedResource(); Command createGif = new Command(script, true); createGif.Parameters.Add("exec", model.exec); createGif.Parameters.Add("origin", model.origin); createGif.Parameters.Add("destination", model.destination); createGif.Parameters.Add("fps", model.fps); createGif.Parameters.Add("scale", model.scale); createGif.Parameters.Add("flags", model.flags); createGif.Parameters.Add("log", model.log); using (PowerShell ps = PowerShell.Create()) { ps.Runspace = rs; ps.Commands.AddCommand(createGif); ps.Invoke(); var output = await ps.GetPowershellOutput(); if (!output.hasError) { output.result = $"{model.destination} successfully created"; } return(output); } } } catch (Exception ex) { throw new Exception(ex.GetExceptionMessageChain()); } }
public bool CreatePsPipeline() { _startTime = DateTime.MinValue; _endTime = DateTime.MinValue; _taskCompleted = false; _taskStatus = Status.NOTSTARTED; _resultDataTable = null; _resultStringBuilder = new StringBuilder(); try { InitialSessionState iss = InitialSessionState.CreateDefault(); foreach (var v in _variables) { SessionStateVariableEntry variable = new SessionStateVariableEntry(v.Key, v.Value, null); iss.Variables.Add(variable); } _runspace = RunspaceFactory.CreateRunspace(initialSessionState: iss); } catch { _taskCompleted = true; _taskStatus = Status.FAILED; throw; } try { _runspace.Open(); _pipeline = _runspace.CreatePipeline(); foreach (var scriptFile in _scriptFiles) { string scriptContent = System.IO.File.ReadAllText(scriptFile); _pipeline.Commands.AddScript(scriptContent); } _pipeline.Commands.AddScript(_scriptText); } catch { _taskStatus = Status.FAILED; throw; } return(true); }
private static string ExecutePowershell(string args) { InitialSessionState iss = InitialSessionState.CreateDefault(); Runspace rs = RunspaceFactory.CreateRunspace(iss); rs.Open(); PowerShell ps = PowerShell.Create(rs); ps.AddCommand("Get-Command"); Collection <PSObject> results = ps.Invoke(); StringBuilder stringBuilder = new StringBuilder(); foreach (PSObject pSObject in results) { stringBuilder.AppendLine(pSObject.ToString()); } return(stringBuilder.ToString()); }
public void RegisterMetrics(ICollectorRegistry registry) { _registry = registry; var iss = InitialSessionState.CreateDefault(); iss.ImportPSModule(new[] { _metricsPowerShellModulePath }); iss.Types.Add(new SessionStateTypeEntry(new TypeData(typeof(Metric)), false)); _rs = RunspaceFactory.CreateRunspace(iss); // NB if this errors out with something alike: // runspace cannot be loaded because running scripts is disabled on this system. For more information, see about_Execution_Policies // you need to change the PowerShell (64-bit and 32-bit) execution policies with: // PowerShell.exe -Command Set-ExecutionPolicy Unrestricted // c:\windows\syswow64\WindowsPowerShell\v1.0\PowerShell.exe -Command Set-ExecutionPolicy Unrestricted _rs.Open(); Log.Information("PowerShell v{PowerShellVersion}", _rs.Version); }
public Invoke_XdtTransformSteps() { var state = InitialSessionState.CreateDefault(); state.Commands.Add( new SessionStateCmdletEntry( "Invoke-XdtTransform", typeof(InvokeXdtTransformCommand), null)); this._Runspace = RunspaceFactory.CreateRunspace(); this._Runspace.Open(); this._Shell = PowerShell.Create(state); this._Shell.Runspace = this._Runspace; this._Command = new Command("Invoke-XdtTransform"); this._Shell.Commands.AddCommand(this._Command); }
public PowerShellKernel() { //Sets the distribution channel to "PSES" so starts can be distinguished in PS7+ telemetry Environment.SetEnvironmentVariable("POWERSHELL_DISTRIBUTION_CHANNEL", "dotnet-interactive-powershell"); var runspace = RunspaceFactory.CreateRunspace(InitialSessionState.CreateDefault()); runspace.Open(); _pwsh = PowerShell.Create(runspace); _cancellationSource = new CancellationTokenSource(); Name = DefaultKernelName; // Add Modules directory that contains the helper modules string psModulePath = Environment.GetEnvironmentVariable("PSModulePath"); Environment.SetEnvironmentVariable("PSModulePath", psModulePath + Path.PathSeparator + Path.Join( Path.GetDirectoryName(typeof(PowerShellKernel).Assembly.Location), "Modules")); }
public PowershellEnvironment(params PowershellModule[] modules) { if (modules == null) { runspace = RunspaceFactory.CreateRunspace(); } else { initialSessionState = InitialSessionState.CreateDefault(); string[] moduleFullPath = new string[modules.Length]; for (int i = 0; i < modules.Length; i++) { moduleFullPath[i] = modules[i].FullPath; initialSessionState.Assemblies.Add(new SessionStateAssemblyEntry(modules[i].FullPath)); } initialSessionState.ImportPSModule(moduleFullPath); runspace = RunspaceFactory.CreateRunspace(initialSessionState); } }
public void TestInit() { testFiles = new List <String>(); var initState = InitialSessionState.CreateDefault(); initState.LanguageMode = PSLanguageMode.FullLanguage; initState.ThrowOnRunspaceOpenError = true; initState.ThreadOptions = PSThreadOptions.UseCurrentThread; var folder = System.IO.Path.GetDirectoryName(Assembly.GetExecutingAssembly().Location); initState.ImportPSModule(new string[] { System.IO.Path.Combine(folder, "RoboDave.dll") }); runspace = RunspaceFactory.CreateRunspace(initState); runspace.Open(); ps = PowerShell.Create(); ps.Runspace = runspace; }
public async override Task InstallPackageAsync(SoftwarePackage package) { var fileinfo = await GetPackageFileAsync(package, ".appx"); var sessionState = InitialSessionState.CreateDefault(); sessionState.ExecutionPolicy = ExecutionPolicy.Unrestricted; using var ps = PowerShell.Create(sessionState); ps.AddScript($"cd \"{fileinfo.DirectoryName}\""); ps.AddScript("Import-Module Appx -UseWindowsPowerShell"); ps.AddScript($"Add-AppxPackage '{package.PackageName}'"); await ps.InvokeAsync(); if (ps.HadErrors) { throw new InstallFailedException(); } }
/// <summary> /// This sample uses an InitialSessionState to create Runspace. It invokes /// a command from PowerShell snap-in present in the console file. /// </summary> /// <param name="args">Unused</param> /// <remarks> /// This sample assumes that user has the PowerShell binary module "GetProcessSample01.dll" /// produced in sample GetProcessSample01 copied to the current directory. /// /// This sample demonstrates the following: /// 1. Creating a default instance of InitialSessionState /// 2. Using the InitialSessionState to create a runspace /// 3. Create a pipeline with the get-proc cmdlet available in the PowerShell binary module /// 4. Using PSObject to extract and display properties from the objects /// returned by this command /// </remarks> static void Main(string[] args) { InitialSessionState iss = InitialSessionState.CreateDefault(); PSSnapInException warning; iss.ImportPSSnapIn("GetProcPSSnapIn01", out warning); // Create a runspace. // (Note that no PSHost instance is supplied to the CreateRunspace // function so the default PSHost implementation is used. See the // Hosting topics for more information on creating your own PSHost class.) Runspace myRunSpace = RunspaceFactory.CreateRunspace(iss); myRunSpace.Open(); // Create a PowerShell with get-proc command. PowerShell powershell = PowerShell.Create().AddCommand("GetProcPSSnapIn01\\get-proc"); powershell.Runspace = myRunSpace; Collection <PSObject> results = powershell.Invoke(); Console.WriteLine("Process HandleCount"); Console.WriteLine("--------------------------------"); // Print out each result object... foreach (PSObject result in results) { Console.WriteLine("{0,-20} {1}", result.Members["ProcessName"].Value, result.Members["HandleCount"].Value); } // Finally close the runspace // up any resources. myRunSpace.Close(); System.Console.WriteLine("Hit any key to exit..."); System.Console.ReadKey(); }
/// <summary> /// Executes the specified PowerShell script. /// </summary> /// <param name="scriptText"></param> /// <returns></returns> public static Collection <PSObject> ExecutePowerShellScript(string scriptText) { InitialSessionState iss = InitialSessionState.CreateDefault(); PSSnapInException warning; iss.ImportPSSnapIn("Microsoft.SharePoint.PowerShell", out warning); Collection <PSObject> results; // create Powershell runspace using (var runspace = RunspaceFactory.CreateRunspace(iss)) { // open it runspace.Open(); try { // create a pipeline and feed it the script text var pipeline = runspace.CreatePipeline(); pipeline.Commands.AddScript(scriptText); pipeline.Commands[0].MergeMyResults(PipelineResultTypes.Error, PipelineResultTypes.Output); try { // execute the script results = pipeline.Invoke(); } catch (Exception ex) { BaristaDiagnosticsService.Local.LogException(ex, BaristaDiagnosticCategory.PowerShell, "Unexpected Error while executing PowerShell Script:"); throw; } } finally { runspace.Close(); } } //Return the results. return(results); }
public string Run2(string script, IDictionary <string, object> parameters = null) { var outputStr = new StringBuilder(); var initialSessionState = InitialSessionState.CreateDefault(); initialSessionState.Variables.Add(new SessionStateVariableEntry("context", parameters, "")); using (Runspace runspace = RunspaceFactory.CreateRunspace(initialSessionState)) { using (PowerShell powerShell = PowerShell.Create()) { // execute runspace.Open(); powerShell.Runspace = runspace; powerShell.AddScript(script); var results = powerShell.Invoke <string>(); // output foreach (var outputItem in results) { if (outputItem != null) { outputStr.AppendLine(outputItem.ToString()); } } // errors foreach (ErrorRecord error in powerShell.Streams.Error.ReadAll()) { outputStr.AppendLine(string.Format("{0} in line {1}, column {2}", error, error.InvocationInfo.ScriptLineNumber, error.InvocationInfo.OffsetInLine)); } runspace.Close(); } } return(outputStr.ToString()); }