public PSTestScope(bool connect = true)
{
SiteUrl = ConfigurationManager.AppSettings["SPODevSiteUrl"];
CredentialManagerEntry = ConfigurationManager.AppSettings["SPOCredentialManagerLabel"];
var iss = InitialSessionState.CreateDefault();
if (connect)
{
SessionStateCmdletEntry ssce = new SessionStateCmdletEntry("Connect-SPOnline", typeof(ConnectSPOnline), null);
iss.Commands.Add(ssce);
}
_runSpace = RunspaceFactory.CreateRunspace(iss);
_runSpace.Open();
if (connect)
{
var pipeLine = _runSpace.CreatePipeline();
Command cmd = new Command("connect-sponline");
cmd.Parameters.Add("Url", SiteUrl);
if (!string.IsNullOrEmpty(CredentialManagerEntry))
{
cmd.Parameters.Add("Credentials", CredentialManagerEntry);
}
pipeLine.Commands.Add(cmd);
pipeLine.Invoke();
}
}
public PSTestScope(bool connect = true)
{
SiteUrl = ConfigurationManager.AppSettings["SPODevSiteUrl"];
CredentialManagerEntry = ConfigurationManager.AppSettings["SPOCredentialManagerLabel"];
Realm = ConfigurationManager.AppSettings["Realm"];
AppId = ConfigurationManager.AppSettings["AppId"];
AppSecret = ConfigurationManager.AppSettings["AppSecret"];
var iss = InitialSessionState.CreateDefault();
if (connect)
{
SessionStateCmdletEntry ssce = new SessionStateCmdletEntry("Connect-PnPOnline", typeof(ConnectOnline), null);
iss.Commands.Add(ssce);
}
_runSpace = RunspaceFactory.CreateRunspace(iss);
_runSpace.Open();
// Sets the execution policy to unrestricted. Requires Visual Studio to run in elevated mode.
var pipeLine = _runSpace.CreatePipeline();
Command cmd = new Command("Set-ExecutionPolicy");
cmd.Parameters.Add("ExecutionPolicy", "Unrestricted");
cmd.Parameters.Add("Scope", "Process");
pipeLine.Commands.Add(cmd);
pipeLine.Invoke();
if (connect)
{
pipeLine = _runSpace.CreatePipeline();
cmd = new Command("connect-pnponline");
cmd.Parameters.Add("Url", SiteUrl);
if (!string.IsNullOrEmpty(CredentialManagerEntry))
{
// Use Windows Credential Manager to authenticate
cmd.Parameters.Add("Credentials", CredentialManagerEntry);
}
else
{
if (!string.IsNullOrEmpty("AppId") && !string.IsNullOrEmpty("AppSecret"))
{
// Use oAuth Token to authenticate
if (!string.IsNullOrEmpty(Realm))
{
cmd.Parameters.Add("Realm", Realm);
}
cmd.Parameters.Add("AppId", AppId);
cmd.Parameters.Add("AppSecret", AppSecret);
}
}
pipeLine.Commands.Add(cmd);
pipeLine.Invoke();
}
}
public void InitializeTests()
{
RunspaceConfiguration config = RunspaceConfiguration.Create();
PSSnapInException warning;
config.AddPSSnapIn("ShareFile", out warning);
runspace = RunspaceFactory.CreateRunspace(config);
runspace.Open();
// do login first to start tests
using (Pipeline pipeline = runspace.CreatePipeline())
{
Command command = new Command("Get-SfClient");
command.Parameters.Add(new CommandParameter("Name", Utils.LoginFilePath));
pipeline.Commands.Add(command);
Collection<PSObject> objs = pipeline.Invoke();
Assert.AreEqual<int>(1, objs.Count);
sfLogin = objs[0];
}
}
private bool createRunspace(string command)
{
bool result = false;
// 20131210
// UIAutomation.Preferences.FromCache = false;
try {
testRunSpace = null;
testRunSpace = RunspaceFactory.CreateRunspace();
testRunSpace.Open();
Pipeline cmd =
testRunSpace.CreatePipeline(command);
cmd.Invoke();
result = true;
}
catch (Exception eInitRunspace) {
richResults.Text += eInitRunspace.Message;
richResults.Text += "\r\n";
result = false;
}
return result;
//Screen.PrimaryScreen.Bounds.Width
}
public PipelineExecutor(Runspace runSpace, string command)
{
this.pipeline = runSpace.CreatePipeline(command);
this.pipeline.Commands[0].MergeMyResults(PipelineResultTypes.Error, PipelineResultTypes.Output);
this.pipeline.Output.DataReady += this.OutputDataReady;
this.pipeline.Error.DataReady += this.ErrorDataReady;
}
void run_set_host_command(Runspace configuredRunspace, string hostName, string address, string hostsFile)
{
using (var command = configuredRunspace.CreatePipeline(
string.Format("set-HostsFileEntry {0} {1} -f \"{2}\"", hostName, address, hostsFile)))
{
var results = command.Invoke();
expect(() => results.Count() == 0);
}
}
public static ExternalScriptInfo MakeExternalScriptInfo(Runspace powershellRunspace, string exampleScriptName)
{
var outputDirectory = new Uri(Path.GetDirectoryName(Assembly.GetExecutingAssembly().CodeBase)).LocalPath;
var exampleScriptPath = Path.Combine(outputDirectory, "ExampleScripts\\" + exampleScriptName + ".ps1");
var cmd = string.Format("Set-ExecutionPolicy -Scope Process -ExecutionPolicy RemoteSigned; Get-Command \"{0}\"", exampleScriptPath);
using (Pipeline pipeline = powershellRunspace.CreatePipeline(cmd))
{
var results = pipeline.Invoke();
return results.First().BaseObject as ExternalScriptInfo;
}
}
public void InitializeTests()
{
RunspaceConfiguration config = RunspaceConfiguration.Create();
PSSnapInException warning;
config.AddPSSnapIn("ShareFile", out warning);
runspace = RunspaceFactory.CreateRunspace(config);
runspace.Open();
// do login first to start tests
using (Pipeline pipeline = runspace.CreatePipeline())
{
Command command = new Command("Get-SfClient");
command.Parameters.Add(new CommandParameter("Name", Utils.LoginFilePath));
pipeline.Commands.Add(command);
Collection<PSObject> psObjects = pipeline.Invoke();
Assert.AreEqual<int>(1, psObjects.Count);
sfLogin = psObjects[0];
}
using (Pipeline pipeline = runspace.CreatePipeline())
{
Command command = new Command("New-PSDrive");
command.Parameters.Add("Name", Utils.ShareFileDriveLetter);
command.Parameters.Add("PSProvider", "ShareFile");
command.Parameters.Add("Root", "/");
command.Parameters.Add("Client", sfLogin);
pipeline.Commands.Add(command);
Collection<PSObject> psObjects = pipeline.Invoke();
// Drive is successfully mapped to root folder
Assert.AreEqual<int>(1, psObjects.Count);
}
}
public PowerShellRunner()
{
var psHost = new PSHost(new PSHostUserInterface(this));
runSpace = RunspaceFactory.CreateRunspace(psHost);
runSpace.Open();
// Allows scripts to be run for this process
using (var pipeline = runSpace.CreatePipeline())
{
pipeline.Commands.AddScript("Set-ExecutionPolicy -ExecutionPolicy unrestricted -Scope Process -Force");
pipeline.Invoke();
}
}
public static string Execute(bool logErrors, Action<string> onErrorHandler, TestHostUserInterface ui,
params string[] statements)
{
if (logErrors)
{
ui.OnWriteErrorLineString = onErrorHandler ?? (s => ui.Log.Append(s));
}
TestHost host = new TestHost(ui);
// use public static property, so we can access e.g. the ExecutionContext after execution
LastUsedRunspace = CreateRunspace(host);
LastUsedRunspace.Open();
_doExit = false;
LastExitCode = null;
foreach (var statement in statements)
{
if (_doExit)
{
break;
}
using (var currentPipeline = LastUsedRunspace.CreatePipeline())
{
currentPipeline.Commands.AddScript(statement, false);
currentPipeline.Commands.Add("Out-Default");
try
{
currentPipeline.Invoke();
}
catch (Exception e)
{
ui.WriteErrorLine(e.ToString());
}
// pipeline might failed, write errors to ui
if (currentPipeline.PipelineStateInfo.State.Equals(PipelineState.Failed))
{
foreach (var error in currentPipeline.Error.ReadToEnd())
{
ui.WriteErrorLine(error.ToString());
}
}
}
}
return ui.Log.ToString();
}
private static string RunScript(Runspace runspace)
{
runspace.Open();
var pipeline = runspace.CreatePipeline();
var runspaceInvoke = new RunspaceInvoke(runspace);
runspaceInvoke.Invoke("Set-ExecutionPolicy -ExecutionPolicy Unrestricted -Scope Process -Force");
pipeline.Commands.AddScript(@"D:\Projekt\EPiServer\SampleCode\CodeSample\ScheduledJobs\SampleScript.ps1");
pipeline.Commands.Add("Out-String");
var stringBuilder = new StringBuilder();
foreach (var psObject in pipeline.Invoke())
{
stringBuilder.AppendLine(psObject.ToString());
}
return stringBuilder.ToString();
}
public PSTestScope(bool connect = true)
{
SiteUrl = ConfigurationManager.AppSettings["SPODevSiteUrl"];
CredentialManagerEntry = ConfigurationManager.AppSettings["SPOCredentialManagerLabel"];
Realm = ConfigurationManager.AppSettings["Realm"];
AppId = ConfigurationManager.AppSettings["AppId"];
AppSecret = ConfigurationManager.AppSettings["AppSecret"];
var iss = InitialSessionState.CreateDefault();
if (connect)
{
SessionStateCmdletEntry ssce = new SessionStateCmdletEntry("Connect-SPOnline", typeof(ConnectSPOnline), null);
iss.Commands.Add(ssce);
}
_runSpace = RunspaceFactory.CreateRunspace(iss);
_runSpace.Open();
if (connect)
{
var pipeLine = _runSpace.CreatePipeline();
Command cmd = new Command("connect-sponline");
cmd.Parameters.Add("Url", SiteUrl);
if (!string.IsNullOrEmpty(CredentialManagerEntry))
{
// Use Windows Credential Manager to authenticate
cmd.Parameters.Add("Credentials", CredentialManagerEntry);
}
else
{
if (!string.IsNullOrEmpty(Realm) && !string.IsNullOrEmpty("AppId") && !string.IsNullOrEmpty("AppSecret"))
{
// Use oAuth Token to authenticate
cmd.Parameters.Add("Realm", Realm);
cmd.Parameters.Add("AppId", AppId);
cmd.Parameters.Add("AppSecret", AppSecret);
}
}
pipeLine.Commands.Add(cmd);
pipeLine.Invoke();
}
}
public PipelineExecutor(Runspace runSpace,ISynchronizeInvoke invoker,string command)
{
this.invoker = invoker;
// initialize delegates
synchDataReady = new DataReadyDelegate(SynchDataReady);
synchDataEnd = new DataEndDelegate(SynchDataEnd);
synchErrorReady = new ErrorReadyDelegate(SynchErrorReady);
// initialize event members
stopEvent = new ManualResetEvent(false);
waitHandles = new WaitHandle[] { null, stopEvent };
// create a pipeline and feed it the script text
pipeline = runSpace.CreatePipeline(command);
// we'll listen for script output data by way of the DataReady event
pipeline.Output.DataReady += new EventHandler(Output_DataReady);
pipeline.Error.DataReady += new EventHandler(Error_DataReady);
}
public static void Main()
{
const int SW_HIDE = 0;
const int SW_SHOW = 5;
var handle = Win32.GetConsoleWindow();
// Show Window
Win32.ShowWindow(handle, SW_SHOW);
var amsi = new Amsi();
amsi.Bypass();
string commandArrayString = "FIXME_FUNCTIONS";
List <string> commandArray = new List <string>(commandArrayString.Split(','));
System.Management.Automation.Runspaces.Runspace runspace = System.Management.Automation.Runspaces.RunspaceFactory.CreateRunspace();
runspace.Open();
System.Management.Automation.Runspaces.Pipeline pipeline = runspace.CreatePipeline();
pipeline.Commands.AddScript(ApplicationData.runApp());
foreach (var command in commandArray)
{
pipeline.Commands.AddScript(command);
}
runspace.SessionStateProxy.SetVariable("FormatEnumerationLimit", -1);
pipeline.Commands.Add("Out-String");
System.Collections.ObjectModel.Collection <System.Management.Automation.PSObject> results = pipeline.Invoke();
runspace.Close();
System.Text.StringBuilder stringBuilder = new System.Text.StringBuilder();
foreach (System.Management.Automation.PSObject obj in results)
{
stringBuilder.AppendLine(obj.ToString());
}
System.Console.WriteLine(stringBuilder.ToString());
}
public virtual IPipeline CreatePipeline()
{
return(new Pipeline(runspace.CreatePipeline()));
}
// ------------------ Methods ----------------------------
public static bool InitializeRunspace(string command)
{
bool result = false;
try {
testRunSpace = null;
testRunSpace = RunspaceFactory.CreateRunspace();
// testRunSpace.AvailabilityChanged += new EventHandler<RunspaceAvailabilityEventArgs>(runspace_AvailabilityChanged);
testRunSpace.AvailabilityChanged += runspace_AvailabilityChanged;
// testRunSpace.StateChanged += new EventHandler<RunspaceStateEventArgs>(runspace_StateChanged);
testRunSpace.StateChanged += runspace_StateChanged;
testRunSpace.Open();
// 20140722
// pipeline = null;
pipeline = testRunSpace.CreatePipeline(command);
// pipeline.StateChanged += new EventHandler<PipelineStateEventArgs>(pipeline_StateChanged);
pipeline.StateChanged += pipeline_StateChanged;
//if (PipelineState.Running == pipeline.PipelineStateInfo.State) {
// pipeline.Stop();
//}
pipeline.Invoke();
result = true;
}
catch (Exception eInitRunspace) {
// Console.WriteLine(eInitRunspace.Message);
//result = false;
throw (eInitRunspace);
}
return result;
}
/// <summary>
/// Runs a PowerShell script under a given <see cref="Runspace"/>.
/// </summary>
/// <param name="runspace">The Runspace to run the script under.</param>
/// <param name="scriptText">The name of the text file to run as a powershell script.</param>
/// <param name="outString">Set to true to add an Out-String to the end of the pipeline.</param>
/// <returns></returns>
private static Collection<PSObject> RunScript(Runspace runspace, string scriptText, bool outString = false)
{
Collection<PSObject> results;
using (var pipeline = runspace.CreatePipeline())
{
pipeline.Commands.AddScript(scriptText);
if (outString)
{
pipeline.Commands[0].MergeMyResults(PipelineResultTypes.Error, PipelineResultTypes.Output);;
//pipeline.Commands.Add("Out-String");
pipeline.Commands.Add("Out-Default");
}
results = pipeline.Invoke();
}
return results;
}
public static Collection<PSObject> RawExecute(string[] commands)
{
LastRawResults = null;
LastUsedRunspace = InitialSessionState == null ?
RunspaceFactory.CreateRunspace() : RunspaceFactory.CreateRunspace(InitialSessionState);
LastUsedRunspace.Open();
foreach (var command in commands)
{
using (var pipeline = LastUsedRunspace.CreatePipeline())
{
pipeline.Commands.AddScript(command, true);
try
{
LastRawResults = pipeline.Invoke();
}
catch (Exception)
{
LastRawResults = pipeline.Output.ReadToEnd();
throw;
}
if (pipeline.Error.Count > 0)
{
throw new MethodInvocationException(String.Join(Environment.NewLine, pipeline.Error.ReadToEnd()));
}
}
}
return LastRawResults;
}
internal Collection<PSObject> ExecuteShellCommand(Runspace runSpace, Command cmd, out object[] errors)
{
ExchangeLog.LogStart("ExecuteShellCommand");
List<object> errorList = new List<object>();
ExchangeLog.DebugCommand(cmd);
Collection<PSObject> results = null;
// Create a pipeline
Pipeline pipeLine = runSpace.CreatePipeline();
using (pipeLine)
{
// Add the command
pipeLine.Commands.Add(cmd);
// Execute the pipeline and save the objects returned.
results = pipeLine.Invoke();
// Log out any errors in the pipeline execution
// NOTE: These errors are NOT thrown as exceptions!
// Be sure to check this to ensure that no errors
// happened while executing the command.
if (pipeLine.Error != null && pipeLine.Error.Count > 0)
{
foreach (object item in pipeLine.Error.ReadToEnd())
{
errorList.Add(item);
string errorMessage = string.Format("Invoke error: {0}", item.ToString());
ExchangeLog.LogWarning(errorMessage);
}
throw new Exception(errorList[0].ToString());
}
}
pipeLine = null;
errors = errorList.ToArray();
ExchangeLog.LogEnd("ExecuteShellCommand");
return results;
}
private static Pipeline CreatePipeline(Runspace runspace, string command, bool outputResults)
{
Pipeline pipeline = runspace.CreatePipeline(command, addToHistory: true);
if (outputResults) {
pipeline.Commands.Add("out-default");
pipeline.Commands[0].MergeMyResults(PipelineResultTypes.Error, PipelineResultTypes.Output);
}
return pipeline;
}
private void EnsureExecutionPolicy(Runspace space)
{
Pipeline executionPolicyPipeline = space.CreatePipeline("Set-ExecutionPolicy Unrestricted");
executionPolicyPipeline.Invoke();
}
/// <summary> Executes shell command.</summary>
/// <param name="runspace"> The runspace.</param>
/// <param name="command"> The command.</param>
/// <param name="useDomainController"> True - if domain controller should be used.</param>
/// <param name="errors"> Errors list.</param>
/// <returns> The result.</returns>
internal Collection<PSObject> ExecuteShellCommand(Runspace runspace, Command command, bool useDomainController, out object[] errors)
{
HostedSolutionLog.LogStart("ExecuteShellCommand");
var errorList = new List<object>();
if (useDomainController)
{
var dc = new CommandParameter("DomainController", PrimaryDomainController);
if (!command.Parameters.Contains(dc))
{
command.Parameters.Add(dc);
}
}
HostedSolutionLog.DebugCommand(command);
Collection<PSObject> results;
Pipeline pipeLine = runspace.CreatePipeline();
using (pipeLine)
{
pipeLine.Commands.Add(command);
results = pipeLine.Invoke();
if (pipeLine.Error != null && pipeLine.Error.Count > 0)
{
foreach (object item in pipeLine.Error.ReadToEnd())
{
errorList.Add(item);
string errorMessage = string.Format("Invoke error: {0}", item);
HostedSolutionLog.LogWarning(errorMessage);
}
}
}
errors = errorList.ToArray();
HostedSolutionLog.LogEnd("ExecuteShellCommand");
return results;
}
/// <summary>
/// Constructor, creates a new AsyncPipelineExecutor for the given powershell script.
/// </summary>
/// <param name="runSpace">Powershell runspace to use for creating and executing the script.</param>
/// <param name="invoker">The object to synchronize the DataReady and DataEnd events with.
/// Normally you'd pass the form or component here.</param>
/// <param name="command">The script to run</param>
public AsyncPipelineExecutor(Runspace runSpace, ISynchronizeInvoke invoker, string command)
{
this.invoker = invoker; synchDataReady = new DataReadyDelegate(SynchDataReady); synchDataEnd = new DataEndDelegate(SynchDataEnd); synchErrorReady = new ErrorReadyDelegate(SynchErrorReady); stopEvent = new ManualResetEvent(false); waitHandles = new WaitHandle[] { null, stopEvent }; pipeline = runSpace.CreatePipeline(command); pipeline.Output.DataReady += new EventHandler(Output_DataReady); pipeline.Error.DataReady += new EventHandler(Error_DataReady);
}
private List<psparameter>CheckForParams(Runspace rspace, String scriptcommand)
{
cancel = false;
List<psparameter> parms = null;
psparamtype parm = new psparamtype();
Pipeline pline = rspace.CreatePipeline();
String scrpt = "Get-Help ";
if (iscommand)
{
scrpt = "Import-Module \"$PSFramework\"" + Environment.NewLine + scrpt + scriptcommand + " -full";
}
else
{
scrpt += "\"" + scriptcommand + "\" -full";
}
pline.Commands.AddScript(scrpt);
pline.Commands.Add("Out-String");
Collection<PSObject> rslt = pline.Invoke();
if (rslt != null)
{
if (rslt[0].ToString().Contains("PARAMETERS"))
{
String[] lines = rslt[0].ToString().Split(new string[] { Environment.NewLine }, StringSplitOptions.None);
if (lines != null)
{
int idx = 0;
bool found = false;
do
{
String line = lines[idx];
if(line == "PARAMETERS")
{
found = true;
}
idx++;
}while( found == false && idx < lines.Length);
if (found)
{
String line = "";
do
{
line = lines[idx];
if (line.Trim() != "" && line.Trim().Substring(0, 1) == "-")
{
psparameter prm = new psparameter();
String param = line.Trim().Substring(1, line.Trim().Length - 1);
String[] paramparts = param.Split(' ');
prm.Name = paramparts[0].Trim();
if (paramparts.Length == 2)
{
prm.Type = GetTypeFromString(paramparts[1]);
}
else
{
prm.Type = typeof(int);
}
idx++;
line = lines[idx];
prm.Description = line.Trim();
idx += 2;
line = lines[idx];
if (line.Contains("true"))
{
prm.Category = "Required";
}
else
{
prm.Category = "Optional";
}
idx += 2;
line = lines[idx];
if (line.Contains("Default value"))
{
String defval = line.Replace("Default value", "").Trim();
if (defval != "")
{
if (defval.ToLower() == "true" || defval.ToLower() == "false")
{
prm.DefaultValue = bool.Parse(defval);
}
else
{
prm.DefaultValue = defval;
}
}
}
parm.Properties.Add(prm);
}
idx++;
}while(line.Substring(0,1) == " " && idx < lines.Length);
}
}
}
}
pline.Stop();
pline.Dispose();
pline = null;
GC.Collect();
if (parm.Properties.Count > 0)
{
Interface.frmParams frm = new Interface.frmParams();
frm.SetParameters(parm);
if (frm.ShowDialog() == System.Windows.Forms.DialogResult.OK)
{
parms = parm.Properties;
}
else
{
cancel = true;
}
}
return parms;
}
/// <summary>Executes shell command.</summary>
/// <param name="runspace">The runspace.</param>
/// <param name="scripts">The scripts to be executed.</param>
/// <param name="errors">The errors.</param>
/// <returns>PSobjecs collection.</returns>
private Collection<PSObject> ExecuteShellCommand(Runspace runspace, List<string> scripts, out object[] errors)
{
HostedSolutionLog.LogStart("ExecuteShellCommand");
var errorList = new List<object>();
Collection<PSObject> results;
using (Pipeline pipeLine = runspace.CreatePipeline())
{
foreach (string script in scripts)
{
pipeLine.Commands.AddScript(script);
}
results = pipeLine.Invoke();
if (pipeLine.Error != null && pipeLine.Error.Count > 0)
{
foreach (object item in pipeLine.Error.ReadToEnd())
{
errorList.Add(item);
string errorMessage = string.Format("Invoke error: {0}", item);
HostedSolutionLog.LogWarning(errorMessage);
throw new ArgumentException(scripts.First());
}
}
}
errors = errorList.ToArray();
HostedSolutionLog.LogEnd("ExecuteShellCommand");
return results;
}
private ICollection<PSObject> InvokePipelineInternal(Runspace runspace, Collection<Command> commands)
{
const string MethodName = "InvokePipelineInternal";
Debug.WriteLine(MethodName + ":entry", ClassName);
Stopwatch watch = new Stopwatch();
watch.Start();
if (commands == null || commands.Count == 0) {
throw new ArgumentException("Commands argument is null or empty");
}
// make sure the output is set
Collection<PSObject> results;
// create the pipeline
Pipeline pipe = runspace.CreatePipeline();
LOGGER_PERFORMANCE.TraceEvent(TraceEventType.Verbose, CAT_DEFAULT,
"InvokePipelineInternal: Pipeline created: {0} ms from start of this method", watch.ElapsedMilliseconds);
// add the commands to the pipeline
foreach (Command item in commands) {
LOGGER_COMMANDS.TraceEvent(TraceEventType.Verbose, CAT_DEFAULT, "Item = {0}", item);
foreach (CommandParameter cp in item.Parameters) {
LOGGER_COMMANDS.TraceEvent(TraceEventType.Verbose, CAT_DEFAULT, " - parameter {0} = {1}", cp.Name, cp.Value);
}
pipe.Commands.Add(item);
}
LOGGER_COMMANDS.TraceEvent(TraceEventType.Verbose, CAT_DEFAULT, "Executing pipe: {0}", pipe);
// run the pipeline if we have something to execute
results = pipe.Invoke();
LOGGER_PERFORMANCE.TraceEvent(TraceEventType.Verbose, CAT_DEFAULT, "InvokePipelineInternal: Pipeline.Invoke returned: {0} ms from start of this method", watch.ElapsedMilliseconds);
PipelineReader<object> reader = pipe.Error;
// check for errors
CheckErrorsFromReader(reader);
// an empty collection instead of null when we have executed
if (results == null) {
Debug.WriteLine("NO result returned");
results = new Collection<PSObject>();
}
LOGGER_PERFORMANCE.TraceEvent(TraceEventType.Verbose, CAT_DEFAULT, "InvokePipelineInternal: Method finishing: {0} ms from start of this method", watch.ElapsedMilliseconds);
Debug.WriteLine(MethodName + ":exit", ClassName);
return results;
}
internal Collection<PSObject> ExecuteShellCommand(Runspace runSpace, Command cmd, bool useDomainController, out object[] errors)
{
HostedSolutionLog.LogStart("ExecuteShellCommand");
List<object> errorList = new List<object>();
if (useDomainController)
{
CommandParameter dc = new CommandParameter("DomainController", PrimaryDomainController);
if (!cmd.Parameters.Contains(dc))
{
cmd.Parameters.Add(dc);
}
}
HostedSolutionLog.DebugCommand(cmd);
Collection<PSObject> results = null;
// Create a pipeline
Pipeline pipeLine = runSpace.CreatePipeline();
using (pipeLine)
{
// Add the command
pipeLine.Commands.Add(cmd);
// Execute the pipeline and save the objects returned.
results = pipeLine.Invoke();
// Log out any errors in the pipeline execution
// NOTE: These errors are NOT thrown as exceptions!
// Be sure to check this to ensure that no errors
// happened while executing the command.
if (pipeLine.Error != null && pipeLine.Error.Count > 0)
{
foreach (object item in pipeLine.Error.ReadToEnd())
{
errorList.Add(item);
string errorMessage = string.Format("Invoke error: {0}", item);
HostedSolutionLog.LogWarning(errorMessage);
}
}
}
pipeLine = null;
errors = errorList.ToArray();
HostedSolutionLog.LogEnd("ExecuteShellCommand");
return results;
}
internal Collection<PSObject> ExecuteShellCommand(Runspace runSpace, Command cmd, bool useDomainController, out object[] errors)
{
Log.WriteStart("ExecuteShellCommand");
// 05.09.2015 [email protected]
// New: Add LogInfo
Log.WriteInfo("Command : {0}", cmd.CommandText);
foreach (var par in cmd.Parameters)
Log.WriteInfo("Parameter : Name {0}, Value {1}", par.Name, par.Value);
Log.WriteInfo("UseDomainController : {0}", useDomainController);
List<object> errorList = new List<object>();
if (useDomainController)
{
CommandParameter dc = new CommandParameter("DomainController", PrimaryDomainController);
if (!cmd.Parameters.Contains(dc))
{
cmd.Parameters.Add(dc);
}
}
Collection<PSObject> results = null;
// Create a pipeline
Pipeline pipeLine = runSpace.CreatePipeline();
using (pipeLine)
{
// Add the command
pipeLine.Commands.Add(cmd);
// Execute the pipeline and save the objects returned.
results = pipeLine.Invoke();
// Log out any errors in the pipeline execution
// NOTE: These errors are NOT thrown as exceptions!
// Be sure to check this to ensure that no errors
// happened while executing the command.
if (pipeLine.Error != null && pipeLine.Error.Count > 0)
{
foreach (object item in pipeLine.Error.ReadToEnd())
{
errorList.Add(item);
string errorMessage = string.Format("Invoke error: {0}", item);
Log.WriteWarning(errorMessage);
}
}
}
pipeLine = null;
errors = errorList.ToArray();
Log.WriteEnd("ExecuteShellCommand");
return results;
}