public void InvokeCommands(PSCommand[] profileCommands) { WithLock(() => { using (var powerShell = System.Management.Automation.PowerShell.Create()) { powerShell.Runspace = _runspace; foreach (PSCommand command in profileCommands) { powerShell.Commands = command; powerShell.AddCommand("out-default"); powerShell.Invoke(); } } }); }
/// <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]; }
public PSSession Create(string userName, SecureString password, string connectionUri, string schemauri, Action<PSDataStreams> psDataStreamAction) { if (string.IsNullOrEmpty(userName)) { throw new ArgumentOutOfRangeException("userName"); } if (password == null) { throw new ArgumentOutOfRangeException("password"); } if (string.IsNullOrEmpty(connectionUri)) { throw new ArgumentOutOfRangeException("connectionUri"); } this.runspace.SetCredentialVariable(userName, password); var command = new PSCommand(); string importpssessionscript = Constants.SessionScripts.NewPSSessionScriptWithBasicAuth; if (AllowRedirection) importpssessionscript += Constants.SessionScripts.AllowRedirectionInNewPSSession; command.AddScript(string.Format(importpssessionscript, schemauri, connectionUri)); Collection<PSSession> sessions = this.runspace.ExecuteCommand<PSSession>(command, psDataStreamAction); if (sessions.Count > 0) this.runspace.SetRunspaceVariable(Constants.ParameterNameStrings.Session, sessions[0]); return sessions.Count == 0 ? null : sessions[0]; }
/// <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) { // Fix for issue #123 - file paths that contain wildcard chars [ and ] need to // quoted and have those wildcard chars escaped. string escapedScriptPath = PowerShellContext.EscapeWildcardsInPath(scriptFile.FilePath); PSCommand psCommand = new PSCommand(); psCommand.AddCommand("Set-PSBreakpoint"); psCommand.AddParameter("Script", escapedScriptPath); 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]; }
public void disableMailbox(string login) { PowerShell powershell = PowerShell.Create(); powershell.Runspace = getRunspace(); PSCommand command = new PSCommand(); command.AddCommand("Disable-Mailbox"); command.AddParameter("Identity", login); command.AddParameter("Confirm", false); powershell.Commands = command; try { Collection<PSObject> commandResults = powershell.Invoke<PSObject>(); foreach (PSObject result in commandResults) { Console.WriteLine(result.ToString()); } //Form1.myForm.lblStatus.Text = powershell.Streams.Error.ToString(); } catch (Exception e) { Console.WriteLine(e.Message); } finally { powershell.Dispose(); } }
public void assignPhoto(string login, string fileLocation) { using (var context = new PrincipalContext(ContextType.Domain, Form1._Domain, Form1._AdminUser, Form1._Password)) { //Import-RecipientDataProperty -Identity "Scott Carter" -Picture -FileData ([Byte[]]$(Get-Content -Path "C:\StaffPhotos\DJScott1.jpg" -Encoding Byte -ReadCount 0)) PowerShell powershell = PowerShell.Create(); powershell.Runspace = getRunspace(); PSCommand command = new PSCommand(); command.AddScript("Import-RecipientDataProperty -Identity " + '\u0022' + myAD.GetAccountName(login) + '\u0022' + " -Picture -FileData ([Byte[]]$(Get-Content -Path " + '\u0022' + fileLocation + '\u0022' + " -Encoding Byte -ReadCount 0))"); powershell.Commands = command; try { Collection<PSObject> commandResults = powershell.Invoke<PSObject>(); foreach (PSObject result in commandResults) { Form1.myForm.lblExchMessage.Text = result.ToString(); Form1.myForm.lblExchMessage.Visible = true; } } catch (Exception e) { Form1.myForm.lblExchMessage.Text = e.Message; Form1.myForm.lblExchMessage.Visible = true; } finally { powershell.Dispose(); } } }
/// <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></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(); }
public static string ToDebuggerString(SMA.PSCommand command) { if (command.Commands.Count == 0) { return("{}"); } return($"{{{command.Commands[0].CommandText}}}"); }
internal PSCommand(PSCommand commandToClone) { this.commands = new CommandCollection(); foreach (Command command in commandToClone.Commands) { Command item = command.Clone(); this.commands.Add(item); this.currentCommand = item; } }
private async void OnLanguageServiceClientConnectAsync( object sender, ChannelBase serverChannel) { MessageDispatcher messageDispatcher = new MessageDispatcher(this.logger); ProtocolEndpoint protocolEndpoint = new ProtocolEndpoint( serverChannel, messageDispatcher, this.logger); protocolEndpoint.UnhandledException += ProtocolEndpoint_UnhandledException; this.editorSession = CreateSession( this.hostDetails, this.profilePaths, protocolEndpoint, messageDispatcher, this.enableConsoleRepl); this.languageServer = new LanguageServer( this.editorSession, messageDispatcher, protocolEndpoint, this.serverCompletedTask, this.logger); await this.editorSession.PowerShellContext.ImportCommandsModuleAsync( Path.Combine( Path.GetDirectoryName(this.GetType().GetTypeInfo().Assembly.Location), @"..\Commands")); this.languageServer.Start(); // TODO: This can be moved to the point after the $psEditor object // gets initialized when that is done earlier than LanguageServer.Initialize foreach (string module in this.additionalModules) { var command = new System.Management.Automation.PSCommand() .AddCommand("Microsoft.PowerShell.Core\\Import-Module") .AddParameter("Name", module); await this.editorSession.PowerShellContext.ExecuteCommandAsync <System.Management.Automation.PSObject>( command, sendOutputToHost : false, sendErrorToHost : true); } protocolEndpoint.Start(); }
/// <summary> /// Internal copy constructor /// </summary> /// <param name="commandToClone"></param> internal PSCommand(PSCommand commandToClone) { _commands = new CommandCollection(); foreach (Command command in commandToClone.Commands) { Command clone = command.Clone(); // Attach the cloned Command to this instance. _commands.Add(clone); _currentCommand = clone; } }
internal Collection<PSObject> InvokeCommand(PSCommand command, ExchContext context) { if (context == null) { throw new ArgumentNullException("Context", "Parametr not defined. [" + _log.Name + "]"); } PSCredential _credential = GetPSCredential(context); WSManConnectionInfo _connection = new WSManConnectionInfo( new Uri(context.Uri), "http://schemas.microsoft.com/powershell/Microsoft.Exchange", _credential); _connection.AuthenticationMechanism = AuthenticationMechanism.Kerberos; _connection.MaximumConnectionRedirectionCount = 3; _connection.SkipCACheck = true; _connection.SkipCNCheck = true; using (Runspace _runspace = RunspaceFactory.CreateRunspace(_connection)) { _runspace.Open(); //_runspace.SessionStateProxy.SetVariable("ErrorActionPreference", "Continue"); using (PowerShell _powershell = PowerShell.Create()) { _powershell.Commands = command; try { //RunspaceInvoke _invoker = new RunspaceInvoke(_runspace); //Collection<PSObject> _commandResults = _invoker.Invoke(command.ToString()); _powershell.Runspace = _runspace; Collection<PSObject> _commandResults = _powershell.Invoke(); CheckErrors(_powershell.Streams.Error); return _commandResults; //foreach (PSObject _result in _commandResults) //{ // Console.WriteLine(_result.ToString()); //} } catch (Exception ex) { throw new Exception(ex.Message + ". [" + _log.Name + "]"); } } } }
public async Task CanExecutePSCommand() { PSCommand psCommand = new PSCommand(); psCommand.AddScript("$a = \"foo\"; $a"); var executeTask = this.powerShellContext.ExecuteCommand<string>(psCommand); await this.AssertStateChange(PowerShellContextState.Running); await this.AssertStateChange(PowerShellContextState.Ready); var result = await executeTask; Assert.Equal("foo", result.First()); }
/// <summary> /// Gets a specific users mailbox size /// </summary> /// <param name="userGuid"></param> /// <returns></returns> public StatMailboxSizes Get_MailboxSize(Guid userGuid, bool isArchive = false) { PSCommand cmd = new PSCommand(); cmd.AddCommand("Get-MailboxStatistics"); cmd.AddParameter("Identity", userGuid.ToString()); cmd.AddParameter("DomainController", Config.ServiceSettings.PrimaryDC); if (isArchive) cmd.AddParameter("Archive"); _powershell.Commands = cmd; Collection<PSObject> psObjects = _powershell.Invoke(); if (psObjects.Count > 0) { StatMailboxSizes returnSize = new StatMailboxSizes(); foreach (PSObject obj in psObjects) { returnSize.UserGuid = userGuid; returnSize.MailboxDatabase = obj.Members["Database"].Value.ToString(); returnSize.TotalItemSize = obj.Members["TotalItemSize"].Value.ToString(); returnSize.TotalItemSizeInBytes = GetExchangeBytes(returnSize.TotalItemSize); returnSize.TotalDeletedItemSize = obj.Members["TotalDeletedItemSize"].Value.ToString(); returnSize.TotalDeletedItemSizeInBytes = GetExchangeBytes(returnSize.TotalDeletedItemSize); int itemCount = 0; int.TryParse(obj.Members["ItemCount"].Value.ToString(), out itemCount); returnSize.ItemCount = itemCount; int deletedItemCount = 0; int.TryParse(obj.Members["DeletedItemCount"].Value.ToString(), out deletedItemCount); returnSize.DeletedItemCount = deletedItemCount; returnSize.Retrieved = DateTime.Now; break; } return returnSize; } else { if (_powershell.Streams.Error.Count > 0) throw _powershell.Streams.Error[0].Exception; if (_powershell.Streams.Warning.Count > 0) throw new Exception(_powershell.Streams.Warning[0].Message); throw new Exception("No data was returned"); } }
public Guid Get_ExchangeGuid(string identity) { PSCommand cmd = new PSCommand(); cmd.AddCommand("Get-Mailbox"); cmd.AddParameter("Identity", identity); cmd.AddParameter("DomainController", Config.ServiceSettings.PrimaryDC); _powershell.Commands = cmd; Collection<PSObject> psObjects = _powershell.Invoke(); if (_powershell.HadErrors) throw _powershell.Streams.Error[0].Exception; else { var foundUser = psObjects[0]; return Guid.Parse(foundUser.Properties["ExchangeGuid"].Value.ToString()); } }
public void Create(ExchMailbox mailbox) { if (string.IsNullOrEmpty(mailbox.Domain)) { throw new Exception("Mailbox domain not defined. [" + _log.Name + "]"); } ExchContext _context = ExchManager.Instance.Config.GetContext(mailbox.Domain); if(_context == null) { throw new Exception("Exchange context not defined for domain <" + mailbox.Domain + ">. [" + _log.Name + "]"); } mailbox.Context = _context; string _database = ExchManager.Instance.Config.GetDatabase(mailbox); if (string.IsNullOrEmpty(_database)) { throw new Exception("Mailbox database not defined. [" + _log.Name + "]"); } mailbox.Database = _database; PSCommand _command = new PSCommand(); _command.AddCommand("Enable-Mailbox"); _command.AddParameter("Identity", mailbox.Identity); _command.AddParameter("DomainController", mailbox.Context.Pdc); _command.AddParameter("Database", _database); Collection<PSObject> _result = ExchManager.Instance.InvokeCommand(_command, _context); foreach(PSObject _rec in _result) { if (_rec.Properties["PrimarySmtpAddress"] != null) { mailbox.Address = _rec.Properties["PrimarySmtpAddress"].Value.ToString(); } } }
public async Task CanQueueParallelRunspaceRequests() { // Concurrently initiate 4 requests in the session this.powerShellContext.ExecuteScriptString("$x = 100"); Task<RunspaceHandle> handleTask = this.powerShellContext.GetRunspaceHandle(); this.powerShellContext.ExecuteScriptString("$x += 200"); this.powerShellContext.ExecuteScriptString("$x = $x / 100"); PSCommand psCommand = new PSCommand(); psCommand.AddScript("$x"); Task<IEnumerable<int>> resultTask = this.powerShellContext.ExecuteCommand<int>(psCommand); // Wait for the requested runspace handle and then dispose it RunspaceHandle handle = await handleTask; handle.Dispose(); // At this point, the remaining command executions should execute and complete int result = (await resultTask).FirstOrDefault(); // 100 + 200 = 300, then divided by 100 is 3. We are ensuring that // the commands were executed in the sequence they were called. Assert.Equal(3, result); }
public PSModuleInfo ImportPSSession(PSSession session, Action<PSDataStreams> psDataStreamAction) { if (session == null) { throw new ArgumentOutOfRangeException("session"); } var command = new PSCommand(); command.AddCommand(Constants.SessionScripts.ImportPSSession); command.AddParameter(Constants.ParameterNameStrings.Session, session); Collection<PSModuleInfo> modules; try { modules = this.runspace.ExecuteCommand<PSModuleInfo>(command, psDataStreamAction); if (modules.Count > 0) return modules[0]; } catch (Exception) { return null; } return null; }
/// <summary> /// Gets a list of Exchange database names /// </summary> /// <returns></returns> public List<MailboxDatabase> Get_ExchangeDatabases() { PowerShell powershell = null; try { // DEBUG logger.Debug("Retrieving a list of Exchange databases..."); // Start clock Stopwatch stopwatch = Stopwatch.StartNew(); // Run commands powershell = PowerShell.Create(); powershell.Runspace = runspace; // Get Databases PSCommand cmd = new PSCommand(); cmd.AddCommand("Get-MailboxDatabase"); cmd.AddParameter("Status"); cmd.AddParameter("DomainController", this.domainController); powershell.Commands = cmd; // Store what we find in this list so we can return the names of the databases List<MailboxDatabase> databases = new List<MailboxDatabase>(); // When retrieved DateTime when = DateTime.Now; // Now read the returned values Collection<PSObject> foundDatabases = powershell.Invoke(); if (foundDatabases != null) { foreach (PSObject o in foundDatabases) { MailboxDatabase db = new MailboxDatabase(); db.Identity = o.Members["Identity"].Value.ToString(); // DEBUG logger.Debug("Found database " + db.Identity); db.LogFolderPath = o.Members["LogFolderPath"].Value.ToString(); db.EDBFilePath = o.Members["EdbFilePath"].Value.ToString(); db.IsMailboxDatabase = bool.Parse(o.Members["IsMailboxDatabase"].Value.ToString()); db.IsPublicFolderDatabase = bool.Parse(o.Members["IsPublicFolderDatabase"].Value.ToString()); if (o.Members["Server"].Value != null) db.Server = o.Members["Server"].Value.ToString(); if (o.Members["DatabaseSize"].Value != null) { db.DatabaseSize = o.Members["DatabaseSize"].Value.ToString(); // DEBUG logger.Debug("Size of the database is " + o.Members["DatabaseSize"].Value.ToString()); logger.Debug("Size of the database after formatted is " + db.DatabaseSize.ToString()); } db.WhenRetrieved = when; databases.Add(db); } } // Log the powershell commands LogPowershellCommands(ref powershell); // Find all the error if (powershell.HadErrors) { // Log all errors detected foreach (ErrorRecord err in powershell.Streams.Error) { string exception = err.Exception.ToString(); // Log the exception logger.Fatal("Error retrieving mailbox database sizes: " + exception); throw err.Exception; } } // Stop the clock stopwatch.Stop(); // Log the success logger.Info("Successfully retrieved a list of databases from Exchange."); // Return values return databases; } catch (Exception ex) { throw; } finally { if (powershell != null) powershell.Dispose(); } }
/// <summary> /// Gets the calendar name because it can be in a different language /// </summary> /// <param name="userPrincipalName"></param> /// <returns></returns> public string Get_CalendarName(string userPrincipalName) { PowerShell powershell = null; try { // DEBUG // logger.Debug("Getting calendar name for " + userPrincipalName); // Run commands powershell = PowerShell.Create(); powershell.Runspace = runspace; // // First we need to remove the default calendar permissions and add the security group // PSCommand cmd = new PSCommand(); cmd.AddCommand("Get-MailboxFolderStatistics"); cmd.AddParameter("Identity", userPrincipalName); cmd.AddParameter("FolderScope", "Calendar"); cmd.AddParameter("DomainController", this.domainController); powershell.Commands = cmd; // Default calendar name in English string calendarName = "Calendar"; Collection<PSObject> obj = powershell.Invoke(); if (obj != null && obj.Count > 0) { foreach (PSObject ps in obj) { if (ps.Members["FolderType"] != null) { string folderType = ps.Members["FolderType"].Value.ToString(); if (folderType.Equals("Calendar")) { calendarName = ps.Members["Name"].Value.ToString(); break; } } } } return calendarName; } catch (Exception ex) { logger.Error("Error getting calendar name for " + userPrincipalName, ex); // Return the default name return "Calendar"; } finally { if (powershell != null) powershell.Dispose(); } }
private async Task<CommandInfo> GetCommandInfo(string commandName) { PSCommand command = new PSCommand(); command.AddCommand("Get-Command"); command.AddArgument(commandName); var results = await this.powerShellContext.ExecuteCommand<CommandInfo>(command); return results.FirstOrDefault(); }
private async Task HandleExpandAliasRequest( string content, RequestContext<string> requestContext) { var script = @" function __Expand-Alias { param($targetScript) [ref]$errors=$null $tokens = [System.Management.Automation.PsParser]::Tokenize($targetScript, $errors).Where({$_.type -eq 'command'}) | Sort Start -Descending foreach ($token in $tokens) { $definition=(Get-Command ('`'+$token.Content) -CommandType Alias -ErrorAction SilentlyContinue).Definition if($definition) { $lhs=$targetScript.Substring(0, $token.Start) $rhs=$targetScript.Substring($token.Start + $token.Length) $targetScript=$lhs + $definition + $rhs } } $targetScript }"; var psCommand = new PSCommand(); psCommand.AddScript(script); await this.editorSession.PowerShellContext.ExecuteCommand<PSObject>(psCommand); psCommand = new PSCommand(); psCommand.AddCommand("__Expand-Alias").AddArgument(content); var result = await this.editorSession.PowerShellContext.ExecuteCommand<string>(psCommand); await requestContext.SendResult(result.First().ToString()); }
protected async Task HandleShowOnlineHelpRequest( string helpParams, RequestContext<object> requestContext) { if (helpParams == null) { helpParams = "get-help"; } var psCommand = new PSCommand(); psCommand.AddCommand("Get-Help"); psCommand.AddArgument(helpParams); psCommand.AddParameter("Online"); await editorSession.PowerShellContext.ExecuteCommand<object>( psCommand); await requestContext.SendResult(null); }
public void NewMailbox(UsersObject user) { try { this.logger.Debug("Creating new mailbox for "+ user.UserPrincipalName); PSCommand cmd = new PSCommand(); cmd.AddCommand("Enable-Mailbox"); cmd.AddParameter("Identity", user.UserPrincipalName); cmd.AddParameter("PrimarySmtpAddress", user.PrimarySmtpAddress); cmd.AddParameter("AddressBookPolicy", user.CompanyCode + " ABP"); this.logger.Debug("Checking activesync policy for " + user.UserPrincipalName); if (!string.IsNullOrEmpty(user.ActiveSyncName)) cmd.AddParameter("ActiveSyncMailboxPolicy", user.ActiveSyncName); this.logger.Debug("Checking if we are putting this new mailbox in a specific database " + user.UserPrincipalName); if (!string.IsNullOrEmpty(user.CurrentMailboxDatabase)) cmd.AddParameter("Database", user.CurrentMailboxDatabase); cmd.AddParameter("Confirm", false); cmd.AddParameter("DomainController", domainController); powershell.Commands = cmd; this.logger.Debug("Invoking powershell to create new mailbox for " + user.UserPrincipalName); powershell.Invoke(); if (powershell.HadErrors) throw powershell.Streams.Error[0].Exception; } catch (Exception ex) { this.logger.Error("Failed to create new mailbox for " + user.UserPrincipalName, ex); throw; } }
public static void SetPowerShellInstance(PowerShell instance) { PowerShellAgent.PowerShellInstance = instance; PowerShellAgent.InitCommand = instance.Commands; }
internal void StartPowerShellCommand( PowerShell powershell, Guid powershellId, Guid runspacePoolId, ServerRunspacePoolDriver runspacePoolDriver, #if !CORECLR // No ApartmentState In CoreCLR ApartmentState apartmentState, #endif ServerRemoteHost remoteHost, HostInfo hostInfo, RemoteStreamOptions streamOptions, bool addToHistory) { // For nested debugger command processing, invoke command on new local runspace since // the root script debugger runspace is unavailable (it is running a PS script or a // workflow function script). Runspace runspace = (remoteHost != null) ? RunspaceFactory.CreateRunspace(remoteHost) : RunspaceFactory.CreateRunspace(); runspace.Open(); try { powershell.InvocationStateChanged += HandlePowerShellInvocationStateChanged; powershell.SetIsNested(false); string script = @" param ($Debugger, $Commands, $output) trap { throw $_ } $Debugger.ProcessCommand($Commands, $output) "; PSDataCollection<PSObject> output = new PSDataCollection<PSObject>(); PSCommand Commands = new PSCommand(powershell.Commands); powershell.Commands.Clear(); powershell.AddScript(script).AddParameter("Debugger", this).AddParameter("Commands", Commands).AddParameter("output", output); ServerPowerShellDriver driver = new ServerPowerShellDriver( powershell, null, true, powershellId, runspacePoolId, runspacePoolDriver, #if !CORECLR // No ApartmentState In CoreCLR apartmentState, #endif hostInfo, streamOptions, addToHistory, runspace, output); driver.Start(); } catch (Exception e) { CommandProcessorBase.CheckForSevereException(e); runspace.Close(); runspace.Dispose(); } }
private PowerShell() { psCommand = new PSCommand(); dataStreams = new PSDataStreams(this); }
public ThreadCommandProcessing( PSCommand command, PSDataCollection<PSObject> output, Debugger debugger, ManualResetEventSlim processCommandCompleteEvent) { _command = command; _output = output; _wrappedDebugger = debugger; _commandCompleteEvent = processCommandCompleteEvent; }
/// <summary> /// ProcessCommand /// </summary> /// <param name="command">Command</param> /// <param name="output">Output</param> /// <returns></returns> public override DebuggerCommandResults ProcessCommand(PSCommand command, PSDataCollection<PSObject> output) { if (LocalDebugMode) { return _wrappedDebugger.Value.ProcessCommand(command, output); } if (!InBreakpoint || (_threadCommandProcessing != null)) { throw new PSInvalidOperationException( StringUtil.Format(DebuggerStrings.CannotProcessDebuggerCommandNotStopped)); } if (_processCommandCompleteEvent == null) { _processCommandCompleteEvent = new ManualResetEventSlim(false); } _threadCommandProcessing = new ThreadCommandProcessing(command, output, _wrappedDebugger.Value, _processCommandCompleteEvent); try { return _threadCommandProcessing.Invoke(_nestedDebugStopCompleteEvent); } finally { _threadCommandProcessing = null; } }
/// <summary> /// Pre-processor for debugger commands. /// Parses special debugger commands and converts to equivalent script for remote execution as needed. /// </summary> /// <param name="commands">PSCommand</param> /// <param name="isDebuggerActive">True if debugger is active.</param> /// <param name="isDebuggerRemote">True if active debugger is pushed and is a remote debugger.</param> /// <param name="commandArgument">Command argument.</param> /// <returns>PreProcessCommandResult type if preprocessing occurred.</returns> private static PreProcessCommandResult PreProcessDebuggerCommand( PSCommand commands, bool isDebuggerActive, bool isDebuggerRemote, out DebuggerCommandArgument commandArgument) { commandArgument = new DebuggerCommandArgument(); PreProcessCommandResult result = PreProcessCommandResult.None; if ((commands.Commands.Count == 0) || (commands.Commands[0].IsScript)) { return result; } var command = commands.Commands[0]; string commandText = command.CommandText; if (commandText.Equals(DebuggerUtils.GetDebuggerStopArgsFunctionName, StringComparison.OrdinalIgnoreCase)) { // // __Get-PSDebuggerStopArgs private virtual command. // No input parameters. // Returns DebuggerStopEventArgs object. // // Evaluate this command only if the debugger is activated. if (!isDebuggerActive) { return PreProcessCommandResult.ValidNotProcessed; } // Translate into debugger method call. ScriptBlock scriptBlock = ScriptBlock.Create("$host.Runspace.Debugger.GetDebuggerStopArgs()"); scriptBlock.LanguageMode = PSLanguageMode.FullLanguage; commands.Clear(); commands.AddCommand("Invoke-Command").AddParameter("ScriptBlock", scriptBlock).AddParameter("NoNewScope", true); result = PreProcessCommandResult.GetDebuggerStopArgs; } else if (commandText.Equals(DebuggerUtils.SetDebuggerActionFunctionName, StringComparison.OrdinalIgnoreCase)) { // // __Set-PSDebuggerAction private virtual command. // DebuggerResumeAction enum input parameter. // Returns void. // // Evaluate this command only if the debugger is activated. if (!isDebuggerActive) { return PreProcessCommandResult.ValidNotProcessed; } if ((command.Parameters == null) || (command.Parameters.Count == 0) || (!command.Parameters[0].Name.Equals("ResumeAction", StringComparison.OrdinalIgnoreCase))) { throw new PSArgumentException("ResumeAction"); } DebuggerResumeAction? resumeAction = null; PSObject resumeObject = command.Parameters[0].Value as PSObject; if (resumeObject != null) { try { resumeAction = (DebuggerResumeAction)resumeObject.BaseObject; } catch (InvalidCastException) { } } if (resumeAction == null) { throw new PSArgumentException("ResumeAction"); } commandArgument.ResumeAction = resumeAction; result = PreProcessCommandResult.SetDebuggerAction; } else if (commandText.Equals(DebuggerUtils.SetDebugModeFunctionName, StringComparison.OrdinalIgnoreCase)) { // // __Set-PSDebugMode private virtual command. // DebugModes enum input parameter. // Returns void. // if ((command.Parameters == null) || (command.Parameters.Count == 0) || (!command.Parameters[0].Name.Equals("Mode", StringComparison.OrdinalIgnoreCase))) { throw new PSArgumentException("Mode"); } DebugModes? mode = null; PSObject modeObject = command.Parameters[0].Value as PSObject; if (modeObject != null) { try { mode = (DebugModes)modeObject.BaseObject; } catch (InvalidCastException) { } } if (mode == null) { throw new PSArgumentException("Mode"); } commandArgument.Mode = mode; result = PreProcessCommandResult.SetDebugMode; } else if (commandText.Equals(DebuggerUtils.SetDebuggerStepMode, StringComparison.OrdinalIgnoreCase)) { // // __Set-PSDebuggerStepMode private virtual command. // Boolean Enabled input parameter. // Returns void. // if ((command.Parameters == null) || (command.Parameters.Count == 0) || (!command.Parameters[0].Name.Equals("Enabled", StringComparison.OrdinalIgnoreCase))) { throw new PSArgumentException("Enabled"); } bool enabled = (bool)command.Parameters[0].Value; commandArgument.DebuggerStepEnabled = enabled; result = PreProcessCommandResult.SetDebuggerStepMode; } else if (commandText.Equals(DebuggerUtils.SetPSUnhandledBreakpointMode, StringComparison.OrdinalIgnoreCase)) { // // __Set-PSUnhandledBreakpointMode private virtual command. // UnhandledBreakpointMode input parameter. // Returns void. // if ((command.Parameters == null) || (command.Parameters.Count == 0) || (!command.Parameters[0].Name.Equals("UnhandledBreakpointMode", StringComparison.OrdinalIgnoreCase))) { throw new PSArgumentException("UnhandledBreakpointMode"); } UnhandledBreakpointProcessingMode? mode = null; PSObject modeObject = command.Parameters[0].Value as PSObject; if (modeObject != null) { try { mode = (UnhandledBreakpointProcessingMode)modeObject.BaseObject; } catch (InvalidCastException) { } } if (mode == null) { throw new PSArgumentException("Mode"); } commandArgument.UnhandledBreakpointMode = mode; result = PreProcessCommandResult.SetPreserveUnhandledBreakpointMode; } return result; }
/// <summary> /// Gets a list of mailbox sizes Exchange /// </summary> /// <returns></returns> public List<MailboxUser> Get_MailboxSizes() { PowerShell powershell = null; try { // DEBUG logger.Debug("Retrieving a list of mailbox users from the SQL database..."); // Start clock Stopwatch stopwatch = Stopwatch.StartNew(); // Get a list of users from the database List<ADUser> allUsers = DbSql.Get_Users(); // Our return object of information List<MailboxUser> users = new List<MailboxUser>(); // Now loop through the databases and query the information foreach (ADUser user in allUsers) { if (user.MailboxPlanID > 0) { // DEBUG logger.Debug("Retrieving mailbox statistics for user " + user); // Our MailboxUser object to store this users information MailboxUser currentUser = new MailboxUser(); try { // Run commands powershell = PowerShell.Create(); powershell.Runspace = runspace; // Get Databases PSCommand cmd = new PSCommand(); cmd.AddCommand("Get-MailboxStatistics"); cmd.AddParameter("Identity", user.UserPrincipalName); cmd.AddParameter("DomainController", this.domainController); powershell.Commands = cmd; // Now read the returned values Collection<PSObject> foundStatistics = powershell.Invoke(); foreach (PSObject o in foundStatistics) { currentUser.UserPrincipalName = user.UserPrincipalName; currentUser.ItemCount = int.Parse(o.Members["ItemCount"].Value.ToString(), CultureInfo.InvariantCulture); currentUser.DeletedItemCount = int.Parse(o.Members["DeletedItemCount"].Value.ToString(), CultureInfo.InvariantCulture); currentUser.TotalItemSize = o.Members["TotalItemSize"].Value.ToString(); currentUser.TotalDeletedItemSize = o.Members["TotalDeletedItemSize"].Value.ToString(); currentUser.Database = o.Members["Database"].Value.ToString(); currentUser.MailboxDataRetrieved = DateTime.Now; } // Log the powershell commands LogPowershellCommands(ref powershell); // Find all the errors if (powershell.HadErrors) { // Log all errors detected foreach (ErrorRecord err in powershell.Streams.Error) { logger.Error("Error getting mailbox size for " + user, err.Exception); // Compile message StringBuilder sb = new StringBuilder(); sb.AppendLine("Failed to get mailbox size for: " + user); sb.AppendLine(""); sb.AppendLine("Recommended Action:"); sb.AppendLine("This could be because the user no longer exists in Active Directory but still exists in the database."); sb.AppendLine("If that is the case simply delete the user from CloudPanel. If the issues stays the same please contact support."); sb.AppendLine(""); sb.AppendLine("Error:"); sb.AppendLine(err.Exception.ToString()); // Send message Support.SendEmailMessage("Failed to get mailbox size for: " + user, sb.ToString()); } // Log all warnings detected foreach (WarningRecord err in powershell.Streams.Warning) { logger.Error("Warning getting mailbox size for " + user + ": " + err.Message); } } else { logger.Info("Successfully retrieved mailbox size information for " + currentUser.UserPrincipalName); users.Add(currentUser); } } catch (Exception ex) { logger.Fatal("Failed to retrieve mailbox size for " + user, ex); } } } // Stop the clock stopwatch.Stop(); // Log the success logger.Info("Successfully retrieved a complete list of mailbox sizes from Exchange."); // Return values return users; } catch (Exception ex) { throw; } finally { if (powershell != null) powershell.Dispose(); } }
private PSCommand CreatePsCommandNotOverriden(string line, bool isScript, bool? useNewScope) { PSCommand command = new PSCommand(); if (isScript) { if (useNewScope.HasValue) { command.AddScript(line, useNewScope.Value); return command; } command.AddScript(line); return command; } if (useNewScope.HasValue) { command.AddCommand(line, useNewScope.Value); return command; } command.AddCommand(line); return command; }
/// <summary> /// Sets the mailbox default calendar permissions by removing the default and adding their company's ExchangeSecurity group to the AvailabilityOnly /// </summary> /// <param name="userPrincipalName"></param> /// <param name="companyCode"></param> public void Set_MailboxCalendarPermission(string userPrincipalName, string companyCode) { PowerShell powershell = null; try { // Strip whitespace from company code companyCode = companyCode.Replace(" ", string.Empty); // DEBUG logger.Debug("Removing default permissions for mailbox calendar and adding correct permissions for user " + userPrincipalName); // Start clock Stopwatch stopwatch = Stopwatch.StartNew(); // Run commands powershell = PowerShell.Create(); powershell.Runspace = runspace; // Enable the mailbox PSCommand cmd = new PSCommand(); // Get the calendar name string calendarName = Get_CalendarName(userPrincipalName); // Remove default calendar permissions cmd.AddCommand("Set-MailboxFolderPermission"); cmd.AddParameter("Identity", string.Format(@"{0}:\{1}", userPrincipalName, calendarName)); cmd.AddParameter("User", "Default"); cmd.AddParameter("AccessRights", "None"); cmd.AddParameter("DomainController", this.domainController); // Add calendar permissions for the group cmd.AddStatement(); cmd.AddCommand("Add-MailboxFolderPermission"); cmd.AddParameter("Identity", string.Format(@"{0}:\{1}", userPrincipalName, calendarName)); cmd.AddParameter("User", "ExchangeSecurity@" + companyCode); cmd.AddParameter("AccessRights", "AvailabilityOnly"); cmd.AddParameter("DomainController", this.domainController); powershell.Commands = cmd; powershell.Invoke(); // Log the powershell commands LogPowershellCommands(ref powershell); // Find all the error if (powershell.HadErrors) { // Log all warning detected foreach (WarningRecord warn in powershell.Streams.Warning) { string warnMessage = warn.Message; if (!warnMessage.Contains("completed successfully but no permissions")) logger.Warn("Warning was generated running the command to modify the mailbox permissions for " + userPrincipalName + ": " + warnMessage); } // Log all errors detected foreach (ErrorRecord err in powershell.Streams.Error) { string exception = err.Exception.ToString(); if (exception.Contains("An existing permission entry was found for user")) logger.Info("Attempted to modify permission on " + userPrincipalName + " but the permission already existed."); else throw err.Exception; } } // Stop the clock stopwatch.Stop(); // Log the success logger.Info("Successfully modified calendar permissions for " + userPrincipalName); } catch (Exception ex) { throw; } finally { if (powershell != null) powershell.Dispose(); } }
internal BatchInvocationContext(PSCommand command, PSDataCollection <PSObject> output) { this.command = command; this.output = output; this.completionEvent = new AutoResetEvent(false); }