/// <summary> /// Checks if Plaster is installed on the user's machine. /// </summary> /// <returns>A Task that can be awaited until the check is complete. The result will be true if Plaster is installed.</returns> public async Task <bool> ImportPlasterIfInstalledAsync() { if (!this.isPlasterInstalled.HasValue) { PSCommand psCommand = new PSCommand(); psCommand .AddCommand("Get-Module") .AddParameter("ListAvailable") .AddParameter("Name", "Plaster"); psCommand .AddCommand("Sort-Object") .AddParameter("Descending") .AddParameter("Property", "Version"); psCommand .AddCommand("Select-Object") .AddParameter("First", 1); this.logger.LogTrace("Checking if Plaster is installed..."); var getResult = await this.powerShellContext.ExecuteCommandAsync <PSObject>( psCommand, false, false).ConfigureAwait(false); PSObject moduleObject = getResult.First(); this.isPlasterInstalled = moduleObject != null; string installedQualifier = this.isPlasterInstalled.Value ? string.Empty : "not "; this.logger.LogTrace($"Plaster is {installedQualifier}installed!"); // Attempt to load plaster if (this.isPlasterInstalled.Value && this.isPlasterLoaded == false) { this.logger.LogTrace("Loading Plaster..."); psCommand = new PSCommand(); psCommand .AddCommand("Import-Module") .AddParameter("ModuleInfo", (PSModuleInfo)moduleObject.ImmediateBaseObject) .AddParameter("PassThru"); var importResult = await this.powerShellContext.ExecuteCommandAsync <object>( psCommand, false, false).ConfigureAwait(false); this.isPlasterLoaded = importResult.Any(); string loadedQualifier = this.isPlasterInstalled.Value ? "was" : "could not be"; this.logger.LogTrace($"Plaster {loadedQualifier} loaded successfully!"); } } return(this.isPlasterInstalled.Value); }
/// <summary> /// Creates the PSCommand when the runspace is not overridden. /// </summary> private PSCommand CreatePsCommandNotOverridden(string line, bool isScript, bool?useNewScope) { PSCommand command = new PSCommand(); if (isScript) { if (useNewScope.HasValue) { command.AddScript(line, useNewScope.Value); } else { command.AddScript(line); } } else { if (useNewScope.HasValue) { command.AddCommand(line, useNewScope.Value); } else { command.AddCommand(line); } } return(command); }
public static void SetFolderPermissions(string mailbox, string folder, string user, string accessRights) { PSCommand commands = new PSCommand(); if (folder == "\\Top of Information Store") { folder = "\\"; } string folderPath = mailbox + ":" + folder; commands.AddCommand("Set-MailboxFolderPermission"); commands.AddParameter("Identity", folderPath); commands.AddParameter("User", user); commands.AddParameter("AccessRights", accessRights); Collection <PSObject> result1 = runPowershellCommands(commands); if (result1.Count == 0) { commands.Clear(); commands.AddCommand("Add-MailboxFolderPermission"); commands.AddParameter("Identity", folderPath); commands.AddParameter("User", user); commands.AddParameter("AccessRights", accessRights); Collection <PSObject> result2 = runPowershellCommands(commands); } }
public List <string> GetManagedBy(string groupname) { var ret = new List <string>(); var runspace = this.CreateRunspace(); var powershell = PowerShell.Create(); var command = new PSCommand(); command.AddCommand("Get-DistributionGroup"); command.AddArgument(groupname); command.AddCommand("Select-Object"); command.AddParameter("Property", "ManagedBy"); powershell.Commands = command; try { runspace.Open(); powershell.Runspace = runspace; Collection <PSObject> results = powershell.Invoke(); this._log.Info(JsonConvert.SerializeObject(results)); if (results != null) { if (results.Count > 0) { for (int i = 0; i < results.Count; i++) { if (results[i].Properties.Any(property => property.Name == "ManagedBy")) { var users = (ArrayList) ((System.Management.Automation.PSObject) (results[0].Properties["ManagedBy"].Value)).BaseObject; ret.AddRange(from object user in users select user.ToString() into name select name.Contains("/") ? name.Substring(name.LastIndexOf("/", StringComparison.Ordinal) + 1) : name); } } } else { this._log.Info(command.Commands[0].CommandText); } } return(ret); } catch (Exception ex) { return(ret); } finally { runspace.Dispose(); runspace = null; powershell.Dispose(); powershell = null; } }
private async Task ClearCommandBreakpoints() { PSCommand psCommand = new PSCommand(); psCommand.AddCommand(@"Microsoft.PowerShell.Utility\Get-PSBreakpoint"); psCommand.AddParameter("Type", "Command"); psCommand.AddCommand(@"Microsoft.PowerShell.Utility\Remove-PSBreakpoint"); await this.powerShellContext.ExecuteCommand <object>(psCommand); }
/// <summary> /// Gets a list of message tracking logs between a time period for sent messages /// </summary> /// <param name="start"></param> /// <param name="end"></param> /// <returns></returns> public List <Models.MessageTrackingLog> Get_TotalSentMessages(DateTime start, DateTime end) { List <Models.MessageTrackingLog> totalSentMessages = new List <Models.MessageTrackingLog>(); PSCommand cmd = new PSCommand(); if (Config.ServiceSettings.ExchangeVersion >= 2013) { cmd.AddCommand("Get-TransportService"); } else { cmd.AddCommand("Get-TransportServer"); } cmd.AddCommand("Get-MessageTrackingLog"); cmd.AddParameter("EventId", "RECEIVE"); cmd.AddParameter("Start", start.ToString("MM/dd/yyyy HH:mm", CultureInfo.InvariantCulture)); cmd.AddParameter("End", end.ToString("MM/dd/yyyy HH:mm", CultureInfo.InvariantCulture)); cmd.AddParameter("ResultSize", "Unlimited"); cmd.AddParameter("DomainController", Config.ServiceSettings.PrimaryDC); _powershell.Commands = cmd; Collection <PSObject> psObjects = _powershell.Invoke(); if (_powershell.HadErrors) { throw _powershell.Streams.Error[0].Exception; } else { foreach (PSObject ps in psObjects) { Models.MessageTrackingLog newLog = new Models.MessageTrackingLog(); newLog.Timestamp = DateTime.Parse(ps.Members["Timestamp"].Value.ToString()); newLog.ServerHostname = ps.Members["ServerHostname"].Value.ToString(); newLog.Source = ps.Members["Source"].Value.ToString(); newLog.EventId = ps.Members["EventId"].Value.ToString(); newLog.TotalBytes = long.Parse(ps.Members["TotalBytes"].Value.ToString()); newLog.Users = new List <string>(); newLog.Users.Add(ps.Members["Sender"].Value.ToString()); if (newLog.Source.Equals("STOREDRIVER")) { totalSentMessages.Add(newLog); } } } return(totalSentMessages); }
/// <summary> /// Parse a PowerShell text string into a PSCommand with parameters /// This is a very basic parser and won't work with complex cmdlet calls /// </summary> /// <param name="commandLine">The PowerShell code</param> private PSCommand ParseCommand(string commandLine) { PSCommand command = new PSCommand(); int i = commandLine.IndexOf(" "); if (i < 0) { // The command has no parameters, so add as is command.AddCommand(commandLine); return(command); } // Add the command, then we need to deal with parameters command.AddCommand(commandLine.Substring(0, i)); string parameters = commandLine.Substring(i + 1); i = parameters.IndexOf("-", i); if (i < 0) { // We have parameters, but they are not named - we just add them to the command command.AddArgument(parameters); return(command); } // Now parse and add parameters try { while ((i > 0) && (i < commandLine.Length)) { int j = parameters.IndexOf("-", i + 1); if (j < 0) { j = parameters.Length; } int p = parameters.IndexOf(" ", i + 1); string sParamName = parameters.Substring(i + 1, p - i - 1); string sParamValue = parameters.Substring(p + 1, j - p - 2).Trim(); if (sParamValue.StartsWith("\"") && sParamValue.EndsWith("\"")) { sParamValue = sParamValue.Substring(1, sParamValue.Length - 2); } command.AddParameter(sParamName, sParamValue); i = j; } } catch (Exception ex) { LogError(String.Format("Unable to parse command parameters: {0}", ex.Message)); } return(command); }
/// <summary> /// Gets a list of message tracking logs between a time period for received messages /// </summary> /// <param name="start"></param> /// <param name="end"></param> /// <returns></returns> public List <Models.MessageTrackingLog> Get_TotalReceivedMessages(DateTime start, DateTime end) { List <Models.MessageTrackingLog> totalReceivedMessages = new List <Models.MessageTrackingLog>(); PSCommand cmd = new PSCommand(); if (Config.ServiceSettings.ExchangeVersion >= 2013) { cmd.AddCommand("Get-TransportService"); } else { cmd.AddCommand("Get-TransportServer"); } cmd.AddCommand("Get-MessageTrackingLog"); cmd.AddParameter("EventId", "DELIVER"); cmd.AddParameter("Start", start.ToString("MM/dd/yyyy HH:mm", CultureInfo.InvariantCulture)); cmd.AddParameter("End", end.ToString("MM/dd/yyyy HH:mm", CultureInfo.InvariantCulture)); cmd.AddParameter("ResultSize", "Unlimited"); cmd.AddParameter("DomainController", Config.ServiceSettings.PrimaryDC); _powershell.Commands = cmd; Collection <PSObject> psObjects = _powershell.Invoke(); if (_powershell.HadErrors) { throw _powershell.Streams.Error[0].Exception; } else { foreach (PSObject ps in psObjects) { Models.MessageTrackingLog newLog = new Models.MessageTrackingLog(); newLog.Timestamp = DateTime.Parse(ps.Members["Timestamp"].Value.ToString()); newLog.ServerHostname = ps.Members["ServerHostname"].Value.ToString(); newLog.Source = ps.Members["Source"].Value.ToString(); newLog.EventId = ps.Members["EventId"].Value.ToString(); newLog.TotalBytes = long.Parse(ps.Members["TotalBytes"].Value.ToString()); var multiValue = ps.Members["Recipients"].Value as PSObject; var users = multiValue.BaseObject as ArrayList; var array = users.ToArray(typeof(string)) as string[]; newLog.Users = array.ToList(); totalReceivedMessages.Add(newLog); } } return(totalReceivedMessages); }
public List <MessageLog> GetReceiveLog(string reveive, DateTime startTime, DateTime endTime, string subject) { var ret = new List <MessageLog>(); var runspace = this.CreateRunspace(); var powershell = PowerShell.Create(); var command = new PSCommand(); command.AddCommand("get-transportservice"); command.AddCommand("get-messagetrackinglog"); command.AddParameter("Recipients", reveive); command.AddParameter("Start", startTime.ToString("yyyy/MM/dd HH:mm:ss")); command.AddParameter("End", endTime.ToString("yyyy/MM/dd HH:mm:ss")); command.AddParameter("MessageSubject", subject); command.AddCommand("Select-Object"); command.AddParameter("Property", new string[] { "Timestamp", "EventId", "Source", "MessageSubject", "ServerIp", "ServerHostname" }); powershell.Commands = command; try { runspace.Open(); powershell.Runspace = runspace; Collection <PSObject> results = powershell.Invoke(); if (results != null) { foreach (var psobj in results) { var log = new MessageLog(); log.Timestamp = psobj.Properties["Timestamp"].Value.ToString(); log.EventId = psobj.Properties["EventId"].Value.ToString(); log.Source = psobj.Properties["Source"].Value.ToString(); log.MessageSubject = psobj.Properties["MessageSubject"].Value.ToString(); log.ServerIp = psobj.Properties["ServerIp"].Value.ToString(); log.ServerHostname = psobj.Properties["ServerHostname"].Value.ToString(); ret.Add(log); } } } catch (Exception ex) { this._log.Error("获取发送日志失败", ex); } finally { runspace.Dispose(); powershell.Dispose(); } return(ret); }
public CommandResult GetRequireSenderAuthenticationEnabled(string groupname) { var ret = new CommandResult(); var runspace = this.CreateRunspace(); var powershell = PowerShell.Create(); var command = new PSCommand(); command.AddCommand("Get-DistributionGroup"); command.AddArgument(groupname); command.AddCommand("Select-Object"); command.AddParameter("Property", "RequireSenderAuthenticationEnabled"); powershell.Commands = command; try { runspace.Open(); powershell.Runspace = runspace; Collection <PSObject> results = powershell.Invoke(); if (results != null && results.Count > 0) { ret.Success = true; ret.Message = results[0].Properties["RequireSenderAuthenticationEnabled"].Value.ToString(); } else { ret.Success = false; ret.Message = "获取属性失败"; } return(ret); } catch (Exception ex) { return(new CommandResult() { Success = false, Message = $"消息:{ex.Message} 堆栈:{ex.StackTrace}" }); } finally { runspace.Dispose(); runspace = null; powershell.Dispose(); powershell = null; } }
/// <summary> /// Gets the CommandInfo instance for a command with a particular name. /// </summary> /// <param name="commandName">The name of the command.</param> /// <param name="powerShellContext">The PowerShellContext to use for running Get-Command.</param> /// <returns>A CommandInfo object with details about the specified command.</returns> public static async Task <CommandInfo> GetCommandInfoAsync( string commandName, PowerShellContextService powerShellContext) { Validate.IsNotNull(nameof(commandName), commandName); Validate.IsNotNull(nameof(powerShellContext), powerShellContext); // Make sure the command's noun isn't blacklisted. This is // currently necessary to make sure that Get-Command doesn't // load PackageManagement or PowerShellGet because they cause // a major slowdown in IntelliSense. var commandParts = commandName.Split('-'); if (commandParts.Length == 2 && NounExclusionList.ContainsKey(commandParts[1])) { return(null); } PSCommand command = new PSCommand(); command.AddCommand(@"Microsoft.PowerShell.Core\Get-Command"); command.AddArgument(commandName); command.AddParameter("ErrorAction", "Ignore"); return((await powerShellContext.ExecuteCommandAsync <PSObject>(command, sendOutputToHost: false, sendErrorToHost: false).ConfigureAwait(false)) .Select(o => o.BaseObject) .OfType <CommandInfo>() .FirstOrDefault()); }
public void Should_UpdateEntry() { _powerShell.Commands.Clear(); var mySM = new MockServiceManager(); ServiceManager.Provider = () => mySM; var hfe = new HostFileEntry() { Address = "127.0.0.2", Hostname = "abc.com" }; mySM.SetupExistingHostList(new [] { hfe }); PSCommand psCmd = new PSCommand(); psCmd.AddCommand("Set-HfHostAddress"); psCmd.AddParameter("Hostname", hfe.Hostname); psCmd.AddParameter("Address", "11.11.11.11"); _powerShell.Commands = psCmd; _powerShell.Invoke(); mySM.MockFileService.Verify(h => h.WriteEntries( It.Is <IEnumerable <HostFileEntry> >(en => en.Any(writeEntry => string.Compare(writeEntry.Hostname, hfe.Hostname) == 0 && string.Compare(writeEntry.Address, "11.11.11.11") == 0)))); // END FUNCTION }
public async Task <List <PSCommandMessage> > Handle(GetCommandParams request, CancellationToken cancellationToken) { PSCommand psCommand = new PSCommand(); // Executes the following: // Get-Command -CommandType Function,Cmdlet,ExternalScript | Select-Object -Property Name,ModuleName | Sort-Object -Property Name psCommand .AddCommand("Microsoft.PowerShell.Core\\Get-Command") .AddParameter("CommandType", new[] { "Function", "Cmdlet", "ExternalScript" }) .AddCommand("Microsoft.PowerShell.Utility\\Select-Object") .AddParameter("Property", new[] { "Name", "ModuleName" }) .AddCommand("Microsoft.PowerShell.Utility\\Sort-Object") .AddParameter("Property", "Name"); IEnumerable <PSObject> result = await _powerShellContextService.ExecuteCommandAsync <PSObject>(psCommand); var commandList = new List <PSCommandMessage>(); if (result != null) { foreach (dynamic command in result) { commandList.Add(new PSCommandMessage { Name = command.Name, ModuleName = command.ModuleName, Parameters = command.Parameters, ParameterSets = command.ParameterSets, DefaultParameterSet = command.DefaultParameterSet }); } } return(commandList); }
void IOrganizationOperation.InvokeOrganizationCmdlet(string organizationId, string cmdlet, bool configOnly) { using (AnchorRunspaceProxy anchorRunspaceProxy = AnchorRunspaceProxy.CreateRunspaceForDatacenterAdmin(this.Context, "upgradehandlers")) { PSCommand pscommand = new PSCommand(); pscommand.AddCommand(cmdlet); pscommand.AddParameter("Identity", organizationId); if (configOnly && cmdlet.Contains("Start-OrganizationUpgrade")) { pscommand.AddParameter("ConfigOnly"); } try { anchorRunspaceProxy.RunPSCommand <PSObject>(pscommand); } catch (MigrationPermanentException ex) { this.Context.Logger.Log(MigrationEventType.Error, "{0} '{1}' failed due to {2}", new object[] { cmdlet, organizationId, ex }); throw; } } }
void IOrganizationOperation.SetTenantUpgradeCapability(string identity, bool tenantUpgradeCapabilityEnabled) { using (AnchorRunspaceProxy anchorRunspaceProxy = AnchorRunspaceProxy.CreateRunspaceForDatacenterAdmin(this.Context, "upgradehandlers")) { PSCommand pscommand = new PSCommand(); pscommand.AddCommand("Set-Mailbox"); pscommand.AddParameter("Identity", identity); pscommand.AddParameter("Arbitration"); pscommand.AddParameter("Force"); pscommand.AddParameter("TenantUpgrade", tenantUpgradeCapabilityEnabled); try { anchorRunspaceProxy.RunPSCommand <Mailbox>(pscommand); } catch (MigrationPermanentException ex) { this.Context.Logger.Log(MigrationEventType.Error, "Unable to set TenantUpgrade capability for '{0}': {1}", new object[] { identity, ex }); throw; } } }
RecipientWrapper IOrganizationOperation.GetUser(string organizationId, string userId) { RecipientWrapper result; using (AnchorRunspaceProxy anchorRunspaceProxy = AnchorRunspaceProxy.CreateRunspaceForDatacenterAdmin(this.Context, "upgradehandlers")) { PSCommand pscommand = new PSCommand(); pscommand.AddCommand("Get-User"); pscommand.AddParameter("Organization", organizationId); pscommand.AddParameter("Identity", userId); User user; try { user = anchorRunspaceProxy.RunPSCommandSingleOrDefault <User>(pscommand); } catch (Exception ex) { this.Context.Logger.Log(MigrationEventType.Error, "MigrationPermanentException from GetUser '{0}'.{1}", new object[] { userId, ex }); if (ex.InnerException is ManagementObjectNotFoundException) { throw new UserNotFoundException(userId, ex.InnerException); } throw; } result = new RecipientWrapper(user); } return(result); }
public async Task <List <PSCommandMessage> > Handle(GetCommandParams request, CancellationToken cancellationToken) { PSCommand psCommand = new PSCommand(); // Executes the following: // Get-Command -CommandType Function,Cmdlet,ExternalScript | Sort-Object -Property Name psCommand .AddCommand("Microsoft.PowerShell.Core\\Get-Command") .AddParameter("CommandType", new[] { "Function", "Cmdlet", "ExternalScript" }) .AddCommand("Microsoft.PowerShell.Utility\\Sort-Object") .AddParameter("Property", "Name"); IEnumerable <CommandInfo> result = await _powerShellContextService.ExecuteCommandAsync <CommandInfo>(psCommand).ConfigureAwait(false); var commandList = new List <PSCommandMessage>(); if (result != null) { foreach (CommandInfo command in result) { // Some info objects have a quicker way to get the DefaultParameterSet. These // are also the most likely to show up so win-win. string defaultParameterSet = null; switch (command) { case CmdletInfo info: defaultParameterSet = info.DefaultParameterSet; break; case FunctionInfo info: defaultParameterSet = info.DefaultParameterSet; break; } if (defaultParameterSet == null) { // Try to get the default ParameterSet if it isn't streamlined (ExternalScriptInfo for example) foreach (CommandParameterSetInfo parameterSetInfo in command.ParameterSets) { if (parameterSetInfo.IsDefault) { defaultParameterSet = parameterSetInfo.Name; break; } } } commandList.Add(new PSCommandMessage { Name = command.Name, ModuleName = command.ModuleName, Parameters = command.Parameters, ParameterSets = command.ParameterSets, DefaultParameterSet = defaultParameterSet }); } } return(commandList); }
private async Task <VariableContainerDetails> FetchVariableContainer( string scope, VariableContainerDetails autoVariables) { PSCommand psCommand = new PSCommand(); psCommand.AddCommand("Get-Variable"); psCommand.AddParameter("Scope", scope); var scopeVariableContainer = new VariableContainerDetails("Scope: " + scope); _variables.Add(scopeVariableContainer); var results = await ExecuteCommand <PSVariable>(psCommand); if (results != null) { foreach (PSVariable psvariable in results) { var variableDetails = new VariableDetails(psvariable); // { Id = this.nextVariableId++ }; _variables.Add(variableDetails); scopeVariableContainer.Children.Add(variableDetails); //.Add(variableDetails.Name, variableDetails); if ((autoVariables != null) && AddToAutoVariables(psvariable, scope)) { autoVariables.Children.Add(variableDetails); //(variableDetails.Name, variableDetails); } } } return(scopeVariableContainer); }
/// <summary> /// Creates a new file or project from a specified template and /// places it in the destination path. This ultimately calls /// Invoke-Plaster in PowerShell. /// </summary> /// <param name="templatePath">The folder path containing the template.</param> /// <param name="destinationPath">The folder path where the files will be created.</param> /// <returns>A boolean-returning Task which communicates success or failure.</returns> public async Task <bool> CreateFromTemplate( string templatePath, string destinationPath) { this.logger.Write( LogLevel.Verbose, $"Invoking Plaster...\n\n TemplatePath: {templatePath}\n DestinationPath: {destinationPath}"); PSCommand command = new PSCommand(); command.AddCommand("Invoke-Plaster"); command.AddParameter("TemplatePath", templatePath); command.AddParameter("DestinationPath", destinationPath); var errorString = new System.Text.StringBuilder(); await this.powerShellContext.ExecuteCommand <PSObject>( command, errorString, new ExecutionOptions { WriteOutputToHost = false, WriteErrorsToHost = true, InterruptCommandPrompt = true }); // If any errors were written out, creation was not successful return(errorString.Length == 0); }
// Token: 0x06000E77 RID: 3703 RVA: 0x00057014 File Offset: 0x00055214 public Collection <PSObject> RunPowershellScript(string scriptFile, Dictionary <string, string> scriptParameters, out Collection <ErrorRecord> errors, IPublicFolderMailboxLoggerBase logger) { errors = null; Command command = new Command(scriptFile, false); if (scriptParameters != null) { foreach (KeyValuePair <string, string> keyValuePair in scriptParameters) { CommandParameter item; if (keyValuePair.Value.ToString().Contains("SwitchValue")) { item = new CommandParameter(keyValuePair.Key, new SwitchParameter(true)); } else { item = new CommandParameter(keyValuePair.Key, keyValuePair.Value); } command.Parameters.Add(item); } } PSCommand pscommand = new PSCommand(); pscommand.AddCommand(command); return(this.RunPSCommand <PSObject>(pscommand, out errors, logger)); }
protected PowerShellResults <O> GetObject <O>(string getCmdlet) { PSCommand pscommand = new PSCommand(); pscommand.AddCommand(getCmdlet); return(this.GetObject <O>(pscommand)); }
static void Main(string[] args) { string uname = Console.ReadLine(); string pwd = Console.ReadLine(); PSCommand psCommand = new PSCommand(); psCommand.AddScript("$PSHome"); PowerShell ps = PowerShell.Create(); ps.Commands = psCommand; Collection <PSObject> results = ps.Invoke(); Console.WriteLine("results length::" + results.Count); foreach (PSObject res in results) { Console.WriteLine("Res val::" + res.ToString()); } Runspace runspace = RunspaceFactory.CreateRunspace(); runspace.Open(); ps.Runspace = runspace; results = ps.Invoke(); Console.WriteLine("results length::" + results.Count); foreach (PSObject res in results) { Console.WriteLine("Res val::" + res.ToString()); } PSCommand rmcommand = new PSCommand(); string exchangeUri = "https://outlook.office365.com/powershell-liveid/"; Uri uri = new Uri(exchangeUri); rmcommand.AddCommand("New-PSSession"); rmcommand.AddParameter("ConfigurationName", "Microsoft.Exchange"); rmcommand.AddParameter("ConnectionUri", uri); SecureString password = new SecureString(); foreach (char c in pwd) { password.AppendChar(c); } PSCredential creds = new PSCredential(uname, password); rmcommand.AddParameter("Credential", creds); rmcommand.AddParameter("Authentication", "Basic"); rmcommand.AddParameter("AllowRedirection"); ps.Commands = rmcommand; Collection <PSObject> result = ps.Invoke(); Console.ReadLine(); }
public void Should_ThrowOnUnknownHostEntry() { _powerShell.Commands.Clear(); var mySM = new MockServiceManager(); ServiceManager.Provider = () => mySM; var hfe = new HostFileEntry() { Address = "127.0.0.2", Hostname = "abc.com" }; mySM.SetupExistingHostList(new[] { hfe }); PSCommand psCmd = new PSCommand(); psCmd.AddCommand("Set-HfHostAddress"); psCmd.AddParameter("Hostname", hfe.Hostname + "aa"); psCmd.AddParameter("Address", hfe.Hostname + "11.11.11.11"); try { _powerShell.Commands = psCmd; _powerShell.Invoke(); } catch (CmdletInvocationException cex) { throw cex.InnerException ?? cex; } // END FUNCTION }
public static void RemoveAllFolderPermissions(string mailbox, string folder) { PSCommand commands = new PSCommand(); if (folder == "\\Top of Information Store") { folder = "\\"; } string folderPath = mailbox + ":" + folder; SwitchParameter noConfirm = new SwitchParameter(); Collection <PSObject> currentPermissions = GetFolderPermissions(mailbox, folder); foreach (PSObject permission in currentPermissions) { if (permission.Properties["User"].Value.ToString() != "Default" && permission.Properties["User"].Value.ToString() != "Anonymous") { commands.Clear(); commands.AddCommand("Remove-MailboxFolderPermission"); commands.AddParameter("Identity", folderPath); commands.AddParameter("User", permission.Properties["User"].Value.ToString()); commands.AddParameter("Confirm", noConfirm); runPowershellCommands(commands); } } }
/// <summary> /// Gets the available file or project templates on the user's /// machine. /// </summary> /// <param name="includeInstalledModules"> /// If true, searches the user's installed PowerShell modules for /// included templates. /// </param> /// <returns>A Task which can be awaited for the TemplateDetails list to be returned.</returns> public async Task <TemplateDetails[]> GetAvailableTemplates( bool includeInstalledModules) { if (!this.isPlasterLoaded) { throw new InvalidOperationException("Plaster is not loaded, templates cannot be accessed."); } ; PSCommand psCommand = new PSCommand(); psCommand.AddCommand("Get-PlasterTemplate"); if (includeInstalledModules) { psCommand.AddParameter("IncludeModules"); } var templateObjects = await this.powerShellContext.ExecuteCommand <PSObject>( psCommand, false, false); this.logger.Write( LogLevel.Verbose, $"Found {templateObjects.Count()} Plaster templates"); return (templateObjects .Select(CreateTemplateDetails) .ToArray()); }
TenantOrganizationPresentationObjectWrapper IOrganizationOperation.GetOrganization(string tenantId) { TenantOrganizationPresentationObjectWrapper result; using (AnchorRunspaceProxy anchorRunspaceProxy = AnchorRunspaceProxy.CreateRunspaceForDatacenterAdmin(this.Context, "upgradehandlers")) { PSCommand pscommand = new PSCommand(); pscommand.AddCommand("Get-Organization"); pscommand.AddParameter("Identity", tenantId); TenantOrganizationPresentationObject tenant = null; try { tenant = anchorRunspaceProxy.RunPSCommandSingleOrDefault <TenantOrganizationPresentationObject>(pscommand); } catch (Exception ex) { this.Context.Logger.Log(MigrationEventType.Error, "MigrationPermanentException from GetOrganization '{0}'.{1}", new object[] { tenantId, ex }); if (ex.InnerException is ManagementObjectNotFoundException) { throw new OrganizationNotFoundException(tenantId, ex); } throw; } result = new TenantOrganizationPresentationObjectWrapper(tenant); } return(result); }
private bool IsSkypeAccountAlreadyExist(string pUserCommonName, Runspace pRunspace, PowerShell pPowerShell, PSCommand pPSCommand) { pPSCommand.AddCommand("Get-CsUser"); pPSCommand.AddParameter("Identity", pUserCommonName); pPowerShell.Commands = pPSCommand; try { pRunspace.Open(); pPowerShell.Runspace = pRunspace; Collection <PSObject> user = pPowerShell.Invoke(); if (user == null || user.Count == 0) { return(false); } else { return(true); } } finally { pRunspace.Dispose(); pRunspace = null; } }
/// <summary> /// Sets the list of breakpoints for the current debugging session. /// </summary> /// <param name="scriptFile">The ScriptFile in which breakpoints will be set.</param> /// <param name="lineNumbers">The line numbers at which breakpoints will be set.</param> /// <param name="clearExisting">If true, causes all existing breakpoints to be cleared before setting new ones.</param> /// <returns>An awaitable Task that will provide details about the breakpoints that were set.</returns> public async Task <BreakpointDetails[]> SetBreakpoints( ScriptFile scriptFile, int[] lineNumbers, bool clearExisting = true) { IEnumerable <Breakpoint> resultBreakpoints = null; if (clearExisting) { await this.ClearBreakpointsInFile(scriptFile); } if (lineNumbers.Length > 0) { PSCommand psCommand = new PSCommand(); psCommand.AddCommand("Set-PSBreakpoint"); psCommand.AddParameter("Script", scriptFile.FilePath); psCommand.AddParameter("Line", lineNumbers.Length > 0 ? lineNumbers : null); resultBreakpoints = await this.powerShellContext.ExecuteCommand <Breakpoint>( psCommand); return (resultBreakpoints .Select(BreakpointDetails.Create) .ToArray()); } return(new BreakpointDetails[0]); }
/// <summary> /// Gets an array of commands that can be run sequentially to set $profile and run the profile commands. /// </summary> /// <param name="shellId">The id identifying the host or shell used in profile file names.</param> /// <param name="useTestProfile">used from test not to overwrite the profile file names from development boxes</param> /// <returns>An array of commands.</returns> internal static PSCommand[] GetProfileCommands(string shellId, bool useTestProfile) { List <PSCommand> commands = new List <PSCommand>(); string allUsersAllHosts = HostUtilities.GetFullProfileFileName(null, false, useTestProfile); string allUsersCurrentHost = HostUtilities.GetFullProfileFileName(shellId, false, useTestProfile); string currentUserAllHosts = HostUtilities.GetFullProfileFileName(null, true, useTestProfile); string currentUserCurrentHost = HostUtilities.GetFullProfileFileName(shellId, true, useTestProfile); PSObject dollarProfile = HostUtilities.GetDollarProfile(allUsersAllHosts, allUsersCurrentHost, currentUserAllHosts, currentUserCurrentHost); PSCommand command = new PSCommand(); command.AddCommand("set-variable"); command.AddParameter("Name", "profile"); command.AddParameter("Value", dollarProfile); command.AddParameter("Option", ScopedItemOptions.None); commands.Add(command); string[] profilePaths = new string[] { allUsersAllHosts, allUsersCurrentHost, currentUserAllHosts, currentUserCurrentHost }; foreach (string profilePath in profilePaths) { if (!System.IO.File.Exists(profilePath)) { continue; } command = new PSCommand(); command.AddCommand(profilePath, false); commands.Add(command); } return(commands.ToArray()); }
private PSCommand RegisterCommand(Match match, PSCommand cmdlet, string cmdletNameGroup, string parameterSetGroup) { cmdlet.AddCommand(new Command(match.Groups[cmdletNameGroup].Value, false, true)); CaptureCollection captures = match.Groups[parameterSetGroup].Captures; string[] array = new string[captures.Count]; for (int i = 0; i < array.Length; i++) { array[i] = captures[i].Value; } int j = 0; while (j < array.Length) { if (j == 0 && !array[j].StartsWith("-")) { cmdlet.AddArgument(array[j]); j++; } else if (j + 1 == array.Length || (j + 1 < array.Length && array[j + 1].StartsWith("-"))) { cmdlet.AddParameter(array[j].Substring(1), true); j++; } else { cmdlet.AddParameter(array[j].Substring(1), this.UnwrapValue(array[j + 1])); j += 2; } } return(cmdlet); }
/// <summary> /// Creates the PSCommand when the runspace is not overridden /// </summary> private PSCommand CreatePsCommandNotOverriden(string line, bool isScript, bool? useNewScope) { PSCommand command = new PSCommand(); if (isScript) { if (useNewScope.HasValue) { command.AddScript(line, useNewScope.Value); } else { command.AddScript(line); } } else { if (useNewScope.HasValue) { command.AddCommand(line, useNewScope.Value); } else { command.AddCommand(line); } } return command; }