/// <summary> /// set the current runspace to local. /// Every command will be executed on the local machine /// </summary> public void SetLocalHost() { if (!this.m_runspaces.ContainsKey("localhost")) { RunspaceConfiguration rc = RunspaceConfiguration.Create(); PSSnapInException psSnapInException = null; switch (this.m_ExchangeVersion) { case ExchangeVersionEnum.v2010: rc.AddPSSnapIn("Microsoft.Exchange.Management.PowerShell.E2010", out psSnapInException); break; case ExchangeVersionEnum.v2013: rc.AddPSSnapIn("Microsoft.Exchange.Management.PowerShell.SnapIn", out psSnapInException); break; } if (psSnapInException != null) { throw psSnapInException; } var runspace = RunspaceFactory.CreateRunspace(rc); runspace.Open(); this.m_runspaces.Add("localhost", runspace); } this.Host = "localhost"; }
internal virtual Runspace OpenRunspace() { ExchangeLog.LogStart("OpenRunspace"); if (runspaceConfiguration == null) { runspaceConfiguration = RunspaceConfiguration.Create(); PSSnapInException exception = null; PSSnapInInfo info = runspaceConfiguration.AddPSSnapIn(ExchangeSnapInName, out exception); if (exception != null) { ExchangeLog.LogWarning("SnapIn error", exception); } } Runspace runSpace = RunspaceFactory.CreateRunspace(runspaceConfiguration); //AdminSessionADSettings adSettings = SetADSettings(); runSpace.Open(); //runSpace.SessionStateProxy.SetVariable("AdminSessionADSettings", adSettings); runSpace.SessionStateProxy.SetVariable("ConfirmPreference", "none"); ExchangeLog.LogEnd("OpenRunspace"); return(runSpace); }
public ExchangeCommandResolver(IEnumerable <string> snapIns) { RunspaceConfiguration runspaceConfiguration = RunspaceConfiguration.Create(); PSSnapInException ex = null; Exception ex2 = null; IEnumerable <string> enumerable = (from s in snapIns select s.ToLower()).Distinct <string>(); foreach (string name in enumerable) { try { runspaceConfiguration.AddPSSnapIn(name, out ex); ex2 = ex; } catch (PSArgumentException ex3) { ex2 = ex3; } if (ex2 != null) { ReportingWebServiceEventLogConstants.Tuple_LoadReportingschemaFailed.LogEvent(new object[] { ex2.Message }); ServiceDiagnostics.ThrowError(ReportingErrorCode.ErrorSchemaInitializationFail, Strings.ErrorSchemaInitializationFail, ex2); } } this.runspace = RunspaceFactory.CreateRunspace(runspaceConfiguration); if (this.runspace.RunspaceStateInfo.State != RunspaceState.Opened) { this.runspace.Open(); } }
/// <summary>Opens PowerShell runspace.</summary> /// <returns>The runspace.</returns> private Runspace OpenRunspace() { HostedSolutionLog.LogStart("OpenRunspace"); if (runspaceConfiguration == null) { runspaceConfiguration = RunspaceConfiguration.Create(); PSSnapInException exception; runspaceConfiguration.AddPSSnapIn(SharepointSnapInName, out exception); HostedSolutionLog.LogInfo("Sharepoint snapin loaded"); if (exception != null) { HostedSolutionLog.LogWarning("SnapIn error", exception); } } Runspace runspace = RunspaceFactory.CreateRunspace(runspaceConfiguration); runspace.Open(); runspace.SessionStateProxy.SetVariable("ConfirmPreference", "none"); HostedSolutionLog.LogEnd("OpenRunspace"); return(runspace); }
private static void AddPSSnapIn(RunspaceConfiguration runspaceConfiguration, string mshSnapInName) { PSSnapInException ex = null; runspaceConfiguration.AddPSSnapIn(mshSnapInName, out ex); if (ex != null) { throw new CouldNotAddExchangeSnapInTransientException(mshSnapInName, ex); } }
public void InitializeTests() { RunspaceConfiguration config = RunspaceConfiguration.Create(); PSSnapInException warning; config.AddPSSnapIn("ShareFile", out warning); runspace = RunspaceFactory.CreateRunspace(config); runspace.Open(); }
private Runspace GetConnectorPowershellRunspace() { RunspaceConfiguration runspaceConfiguration = RunspaceConfiguration.Create(); PSSnapInException ex = null; runspaceConfiguration.AddPSSnapIn("Microsoft.Exchange.Management.PowerShell.E2010", out ex); if (ex != null) { throw ex; } return(RunspaceFactory.CreateRunspace(runspaceConfiguration)); }
private void RunNormal() { Pipeline pipeline = null; Runspace runspace = null; try { RunspaceConfiguration runConfig = RunspaceConfiguration.Create(); PSSnapInException psEx = null; string script = OSAEScriptManager.GetScriptByName(Name); runConfig.AddPSSnapIn("OSA", out psEx); runspace = RunspaceFactory.CreateRunspace(runConfig); runspace.ThreadOptions = PSThreadOptions.UseCurrentThread; runspace.Open(); runspace.SessionStateProxy.SetVariable("parameter2", Parameter2); pipeline = runspace.CreatePipeline(); pipeline.Commands.AddScript(script); pipeline.Commands.Add("Out-String"); Collection <PSObject> results = pipeline.Invoke(); StringBuilder stringBuilder = new StringBuilder(); foreach (PSObject obj in results) { stringBuilder.AppendLine(obj.ToString()); } logging.AddToLog("Script return: \r\n" + stringBuilder.ToString(), false); } catch (Exception ex) { logging.AddToLog("An error occured while trying to run the script, details: \r\n" + ex.Message, true); } finally { if (pipeline != null) { pipeline.Dispose(); } if (runspace != null) { runspace.Close(); runspace.Dispose(); } } }
/// <summary> /// Runs the content of the script parameter as a powershell script /// </summary> /// <param name="script">The script to be run</param> private void RunScript(string script, OSAEMethod method) { Pipeline pipeline = null; Runspace runspace = null; try { RunspaceConfiguration runConfig = RunspaceConfiguration.Create(); PSSnapInException psEx = null; runConfig.AddPSSnapIn("OSA", out psEx); runspace = RunspaceFactory.CreateRunspace(runConfig); runspace.ThreadOptions = PSThreadOptions.UseCurrentThread; runspace.Open(); runspace.SessionStateProxy.SetVariable("parameter2", method.Parameter2); pipeline = runspace.CreatePipeline(); pipeline.Commands.AddScript(script); pipeline.Commands.Add("Out-String"); Collection <PSObject> results = pipeline.Invoke(); StringBuilder stringBuilder = new StringBuilder(); foreach (PSObject obj in results) { stringBuilder.AppendLine(obj.ToString()); } this.Log.Debug("Script return: " + stringBuilder.ToString()); } catch (Exception ex) { this.Log.Error("An error occured while trying to run the script, details", ex); } finally { if (pipeline != null) { pipeline.Dispose(); } if (runspace != null) { runspace.Close(); runspace.Dispose(); } } }
private static void AddPSSnapIn(RunspaceConfiguration runspaceConfiguration, string mshSnapInName) { PSSnapInException ex = null; PSSnapInInfo pssnapInInfo = runspaceConfiguration.AddPSSnapIn(mshSnapInName, out ex); if (ex != null) { throw ex; } if (pssnapInInfo != null) { ExTraceGlobals.IntegrationTracer.Information(0L, mshSnapInName + " added to Runspace:" + pssnapInInfo.ToString()); } }
private Collection <PSObject> RunPsScriptTBD(string psScriptPath) { string psScript = string.Empty; if (File.Exists(psScriptPath)) { psScript = File.ReadAllText(psScriptPath); } else { throw new FileNotFoundException("Wrong path for the script file"); } RunspaceConfiguration config = RunspaceConfiguration.Create(); PSSnapInException psEx; //add Microsoft SharePoint PowerShell SnapIn PSSnapInInfo pssnap = config.AddPSSnapIn("Microsoft.SharePoint.PowerShell", out psEx); //create powershell runspace Runspace cmdlet = RunspaceFactory.CreateRunspace(config); cmdlet.Open(); RunspaceInvoke scriptInvoker = new RunspaceInvoke(cmdlet); // set powershell execution policy to unrestricted scriptInvoker.Invoke("Set-ExecutionPolicy Unrestricted"); // create a pipeline and load it with command object Pipeline pipeline = cmdlet.CreatePipeline(); try { // Using Get-SPFarm powershell command pipeline.Commands.AddScript(psScript); pipeline.Commands.AddScript("Out-String"); // this will format the output Collection <PSObject> output = pipeline.Invoke(); pipeline.Stop(); cmdlet.Close(); // process each object in the output and append to stringbuilder StringBuilder results = new StringBuilder(); foreach (PSObject obj in output) { results.AppendLine(obj.ToString()); } return(output); } catch (Exception ex) { return(null); } }
public Collection <PSObject> ExecuteCommand(Command command) { RunspaceConfiguration runspaceConf = RunspaceConfiguration.Create(); PSSnapInException PSException = null; PSSnapInInfo info = runspaceConf.AddPSSnapIn("Microsoft.Exchange.Management.PowerShell.E2010", out PSException); Runspace runspace = RunspaceFactory.CreateRunspace(runspaceConf); runspace.Open(); Pipeline pipeline = runspace.CreatePipeline(); pipeline.Commands.Add(command); Collection <PSObject> result = pipeline.Invoke(); return(result); }
/// <summary> /// This sample introduces how to add a PSSnapin to RunspaceConfiguration and /// then use modified RunspaceConfiguration to create the Runspace. /// </summary> /// <param name="args">Unused</param> /// <remarks> /// This sample assumes that user has the PowerShell snap-in "GetProcPSSnapIn01" /// produced in sample GetProcessSample01 installed on the machine. /// /// This sample demonstrates the following: /// 1. Creating an instance of RunspaceConfiguration /// 2. Adding a PowerShell snap-in to this configuration /// 3. Using the configuration to create a runspace /// 4. Create a pipeline with the get-proc cmdlet available in the PowerShell snap-in /// 5. Using PSObject to extract and display properties from the objects /// returned by this command /// </remarks> static void Main(string[] args) { //Create a default RunspaceConfiguration RunspaceConfiguration config = RunspaceConfiguration.Create(); //Add GetProcPSSnapIn01 to config. PSSnapInException warning; config.AddPSSnapIn("GetProcPSSnapIn01", out warning); if (warning != null) { //We don't expect any warning so write the warning and return System.Console.Write(warning.Message); return; } // Create a runspace. // (Note that no PSHost instance is supplied in the constructor so the // default PSHost implementation is used. See the Hosting topics for // more information on creating your own PSHost class.) Runspace myRunSpace = RunspaceFactory.CreateRunspace(config); myRunSpace.Open(); // Create a pipeline with get-proc command from PowerShell snap-in GetProcPSSnapIn01. Pipeline pipeLine = myRunSpace.CreatePipeline("GetProcPSSnapIn01\\get-proc"); Collection <PSObject> results = pipeLine.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(); }
static PSCommandBase() { lock (sync) { if (_runspace != null && _runspace.RunspaceStateInfo.State == RunspaceState.Broken) { _runspace.Close(); _runspace.Dispose(); } _runspaceConfiguration = RunspaceConfiguration.Create(); _runspaceConfiguration.AddPSSnapIn(EXCHANGE_MANAGEMENT_ADMIN, out _psSnapinException); _runspace = RunspaceFactory.CreateRunspace(_runspaceConfiguration); _runspace.Open(); // _runspace.SessionStateProxy.SetVariable("ConfirmPreference", "none"); } }
private static void ReOpen() { lock (sync) { #region modfiy by 2016/09/01 if (_runspace != null && _runspace.RunspaceStateInfo.State == RunspaceState.Broken) { _runspace.Close(); _runspace.Dispose(); } _runspaceConfiguration = RunspaceConfiguration.Create(); _runspaceConfiguration.AddPSSnapIn(EXCHANGE_MANAGEMENT_ADMIN, out _psSnapinException); _runspace = RunspaceFactory.CreateRunspace(_runspaceConfiguration); _runspace.Open(); // _runspace.SessionStateProxy.SetVariable("ConfirmPreference", "none"); #endregion } }
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); } }
private static bool RunScript(string cmd) { // create Powershell runspace try { RunspaceConfiguration rsConfig = RunspaceConfiguration.Create(); PSSnapInException snapInException = null; PSSnapInInfo info = rsConfig.AddPSSnapIn("Microsoft.Exchange.Management.PowerShell.E2010", out snapInException); Runspace myRunSpace = RunspaceFactory.CreateRunspace(rsConfig); myRunSpace.Open(); Pipeline pipeLine = myRunSpace.CreatePipeline(); Command myCommand = new Command(cmd, true); pipeLine.Commands.Add(myCommand); Collection <PSObject> commandResults = pipeLine.Invoke(); foreach (PSObject obj in commandResults) { Console.WriteLine(obj.ToString()); } return(true); } catch (Exception ex) { return(false); } }
private void RunPowerShell() { //create the runspace runSpace = RunspaceFactory.CreateRunspace(rsConfig); runSpace.Open(); rsConfig.AddPSSnapIn("Microsoft.Exchange.Management.PowerShell.E2010", out snapInException); //set up the pipeline to run the powershell command Pipeline pipeLine = runSpace.CreatePipeline(); //create the script to run String sScript = "get-mailbox -identity 'rj'"; //invoke the command pipeLine.Commands.AddScript(sScript); Collection<PSObject> commandResults = pipeLine.Invoke(); //loop through the results of the command and load the SamAccountName into the list foreach (PSObject results in commandResults) { Console.WriteLine(results.Properties["SamAccountName"].Value.ToString()); } pipeLine.Dispose(); runSpace.Close(); }
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]; } }
public Runspace DefaultRunspaceCreateMethod() { LOGGER.TraceEvent(TraceEventType.Verbose, CAT_DEFAULT, "Creating runspace configuration"); RunspaceConfiguration runSpaceConfig = RunspaceConfiguration.Create(); if (_localSnapinNames != null) { foreach (string snapinName in _localSnapinNames) { LOGGER.TraceEvent(TraceEventType.Verbose, CAT_DEFAULT, "Adding snap-in {0}", snapinName); PSSnapInException snapOutput = null; runSpaceConfig.AddPSSnapIn(snapinName, out snapOutput); if (snapOutput != null) { throw snapOutput; } } } LOGGER.TraceEvent(TraceEventType.Verbose, CAT_DEFAULT, "Creating the runspace"); var runspace = RunspaceFactory.CreateRunspace(runSpaceConfig); LOGGER.TraceEvent(TraceEventType.Verbose, CAT_DEFAULT, "Runspace created"); return(runspace); }
public Runspace DefaultRunspaceCreateMethod() { LOG.Trace("Creating runspace configuration"); RunspaceConfiguration runSpaceConfig = RunspaceConfiguration.Create(); if (_localSnapinNames != null) { foreach (string snapinName in _localSnapinNames) { LOG.Debug("Adding snap-in {0}", snapinName); PSSnapInException snapOutput = null; runSpaceConfig.AddPSSnapIn(snapinName, out snapOutput); if (snapOutput != null) { throw snapOutput; } } } LOG.Trace("Creating the runspace"); var runspace = RunspaceFactory.CreateOutOfProcessRunspace(new TypeTable(new string[0])); LOG.Trace("Runspace created"); return(runspace); }
/// <summary> The asynchronous execution method. </summary> /// <remarks> Anthony, 5/27/2015. </remarks> /// <exception cref="ArgumentException"> Thrown when one or more arguments have /// unsupported or illegal values. </exception> /// <exception cref="ArgumentNullException"> Thrown when one or more required arguments /// are null. </exception> /// <exception cref="PSSnapInException"> . </exception> /// <exception cref="PowerShellExecutionException"> Thrown when a Power Shell Execution error /// condition occurs. </exception> /// <param name="filename"> The filename. </param> /// <param name="snapin"> The snap in. </param> /// <param name="module"> The module. </param> /// <param name="parametersList"> The parameters List. </param> /// <param name="asJob"> Run this command as a job. </param> /// <returns> The <see cref="Task"/>. </returns> public Task <PowershellReturn> ExecuteAsync( string filename, string snapin, string module, IList <KeyValuePair <string, string> > parametersList, bool asJob) { if (string.IsNullOrWhiteSpace(filename)) { throw new ArgumentException("Argument cannot be null, empty or composed of whitespaces only", "filename"); } if (parametersList == null) { throw new ArgumentNullException("parametersList", "Argument cannot be null"); } // Raise an event so we know what is going on try { var sb = new StringBuilder(); foreach (KeyValuePair <string, string> kvp in parametersList) { if (sb.Length > 0) { sb.Append(";"); } sb.Append(string.Format("{0}:{1}", kvp.Key, kvp.Value)); } DynamicPowershellApiEvents .Raise .ExecutingPowerShellScript(filename, sb.ToString()); } catch (Exception) { DynamicPowershellApiEvents .Raise .ExecutingPowerShellScript(filename, "Unknown"); } try { string strBaseDirectory = AppDomain.CurrentDomain.BaseDirectory; string scriptContent = File.ReadAllText(Path.Combine(strBaseDirectory, Path.Combine("ScriptRepository", filename))); RunspaceConfiguration rsConfig = RunspaceConfiguration.Create(); if (!String.IsNullOrWhiteSpace(snapin)) { PSSnapInException snapInException; rsConfig.AddPSSnapIn(snapin, out snapInException); if (snapInException != null) { DynamicPowershellApiEvents .Raise .SnapinException(snapInException.Message); throw snapInException; } } InitialSessionState initialSession = InitialSessionState.Create(); if (!String.IsNullOrWhiteSpace(module)) { DynamicPowershellApiEvents .Raise .LoadingModule(module); initialSession.ImportPSModule(new[] { module }); } using (PowerShell powerShellInstance = PowerShell.Create(initialSession)) { powerShellInstance.RunspacePool = RunspacePoolWrapper.Pool; if (powerShellInstance.Runspace == null) { powerShellInstance.Runspace = RunspaceFactory.CreateRunspace(rsConfig); powerShellInstance.Runspace.Open(); } powerShellInstance.AddScript(scriptContent); foreach (var item in parametersList) { powerShellInstance.AddParameter(item.Key, item.Value); } // invoke execution on the pipeline (collecting output) Collection <PSObject> psOutput = powerShellInstance.Invoke(); string sMessage = psOutput == null ? String.Empty : ( psOutput.LastOrDefault() != null ? Regex.Replace(psOutput.LastOrDefault().ToString(), @"[^\u0000-\u007F]", string.Empty) : String.Empty); DynamicPowershellApiEvents.Raise.PowerShellScriptFinalised("The powershell has completed - anlaysing results now"); // check the other output streams (for example, the error stream) if (powerShellInstance.HadErrors && powerShellInstance.Streams.Error.Count > 0) { var runtimeErrors = new List <PowerShellException>(); // Create a string builder for the errors StringBuilder sb = new StringBuilder(); // error records were written to the error stream. // do something with the items found. sb.Append("PowerShell script raised errors:" + Environment.NewLine); sb.Append(String.Format("{0}", sMessage)); var errors = powerShellInstance.Streams.Error.ReadAll(); if (errors != null) { foreach (var error in errors) { if (error.ErrorDetails == null) { DynamicPowershellApiEvents.Raise.UnhandledException("error.ErrorDetails is null"); } string errorDetails = error.ErrorDetails != null ? error.ErrorDetails.Message : String.Empty; string scriptStack = error.ScriptStackTrace ?? String.Empty; string commandPath = error.InvocationInfo.PSCommandPath ?? String.Empty; if (error.ScriptStackTrace == null) { DynamicPowershellApiEvents.Raise.UnhandledException("error.ScriptStackTrace is null"); } if (error.InvocationInfo == null) { DynamicPowershellApiEvents.Raise.UnhandledException("error.InvocationInfo is null"); } else { if (error.InvocationInfo.PSCommandPath == null) { DynamicPowershellApiEvents.Raise.UnhandledException("error.InvocationInfo.PSCommandPath is null"); } } if (error.Exception == null) { DynamicPowershellApiEvents.Raise.UnhandledException("error.Exception is null"); } DynamicPowershellApiEvents.Raise.PowerShellError( errorDetails, scriptStack, commandPath, error.InvocationInfo.ScriptLineNumber); runtimeErrors.Add(new PowerShellException { StackTrace = scriptStack, ErrorMessage = errorDetails, LineNumber = error.InvocationInfo != null ? error.InvocationInfo.ScriptLineNumber : 0, ScriptName = filename }); if (error.Exception != null) { sb.Append(String.Format("PowerShell Exception {0} : {1}", error.Exception.Message, error.Exception.StackTrace)); } sb.Append(String.Format("Error {0}", error.ScriptStackTrace)); } } else { sb.Append(sMessage); } DynamicPowershellApiEvents.Raise.PowerShellScriptFinalised(String.Format("An error was rasied {0}", sb)); throw new PowerShellExecutionException(sb.ToString()) { Exceptions = runtimeErrors, LogTime = DateTime.Now }; } var psGood = new PowershellReturn { PowerShellReturnedValidData = true, ActualPowerShellData = sMessage }; DynamicPowershellApiEvents.Raise.PowerShellScriptFinalised(String.Format("The powershell returned the following {0}", psGood.ActualPowerShellData)); return(Task.FromResult(psGood)); } } catch (Exception runnerException) { if (runnerException.GetType() == typeof(PowerShellExecutionException)) { throw; } DynamicPowershellApiEvents.Raise.UnhandledException(runnerException.Message, runnerException.StackTrace); throw new PowerShellExecutionException(runnerException.Message) { Exceptions = new List <PowerShellException> { new PowerShellException { ErrorMessage = runnerException.Message, LineNumber = 0, ScriptName = "PowerShellRunner.cs", StackTrace = runnerException.StackTrace } }, LogTime = DateTime.Now }; } }
private void loadCitrixCmdlets() { PSSnapInException psEx = null; //load all the citrix powershell snapins rsc.AddPSSnapIn("Citrix.ADIdentity.Admin.V2", out psEx); rsc.AddPSSnapIn("Citrix.Analytics.Admin.V1", out psEx); rsc.AddPSSnapIn("Citrix.AppLibrary.Admin.V1", out psEx); rsc.AddPSSnapIn("Citrix.AppV.Admin.V1", out psEx); rsc.AddPSSnapIn("Citrix.Broker.Admin.V2", out psEx); rsc.AddPSSnapIn("Citrix.Configuration.Admin.V2", out psEx); rsc.AddPSSnapIn("Citrix.ConfigurationLogging.Admin.V1", out psEx); rsc.AddPSSnapIn("Citrix.DelegatedAdmin.Admin.V1", out psEx); rsc.AddPSSnapIn("Citrix.EnvTest.Admin.V1", out psEx); rsc.AddPSSnapIn("Citrix.Host.Admin.V2", out psEx); rsc.AddPSSnapIn("Citrix.Licensing.Admin.V1", out psEx); rsc.AddPSSnapIn("Citrix.MachineCreation.Admin.V2", out psEx); rsc.AddPSSnapIn("Citrix.Monitor.Admin.V1", out psEx); rsc.AddPSSnapIn("Citrix.Orchestration.Admin.V1", out psEx); rsc.AddPSSnapIn("Citrix.Storefront.Admin.V1", out psEx); rsc.AddPSSnapIn("Citrix.Trust.Admin.V1", out psEx); rsc.AddPSSnapIn("Citrix.UserProfileManager.Admin.V1", out psEx); }