private Command() { Parameters = new CommandParameterCollection(); MergeMyResult = PipelineResultTypes.None; MergeToResult = PipelineResultTypes.None; ScriptBlockAst = null; }
public JobInvocationInfo(JobDefinition definition, CommandParameterCollection parameters) { this._name = string.Empty; this._instanceId = Guid.NewGuid(); this._definition = definition; this.Parameters.Add(parameters ?? new CommandParameterCollection()); }
public Command(string command, bool isScript, bool useLocalScope) { CommandText = command; IsScript = isScript; UseLocalScope = useLocalScope; Parameters = new CommandParameterCollection(); MergeMyResult = PipelineResultTypes.None; MergeToResult = PipelineResultTypes.None; }
internal Command(System.Management.Automation.CommandInfo commandInfo, bool isScript) { this._mergeInstructions = new PipelineResultTypes[4]; this._parameters = new CommandParameterCollection(); this._command = string.Empty; this._commandInfo = commandInfo; this._command = this._commandInfo.Name; this._isScript = isScript; }
/// <summary> /// Binds the parameters from the command line to the command. /// </summary> /// <remarks> /// All abount Cmdlet parameters: http://msdn2.microsoft.com/en-us/library/ms714433(VS.85).aspx /// About the lifecycle: http://msdn.microsoft.com/en-us/library/ms714429(v=vs.85).aspx /// </remarks> public void BindCommandLineParameters(CommandParameterCollection parameters) { // How command line parameters are bound: // In general: We will bind first named parameters, then positionals, and then maybe gather some. // While parameters are being bound, a list of _candidateParameterSets is maintained that keeps track // of those sets that are eligible for being taken. // As we might have an early choice that can be handled, an _activeSet is maintained in addition. // The _candidateSet will be restricted to the _activeSet if we found one early // Check if one obvious choice for a parameter set to be chosen (e.g. if there is only one) _activeSet = SelectObviousActiveParameterSet(); // Bind all named parameters, fail if some name is bound twice or if the selection is already ambiguos parameters = BindNamedParameters(parameters); // Bind positional parameters per parameter set // To do so, sort parameters of set by position, ignore bound parameters and set the first unbound position // Note: if we don't know the active parameter set, yet, we will bind it by Default, this is PS behavior // Binding will also restrict the candidate set and check for ambiguity parameters = BindPositionalParameters(parameters, ActiveOrDefaultParameterSet); // Bind dynamic parameters based on what's already bound. // TODO: this is also the place to support ShouldProcess parameters = BindDynamicParameters(parameters); // Make sure that there are no parameters that couldn't be bound ValidateAllParametersBound(parameters); // There might be parameter sets with parameters that are still unbound but will be set by pipeline. // If not, and if we have an (active or default) parameter set that is still a candidate, then get the // missing parameters. if (!HasParameterSetsWithUnboundMandatoryPipelineParameters() && _candidateParameterSets.Contains(ActiveOrDefaultParameterSet)) { HandleMissingMandatoryParameters(ActiveOrDefaultParameterSet, false, true); } // We finished binding parameters without pipeline. Therefore we can restrict the candidate set to those // sets that have all mandatory parameters set or are able to set them by pipeline RestrictCandidatesByBoundParameter(false); // Check if we have unbound parameters that can be set by pipeline. If not and we can already do // our final choice (and throw an error on problems) if (!HasUnboundPipelineParameters()) { DoFinalChoiceOfParameterSet(); } // Back up the bound parameters BackupCommandLineParameterValues(); // For the beginning phase: Tell the cmdlet which parameter set is likely to be used (if we know it) // If there is only one candidate, use it at least temporarily. Otherwise the active or default SetCmdletParameterSetName(_candidateParameterSets.Count == 1 ? _candidateParameterSets[0] : ActiveOrDefaultParameterSet); }
public void BindingParameterAlias() { var parameters = new CommandParameterCollection { { "Path", "a path" } }; _binder.BindCommandLineParameters(parameters); Assert.AreEqual("a path", _cmdlet.FilePath.ToString()); }
public void BindingFieldAlias() { var parameters = new CommandParameterCollection { { "fn", "John" }, { "Variable", "foo" } // mandatory }; _binder.BindCommandLineParameters(parameters); Assert.AreEqual("John", _cmdlet.Name); }
public void BindingParameterByPipeline() { var parameters = new CommandParameterCollection { { "Variable", "foo" } // mandatory }; _binder.BindCommandLineParameters(parameters); _binder.BindPipelineParameters(10, true); Assert.AreEqual("10", _cmdlet.InputObject.ToString()); }
public void BindingCombinationNonDefaultSet() { var parameters = new CommandParameterCollection { { "Variable", "a" }, { "Recurse", null } }; _binder.BindCommandLineParameters(parameters); Assert.AreEqual("a", _cmdlet.Variable); Assert.IsTrue(_cmdlet.Recurse.ToBool()); }
public JobInvocationInfo(JobDefinition definition, Dictionary <string, object> parameters) { this._name = string.Empty; this._instanceId = Guid.NewGuid(); this._definition = definition; CommandParameterCollection item = ConvertDictionaryToParameterCollection(parameters); if (item != null) { this.Parameters.Add(item); } }
public void BindingCombinationNonDefaultSet() { var parameters = new CommandParameterCollection { { "Variable", "a" }, { "Recurse", null } }; _binder.BindCommandLineParameters(parameters); Assert.AreEqual("a", _cmdlet.Variable); Assert.IsTrue(_cmdlet.Recurse.ToBool()); }
public void BindingNonSwitch() { var parameters = new CommandParameterCollection { { "Name", "John" }, { "Variable", "foo" } }; _binder.BindCommandLineParameters(parameters); Assert.AreEqual("John", _cmdlet.Name); Assert.IsFalse(_cmdlet.Recurse.ToBool()); }
public IEnumerable <PSObject> RunCmdlet(string command, CommandParameterCollection parameters, bool throwExceptionOnError = true) { if (this.cmdletValidator.Validate(command, parameters)) { return(this.ExecuteCmdlet(command, parameters, throwExceptionOnError)); } if (throwExceptionOnError) { throw new CmdletExecutionException(string.Format("Command passed {0} failed validation", command)); } return(new List <PSObject>()); }
public void BindingParameterSetSelectionDoubleShouldFail() { var parameters = new CommandParameterCollection { { "Variable", "test" }, { "FilePath", "a path" } }; Assert.Throws(typeof(ParameterBindingException), delegate() { _binder.BindCommandLineParameters(parameters); }); }
public void BindingParameterTwiceShouldFail() { var parameters = new CommandParameterCollection { { "Variable", "foo" }, { "Variable", "bar" } }; Assert.Throws(typeof(ParameterBindingException), delegate() { _binder.BindCommandLineParameters(parameters); }); }
private Job StartJobCommand(System.Management.Automation.PowerShell powerShell) { Job job = null; // Use PowerShell Start-Job cmdlet to run job. powerShell.AddCommand("Start-Job"); powerShell.AddParameter("Name", _jobDefinition.Name); // Add job parameters from the JobInvocationInfo object. CommandParameterCollection parameters = _jobDefinition.InvocationInfo.Parameters[0]; foreach (CommandParameter parameter in parameters) { switch (parameter.Name) { case "ScriptBlock": powerShell.AddParameter("ScriptBlock", parameter.Value as ScriptBlock); break; case "FilePath": powerShell.AddParameter("FilePath", parameter.Value as string); break; case "RunAs32": powerShell.AddParameter("RunAs32", (bool)parameter.Value); break; case "Authentication": powerShell.AddParameter("Authentication", (AuthenticationMechanism)parameter.Value); break; case "InitializationScript": powerShell.AddParameter("InitializationScript", parameter.Value as ScriptBlock); break; case "ArgumentList": powerShell.AddParameter("ArgumentList", parameter.Value as object[]); break; } } // Start the job. Collection <PSObject> rtn = powerShell.Invoke(); if (rtn != null && rtn.Count == 1) { job = rtn[0].BaseObject as Job; } return(job); }
public Command(string command, bool isScript, bool useLocalScope) { this._mergeInstructions = new PipelineResultTypes[4]; this._parameters = new CommandParameterCollection(); this._command = string.Empty; if (command == null) { throw PSTraceSource.NewArgumentNullException("command"); } this._command = command; this._isScript = isScript; this._useLocalScope = new bool?(useLocalScope); }
private void DeserializeInvocationInfo(SerializationInfo info) { string str = info.GetString("InvocationInfo_Command"); string str1 = info.GetString("InvocationInfo_Name"); string str2 = info.GetString("InvocationInfo_ModuleName"); string str3 = info.GetString("InvocationInfo_AdapterTypeName"); Dictionary <string, object> strs = new Dictionary <string, object>(); string str4 = info.GetString("InvocationParam_ScriptBlock"); if (str4 != null) { strs.Add("ScriptBlock", ScriptBlock.Create(str4)); } string str5 = info.GetString("InvocationParam_FilePath"); if (!string.IsNullOrEmpty(str5)) { strs.Add("FilePath", str5); } str4 = info.GetString("InvocationParam_InitScript"); if (!string.IsNullOrEmpty(str4)) { strs.Add("InitializationScript", ScriptBlock.Create(str4)); } bool flag = info.GetBoolean("InvocationParam_RunAs32"); strs.Add("RunAs32", flag); AuthenticationMechanism value = (AuthenticationMechanism)info.GetValue("InvocationParam_Authentication", typeof(AuthenticationMechanism)); strs.Add("Authentication", value); object[] objArray = (object[])info.GetValue("InvocationParam_ArgList", typeof(object[])); if (objArray != null) { strs.Add("ArgumentList", objArray); } JobDefinition jobDefinition = new JobDefinition(null, str, str1); jobDefinition.ModuleName = str2; jobDefinition.JobSourceAdapterTypeName = str3; CommandParameterCollection commandParameterCollection = new CommandParameterCollection(); foreach (KeyValuePair <string, object> keyValuePair in strs) { CommandParameter commandParameter = new CommandParameter(keyValuePair.Key, keyValuePair.Value); commandParameterCollection.Add(commandParameter); } base.Definition = jobDefinition; base.Name = str1; base.Command = str; base.Parameters.Add(commandParameterCollection); }
/// <summary> /// Creates a new migration endpoint in Exchange Online. /// </summary> /// <param name="entity">An instance of <see cref="EnvironmentEntity"/> that represents the new migration endpoint.</param> /// <returns>An instance of <see cref="Task"/> that represents the asynchronous operation.</returns> /// <exception cref="ArgumentNullException"> /// <paramref name="entity"/> is null. /// </exception> /// <exception cref="ArgumentNullException"> /// <paramref name="entity"/> is null. /// </exception> public async Task CreateMigrationEndpointAsync(EnvironmentEntity entity) { Command command; CommandParameterCollection parameters; PSCredential credential; PSCredential onPermiseCredential; Uri connectionUri; WSManConnectionInfo connectionInfo; string onPermisePassword; entity.AssertNotNull(nameof(entity)); try { credential = new PSCredential( service.Configuration.ExchangeOnlineUsername, service.Configuration.ExchangeOnlinePassword.ToSecureString()); onPermisePassword = await service.Vault.GetAsync(entity.Password); onPermiseCredential = new PSCredential(entity.Username, onPermisePassword.ToSecureString()); connectionUri = new Uri($"{MigrationConstants.ExchangeOnlineEndpoint}{entity.Organization}"); connectionInfo = GetConnectionInfo(connectionUri, MigrationConstants.SchemaUri, credential); command = new Command("New-MigrationEndpoint"); parameters = new CommandParameterCollection { { "Autodiscover" }, { "Credentials", onPermiseCredential }, { "EmailAddress", entity.Username }, { "ExchangeRemoteMove" }, { "Name", entity.Name } }; using (Runspace runspace = RunspaceFactory.CreateRunspace(connectionInfo)) { scriptManager.InvokeCommand(runspace, command, parameters); } } finally { command = null; connectionInfo = null; connectionUri = null; credential = null; onPermiseCredential = null; parameters = null; } }
public void BindingCombinationAllSet(string mandatory) { var parameters = new CommandParameterCollection { { "Name", "John" }, { "Recurse", null }, { mandatory, "foo" } // chooses the parameter set }; _binder.BindCommandLineParameters(parameters); // as the values are in both sets, it should be always set Assert.AreEqual("John", _cmdlet.Name); Assert.IsTrue(_cmdlet.Recurse.ToBool()); }
private static CommandParameterCollection ConvertDictionaryToParameterCollection(IEnumerable <KeyValuePair <string, object> > parameters) { if (parameters == null) { return(null); } CommandParameterCollection parameters2 = new CommandParameterCollection(); foreach (CommandParameter parameter in from param in parameters select new CommandParameter(param.Key, param.Value)) { parameters2.Add(parameter); } return(parameters2); }
public void BindingParameterByPositionAfterSetSelection() { var varname = "foo"; var parameters = new CommandParameterCollection { { "ConstVar", null }, // switch parameter, should select "Variable" set { null, varname } }; _binder.BindCommandLineParameters(parameters); Assert.IsTrue(_cmdlet.ConstVar.ToBool()); Assert.AreEqual(varname, _cmdlet.Variable); Assert.AreEqual("Variable", _cmdlet.ParameterSetName); }
public void BindingParameterByPositionSelectsDefaultParameterSetIncomplete() { var name = "foo"; var parameters = new CommandParameterCollection { { null, name } }; var ex = Assert.Throws(typeof(ParameterBindingException), delegate() { _binder.BindCommandLineParameters(parameters); }); StringAssert.Contains("FilePath", ex.Message); // should complain that no "FilePath" was provided }
public void BindingCombinationAllSet(string mandatory) { var parameters = new CommandParameterCollection { { "Name", "John" }, { "Recurse", null }, { mandatory, "foo" } // chooses the parameter set }; _binder.BindCommandLineParameters(parameters); // as the values are in both sets, it should be always set Assert.AreEqual("John", _cmdlet.Name); Assert.IsTrue(_cmdlet.Recurse.ToBool()); }
public void ThrowExceptionWhenParameterIsNullAndDataTypeIsNotSetInStoredProcedure() { var parameters = new CommandParameterCollection { { "@Param1", 1 }, { "@Param2", null } }; using (SqlServerTestHelper helper = CreateHelper((string)null)) { QueryProvider provider = CreateQueryProvider(helper.Connection); Action executeStoredProcedure = () => provider.ExecuteStoredProcedure <int>("NoProcedure", parameters); executeStoredProcedure.Should().Throw <ArgumentException>().WithMessage("*@Param2*"); } }
/// <summary> /// Utility function to turn a dictionary of name/value pairs into a parameter collection /// </summary> /// <param name="parameters">The dictionary to convert</param> /// <returns>The converted collection</returns> private static CommandParameterCollection ConvertDictionaryToParameterCollection(IEnumerable <KeyValuePair <string, object> > parameters) { if (parameters == null) { return(null); } CommandParameterCollection paramCollection = new CommandParameterCollection(); foreach (CommandParameter paramItem in parameters.Select(param => new CommandParameter(param.Key, param.Value))) { paramCollection.Add(paramItem); } return(paramCollection); }
public void BindingParameterByPositionSelectsDefaultParameterSet() { var name = "foo"; var path = "a path"; var parameters = new CommandParameterCollection { { null, name }, { null, path } }; _binder.BindCommandLineParameters(parameters); Assert.AreEqual(path, _cmdlet.FilePath); Assert.AreEqual(name, _cmdlet.Name); Assert.AreEqual("File", _cmdlet.ParameterSetName); }
private void BindNamedParameters(CommandParameterCollection parameters) { var namedParameters = from parameter in parameters where !String.IsNullOrEmpty(parameter.Name) select parameter; foreach (var curParam in namedParameters) { string curName = curParam.Name; // try to get the parameter from any set. throws an error if the name is ambiguous or doesn't exist var paramInfo = _cmdletInfo.LookupParameter(curName); BindParameter(paramInfo, curParam.Value, true); } }
/// <summary> /// Starts the migration batch in Exchange Online. /// </summary> /// <param name="entity">An instance of <see cref="MigrationBatchEntity"/> that represents the migration batch to start.</param> /// <returns>An instance of <see cref="Task"/> that represents the asynchronous operation.</returns> /// <exception cref="ArgumentNullException"> /// <paramref name="entity"/> is null. /// </exception> public async Task MigrationBatchStartAsync(MigrationBatchEntity entity) { Command command; CommandParameterCollection parameters; EnvironmentEntity environment; PSCredential credential; Uri connectionUri; WSManConnectionInfo connectionInfo; entity.AssertNotNull(nameof(entity)); try { credential = new PSCredential( service.Configuration.ExchangeOnlineUsername, service.Configuration.ExchangeOnlinePassword.ToSecureString()); environment = await service.Storage.GetEntityAsync <EnvironmentEntity>( MigrationConstants.EnvironmentTableName, entity.CustomerId, entity.PartitionKey); connectionUri = new Uri($"{MigrationConstants.ExchangeOnlineEndpoint}{environment.Organization}"); connectionInfo = GetConnectionInfo(connectionUri, MigrationConstants.SchemaUri, credential); command = new Command("Start-MigrationBatch"); parameters = new CommandParameterCollection { { "Identity", entity.Name } }; using (Runspace runspace = RunspaceFactory.CreateRunspace(connectionInfo)) { scriptManager.InvokeCommand(runspace, command, parameters); } entity.Started = true; await service.Storage.WriteToTableAsync(MigrationConstants.MigrationBatchTable, entity); } finally { connectionInfo = null; connectionUri = null; credential = null; parameters = null; } }
public void ToNativeCommandShouldReturnCorrectNativeCommand(GetProcessCommand command) { // Fixture setup var expectedParameters = new CommandParameterCollection() { new CommandParameter("ComputerName", command.ComputerName) }; // Exercise system var nativeCommand = command.ToNativeCommand(); // Verify outcome nativeCommand.Should().NotBeNull(); nativeCommand.CommandText.Should().Be(command.Name); nativeCommand.Parameters.Should().BeEquivalentTo(expectedParameters); }
public void ExecuteUpdateQuery() { using (SqlServerTestHelper helper = CreateHelper(CreateTable_TestTable)) { var query = $"UPDATE {Table_TestTable} SET Number = @Number WHERE Id >= @Id"; var parameters = new CommandParameterCollection { { "@Id", 2 }, { "@Number", 666 } }; QueryProvider provider = CreateQueryProvider(helper.Connection); int result = provider.ExecuteNonQuery(query, parameters); result.Should().Be(2); // Updated 2 rows. } }
public void ExecuteInsertQuery() { using (SqlServerTestHelper helper = CreateHelper(CreateTable_TestTable)) { var query = $"INSERT INTO {Table_TestTable} (Id, Number, Description) VALUES (@Id, @Number, @Description)"; var parameters = new CommandParameterCollection { { "@Id", 6 }, { "@Number", 666 }, { "@Description", "Sed ac lobortis magna." } }; QueryProvider provider = CreateQueryProvider(helper.Connection); int result = provider.ExecuteNonQuery(query, parameters); result.Should().Be(1); // Inserted 1 row. } }
public void ReturnCorrectValueFromSelectRowStoredProcedure() { using (SqlServerTestHelper helper = CreateHelper(CreateProcedure_RowResultWithMultipleValues)) { var parameters = new CommandParameterCollection { { "@Id", 1 }, { "@Number", 10 }, { "@Description", "Lorem ipsum" } }; QueryProvider provider = CreateQueryProvider(helper.Connection); TestItem result = provider.ExecuteStoredProcedure <TestItem>(Procedure_RowResultWithMultipleValues, parameters); result.Should().Be(new TestItem(1, 10, "Lorem ipsum")); } }
private void DeserializeInvocationInfo(SerializationInfo info) { string str = info.GetString("InvocationInfo_Command"); string str1 = info.GetString("InvocationInfo_Name"); string str2 = info.GetString("InvocationInfo_ModuleName"); string str3 = info.GetString("InvocationInfo_AdapterTypeName"); Dictionary<string, object> strs = new Dictionary<string, object>(); string str4 = info.GetString("InvocationParam_ScriptBlock"); if (str4 != null) { strs.Add("ScriptBlock", ScriptBlock.Create(str4)); } string str5 = info.GetString("InvocationParam_FilePath"); if (!string.IsNullOrEmpty(str5)) { strs.Add("FilePath", str5); } str4 = info.GetString("InvocationParam_InitScript"); if (!string.IsNullOrEmpty(str4)) { strs.Add("InitializationScript", ScriptBlock.Create(str4)); } bool flag = info.GetBoolean("InvocationParam_RunAs32"); strs.Add("RunAs32", flag); AuthenticationMechanism value = (AuthenticationMechanism)info.GetValue("InvocationParam_Authentication", typeof(AuthenticationMechanism)); strs.Add("Authentication", value); object[] objArray = (object[])info.GetValue("InvocationParam_ArgList", typeof(object[])); if (objArray != null) { strs.Add("ArgumentList", objArray); } JobDefinition jobDefinition = new JobDefinition(null, str, str1); jobDefinition.ModuleName = str2; jobDefinition.JobSourceAdapterTypeName = str3; CommandParameterCollection commandParameterCollection = new CommandParameterCollection(); foreach (KeyValuePair<string, object> keyValuePair in strs) { CommandParameter commandParameter = new CommandParameter(keyValuePair.Key, keyValuePair.Value); commandParameterCollection.Add(commandParameter); } base.Definition = jobDefinition; base.Name = str1; base.Command = str; base.Parameters.Add(commandParameterCollection); }
internal Command(Command command) { this._mergeInstructions = new PipelineResultTypes[4]; this._parameters = new CommandParameterCollection(); this._command = string.Empty; this._isScript = command._isScript; this._useLocalScope = command._useLocalScope; this._command = command._command; this._mergeInstructions = command._mergeInstructions; this._mergeMyResult = command._mergeMyResult; this._mergeToResult = command._mergeToResult; this._mergeUnclaimedPreviousCommandResults = command._mergeUnclaimedPreviousCommandResults; this.isEndOfStatement = command.isEndOfStatement; foreach (CommandParameter parameter in command.Parameters) { this.Parameters.Add(new CommandParameter(parameter.Name, parameter.Value)); } }
private void ValidateAllParametersBound(CommandParameterCollection parameters) { if (parameters.Count < 1) { return; } var curParam = parameters[0]; if (!String.IsNullOrEmpty(curParam.Name)) { var msg = String.Format("No parameter was found that matches the name or alias '{0}'.", curParam.Name); throw new ParameterBindingException(msg, "ParameterNotFound"); } else { var msg = String.Format("Positional parameter not found for provided argument '{0}'", curParam.Value); throw new ParameterBindingException(msg, "PositionalParameterNotFound"); } }
public void BindCommandLineParameters(CommandParameterCollection parameters) { // TODO: as soon as we support cmdlet functions, we should think about using the CmdletParameterBinder // or at least extract common functionality var unboundArguments = new List<CommandParameter>(parameters); var unboundScriptParameters = new List<ParameterAst>(_scriptParameters); // bind arguments by name BindArgumentsByName(unboundScriptParameters, unboundArguments); // then we set all parameters by position BindArgumentsByPosition(unboundScriptParameters, unboundArguments); // parameters that are still unbound should get their default value SetUnboundParametersToDefaultValue(unboundScriptParameters); // finally we will set the $Args variable with all values that are left SetArgsVariableFromUnboundArgs(unboundArguments); }
public void BindCommandLineParameters(CommandParameterCollection parameters) { // TODO: as soon as we support cmdlet functions, we should think about using the CmdletParameterBinder // or at least extract common functionality var unboundArguments = new List <CommandParameter>(parameters); var unboundScriptParameters = new List <ParameterAst>(_scriptParameters); // bind arguments by name BindArgumentsByName(unboundScriptParameters, unboundArguments); // then we set all parameters by position BindArgumentsByPosition(unboundScriptParameters, unboundArguments); // parameters that are still unbound should get their default value SetUnboundParametersToDefaultValue(unboundScriptParameters); // finally we will set the $Args variable with all values that are left SetArgsVariableFromUnboundArgs(unboundArguments); }
private void BindPositionalParameters(CommandParameterCollection parameters, CommandParameterSetInfo parameterSet) { var parametersWithoutName = from param in parameters where String.IsNullOrEmpty(param.Name) select param; if (parameterSet == null) { if (parametersWithoutName.Any()) { ThrowAmbiguousParameterSetException(); } return; } var positionals = (from param in parameterSet.Parameters where param.Position >= 0 orderby param.Position ascending select param).ToList(); int i = 0; foreach (var curParam in parametersWithoutName) { bool bound = false; while (!bound) { if (i < positionals.Count) { var affectedParam = positionals[i]; if (!_boundParameters.Contains(affectedParam.MemberInfo)) { BindParameter(affectedParam, curParam.Value, true); bound = true; } i++; } else { var msg = String.Format("Positional parameter not found for provided argument '{0}'", curParam.Value); throw new ParameterBindingException(msg, "PositionalParameterNotFound"); } } } }
public JobInvocationInfo(JobDefinition definition, IEnumerable <Dictionary <string, object> > parameterCollectionList) { this._name = string.Empty; this._instanceId = Guid.NewGuid(); this._definition = definition; if (parameterCollectionList != null) { foreach (Dictionary <string, object> dictionary in parameterCollectionList) { if (dictionary != null) { CommandParameterCollection item = ConvertDictionaryToParameterCollection(dictionary); if (item != null) { this.Parameters.Add(item); } } } } }
public void ReturnCorrectValueFromStoredProcedure() { using (SqlServerTestHelper helper = CreateHelper(CreateProcedure_ScalarResult)) { const int param1 = 11; const int param2 = 22; const int expected = 33; var parameters = new CommandParameterCollection { { "@Param1", param1 }, { "@Param2", param2 } }; QueryProvider provider = CreateQueryProvider(helper.Connection); int result = provider.ExecuteStoredProcedure <int>(Procedure_ScalarResult, parameters); result.Should().Be(expected); } }
public JobInvocationInfo(JobDefinition definition, IEnumerable <Dictionary <string, object> > parameterCollectionList) { _definition = definition; if (parameterCollectionList == null) { return; } foreach (var parameterCollection in parameterCollectionList) { if (parameterCollection == null) { continue; } CommandParameterCollection convertedCollection = ConvertDictionaryToParameterCollection(parameterCollection); if (convertedCollection != null) { Parameters.Add(convertedCollection); } } }
/// <summary> /// Binds the parameters from the command line to the command. /// </summary> /// <remarks> /// All abount Cmdlet parameters: http://msdn2.microsoft.com/en-us/library/ms714433(VS.85).aspx /// About the lifecycle: http://msdn.microsoft.com/en-us/library/ms714429(v=vs.85).aspx /// </remarks> public void BindCommandLineParameters(CommandParameterCollection parameters) { // How command line parameters are bound: // 1. Bind all named parameters, fail if some name is bound twice BindNamedParameters(parameters); // 2. Check if there is an "active" parameter set, yet. // If there is more than one "active" parameter set, fail with ambigous error CheckForActiveParameterSet(); // 3. Bind positional parameters per parameter set // To do so, sort parameters of set by position, ignore bound parameters and set the first unbound position // Note: if we don't know the active parameter set, yet, we will bind it by Default, this is PS behavior BindPositionalParameters(parameters, ActiveOrDefaultParameterSet); // 4. This would be the place for common parameters, support of ShouldProcess and dynamic parameters // TODO: care about "common" parameters and dynamic parameters // 5. Check if there is an "active" parameter set, yet, and fail if there are more than one CheckForActiveParameterSet(); // 6. For either the (active or default) parameter set: Gather missing mandatory parameters by UI // 7. Check if (active or default) parameter set has unbound mandatory parameters and fail if so // But not pipeline related parameters, they might get passed later on HandleMissingMandatoryParameters(ActiveOrDefaultParameterSet, false, true); // 8. Check for an active parameter set. If the default set had unique mandatory parameters, we might // know that the default set is the active set CheckForActiveParameterSet(); // 9. Define "candidate" parameter sets: All that have mandatory parameters set, ignoring pipeline related // If one set is already active, this should be the only candidate set // NOTE: makes sense if there has been no unique parameter, but multiple sets have their mandatories set _candidateParameterSets = GetCandidateParameterSets(false); // 10. Back up the bound parameters BackupCommandLineParameterValues(); // 11. For the beginning phase: Tell the cmdlet which parameter set is likely to be used (if we know it) ChooseParameterSet(ActiveOrDefaultParameterSet); }
/// <summary> /// Binds the parameters from the command line to the command. /// </summary> /// <remarks> /// All abount Cmdlet parameters: http://msdn2.microsoft.com/en-us/library/ms714433(VS.85).aspx /// About the lifecycle: http://msdn.microsoft.com/en-us/library/ms714429(v=vs.85).aspx /// </remarks> public void BindCommandLineParameters(CommandParameterCollection parameters) { // How command line parameters are bound: // 1. Bind all named parameters, fail if some name is bound twice BindNamedParameters(parameters); // 2. Check if there is an "active" parameter set, yet. // If there is more than one "active" parameter set, fail with ambigous error CheckForActiveParameterSet(); // 3. Bind positional parameters per parameter set // To do so, sort parameters of set by position, ignore bound parameters and set the first unbound position // Note: if we don't know the active parameter set, yet, we will bind it by Default, this is PS behavior BindPositionalParameters(parameters, ActiveOrDefaultParameterSet); // 4. This would be the place for common parameters, support of ShouldProcess and dynamic parameters // TODO: care about "common" parameters and dynamic parameters // 5. Check if there is an "active" parameter set, yet, and fail if there are more than one CheckForActiveParameterSet(); // 6. For either the (active or default) parameter set: Gather missing mandatory parameters by UI // 7. Check if (active or default) parameter set has unbound mandatory parameters and fail if so // But not pipeline related parameters, they might get passed later on HandleMissingMandatoryParameters(ActiveOrDefaultParameterSet, false, true); // 8. Check for an active parameter set. If the default set had unique mandatory parameters, we might // know that the default set is the active set CheckForActiveParameterSet(); // 9. Define "candidate" parameter sets: All that have mandatory parameters set, ignoring pipeline related // If one set is already active, this should be the only candidate set // NOTE: makes sense if there has been no unique parameter, but multiple sets have their mandatories set _candidateParameterSets = GetCandidateParameterSets(false); // 10. Back up the bound parameters BackupCommandLineParameterValues(); // 11. For the beginning phase: Tell the cmdlet which parameter set is likely to be used (if we know it) ChooseParameterSet(ActiveOrDefaultParameterSet); }
private CommandParameterCollection BindNamedParameters(CommandParameterCollection parameters) { var namedParameters = from parameter in parameters where !String.IsNullOrEmpty(parameter.Name) select parameter; var parametersLeft = new CommandParameterCollection(parameters); foreach (var curParam in namedParameters) { string curName = curParam.Name; // try to get the parameter from any set. throws an error if the name is ambiguous or doesn't exist var paramInfo = _cmdletInfo.LookupParameter(curName); if (paramInfo != null) { BindParameter(paramInfo, curParam.Value, true); parametersLeft.Remove(curParam); } } return(parametersLeft); }
private void DeserializeInvocationInfo(SerializationInfo info) { string command = info.GetString("InvocationInfo_Command"); string name = info.GetString("InvocationInfo_Name"); string moduleName = info.GetString("InvocationInfo_ModuleName"); string adapterTypeName = info.GetString("InvocationInfo_AdapterTypeName"); // // Parameters Dictionary<string, object> parameters = new Dictionary<string, object>(); // ScriptBlock string script = info.GetString("InvocationParam_ScriptBlock"); if (script != null) { parameters.Add(ScriptBlockParameter, ScriptBlock.Create(script)); } // FilePath string filePath = info.GetString("InvocationParam_FilePath"); if (!string.IsNullOrEmpty(filePath)) { parameters.Add(FilePathParameter, filePath); } // InitializationScript script = info.GetString("InvocationParam_InitScript"); if (!string.IsNullOrEmpty(script)) { parameters.Add(InitializationScriptParameter, ScriptBlock.Create(script)); } // RunAs32 bool runAs32 = info.GetBoolean("InvocationParam_RunAs32"); parameters.Add(RunAs32Parameter, runAs32); // Authentication AuthenticationMechanism authentication = (AuthenticationMechanism)info.GetValue("InvocationParam_Authentication", typeof(AuthenticationMechanism)); parameters.Add(AuthenticationParameter, authentication); // ArgumentList object[] argList = (object[])info.GetValue("InvocationParam_ArgList", typeof(object[])); if (argList != null) { parameters.Add(ArgumentListParameter, argList); } JobDefinition jobDefinition = new JobDefinition(null, command, name); jobDefinition.ModuleName = moduleName; jobDefinition.JobSourceAdapterTypeName = adapterTypeName; // Convert to JobInvocationParameter collection CommandParameterCollection paramCollection = new CommandParameterCollection(); foreach (KeyValuePair<string, object> param in parameters) { CommandParameter paramItem = new CommandParameter(param.Key, param.Value); paramCollection.Add(paramItem); } this.Definition = jobDefinition; this.Name = name; this.Command = command; this.Parameters.Add(paramCollection); }
private CommandParameterCollection BindDynamicParameters(CommandParameterCollection parameters) { var dynamicParamsCmdlet = _cmdlet as IDynamicParameters; if (dynamicParamsCmdlet == null) // no support for dynamic parameters { return parameters; } // get the object with dynamic parameters var parameterObject = dynamicParamsCmdlet.GetDynamicParameters(); if (parameterObject == null) { return parameters; } var discovery = new CommandParameterDiscovery(parameterObject.GetType()); // add the parameters to the cmdletInfo _cmdletInfo.AddParametersToAllSets(discovery); // as we updated parameter sets, we need to rebuild some cached values _activeSet = _activeSet == null ? null : GetParameterSet(_activeSet.Name); _defaultSet = _defaultSet == null ? null : GetParameterSet(_defaultSet.Name); _candidateParameterSets = (from p in _candidateParameterSets select GetParameterSet(p.Name)).ToList(); AddBindDestionations(discovery, parameterObject); // now try to rebind the parameters parameters = BindNamedParameters(parameters); return BindPositionalParameters(parameters, ActiveOrDefaultParameterSet); }
private void ValidateAllParametersBound(CommandParameterCollection parameters) { if (parameters.Count < 1) { return; } var curParam = parameters[0]; if (!String.IsNullOrEmpty(curParam.Name)) { var msg = String.Format("No parameter was found that matches the name or alias '{0}'.", curParam.Name); throw new ParameterBindingException(msg, "ParameterNotFound"); } else { var msg = String.Format("Positional parameter not found for provided argument '{0}'", curParam.Value); throw new ParameterBindingException(msg, "PositionalParameterNotFound"); } }
private void BindPositionalParameters(CommandParameterCollection parameters, CommandParameterSetInfo parameterSet) { var parametersWithoutName = from param in parameters where String.IsNullOrEmpty(param.Name) select param; if (parameterSet == null) { if (parametersWithoutName.Any()) { throw new ParameterBindingException("The parameter set to be used cannot be resolved.", "AmbiguousParameterSet"); } return; } var positionals = (from param in parameterSet.Parameters where param.Position >= 0 orderby param.Position ascending select param).ToList(); int i = 0; foreach (var curParam in parametersWithoutName) { if (i < positionals.Count) { var affectedParam = positionals[i]; BindParameter(affectedParam, curParam.Value, true); i++; } else { var msg = String.Format("Positional parameter not found for provided argument '{0}'", curParam.Value); throw new ParameterBindingException(msg, "PositionalParameterNotFound"); } } }
private void BindNamedParameters(CommandParameterCollection parameters) { var namedParameters = from parameter in parameters where !String.IsNullOrEmpty(parameter.Name) select parameter; foreach (var curParam in namedParameters) { string curName = curParam.Name; // try to get the parameter from any set. throws an error if the name is ambiguous or doesn't exist var paramInfo = _cmdletInfo.LookupParameter(curName); BindParameter(paramInfo, curParam.Value, true); } }
private CommandParameterCollection BindNamedParameters(CommandParameterCollection parameters) { var namedParameters = from parameter in parameters where !String.IsNullOrEmpty(parameter.Name) select parameter; var parametersLeft = new CommandParameterCollection(parameters); foreach (var curParam in namedParameters) { string curName = curParam.Name; // try to get the parameter from any set. throws an error if the name is ambiguous or doesn't exist var paramInfo = _cmdletInfo.LookupParameter(curName); if (paramInfo != null) { BindParameter(paramInfo, curParam.Value, true); parametersLeft.Remove(curParam); } } return parametersLeft; }
/// <summary> /// Utility function to turn a dictionary of name/value pairs into a parameter collection /// </summary> /// <param name="parameters">The dictionary to convert</param> /// <returns>The converted collection</returns> private static CommandParameterCollection ConvertDictionaryToParameterCollection(IEnumerable<KeyValuePair<string, object>> parameters) { if (parameters == null) return null; CommandParameterCollection paramCollection = new CommandParameterCollection(); foreach (CommandParameter paramItem in parameters.Select(param => new CommandParameter(param.Key, param.Value))) { paramCollection.Add(paramItem); } return paramCollection; }
private Command() { Parameters = new CommandParameterCollection(); MergeMyResult = PipelineResultTypes.None; MergeToResult = PipelineResultTypes.None; }
/// <summary> /// Create necessary dictionaries for WorkflowManager consumption based on StartParameters. /// </summary> private void SortStartParameters(DynamicActivity dynamicActivity, CommandParameterCollection parameters) { bool selfRemoting = dynamicActivity != null && dynamicActivity.Properties.Any(x => x.Name.Equals(Constants.ComputerName, StringComparison.CurrentCultureIgnoreCase)); bool takesPSPrivateMetadata = dynamicActivity != null && dynamicActivity.Properties.Contains(Constants.PrivateMetadata); _jobMetadata.Add(Constants.WorkflowTakesPrivateMetadata, takesPSPrivateMetadata); if (parameters != null) { foreach (var parameter in parameters) { _tracer.WriteMessage(ClassNameTrace, "SortStartParameters", WorkflowGuidForTraces, this, "Found parameter; {0}; {1}", parameter.Name, parameter.Value == null ? null : parameter.Value.ToString()); switch (parameter.Name) { case Constants.ComputerName: if (selfRemoting) { // If we're self-remoting, location becomes the default computer // and the PSComputerNames is passed in as an argument instead // of going to the ubiquitous parameters _location = Constants.DefaultComputerName; string parameterName = dynamicActivity.Properties.First(x => x.Name.Equals(Constants.ComputerName, StringComparison.CurrentCultureIgnoreCase)).Name; _workflowParameters[parameterName] = LanguagePrimitives.ConvertTo<string[]>(parameter.Value); } else { // Set _location before adding parameter. var computer = parameter.Value as string; _location = computer; string[] computerNames = LanguagePrimitives.ConvertTo<string[]>(parameter.Value); _psWorkflowCommonParameters[parameter.Name] = computerNames; } break; case Constants.PrivateMetadata: Hashtable privateData = parameter.Value as Hashtable; if (privateData != null) { IDictionaryEnumerator enumerator = privateData.GetEnumerator(); while (enumerator.MoveNext()) { _privateMetadata.Add(enumerator.Key.ToString(), enumerator.Value); } // Make the combined object available within the workflow as well... if (takesPSPrivateMetadata) { _workflowParameters.Add(parameter.Name, parameter.Value); } } break; case Constants.PSInputCollection: { // Remove the input collection so we can properly pass it to the workflow job object baseObject = parameter.Value is PSObject ? ((PSObject)parameter.Value).BaseObject : parameter.Value; if (baseObject is PSDataCollection<PSObject>) { _inputCollection = baseObject as PSDataCollection<PSObject>; } else { var inputCollection = new PSDataCollection<PSObject>(); var e = LanguagePrimitives.GetEnumerator(baseObject); if (e != null) { while (e.MoveNext()) { inputCollection.Add(PSObject.AsPSObject(e.Current)); } } else { inputCollection.Add(PSObject.AsPSObject(parameter.Value)); } _inputCollection = inputCollection; } } break; case Constants.PSParameterCollection: // Remove this one from the parameter collection... break; case Constants.PSRunningTime: case Constants.PSElapsedTime: case Constants.ConnectionRetryCount: case Constants.ActionRetryCount: case Constants.ConnectionRetryIntervalSec: case Constants.ActionRetryIntervalSec: _psWorkflowCommonParameters.Add(parameter.Name, parameter.Value); break; case Constants.Persist: case Constants.Credential: case Constants.Port: case Constants.UseSSL: case Constants.ConfigurationName: case Constants.ApplicationName: case Constants.ConnectionURI: case Constants.SessionOption: case Constants.Authentication: case Constants.AuthenticationLevel: case Constants.CertificateThumbprint: case Constants.AllowRedirection: case Constants.Verbose: case Constants.Debug: case Constants.ErrorAction: case Constants.WarningAction: case Constants.InformationAction: case Constants.PSWorkflowErrorAction: case Constants.PSSuspendOnError: case Constants.PSSenderInfo: case Constants.ModulePath: case Constants.PSCurrentDirectory: // Note: We don't add ErrorVariable, WarningVariable, OutVariable, or OutBuffer // here because they are interpreted by PowerShell in the function generated over // the workflow definition. _psWorkflowCommonParameters.Add(parameter.Name, parameter.Value); break; default: _workflowParameters.Add(parameter.Name, parameter.Value); break; } } } // Add in the workflow command name... _psWorkflowCommonParameters.Add("WorkflowCommandName", _definition.Command); }
internal void LoadWorkflow(CommandParameterCollection commandParameterCollection, Activity activity, string xaml) { _tracer.WriteMessage(ClassNameTrace, "LoadWorkflow", WorkflowGuidForTraces, this, "BEGIN"); Dbg.Assert(_workflowInstance == null, "LoadWorkflow() should only be called once by the adapter"); // If activity hasn't been cached, we can't generate it from _definition. if (activity == null) { bool windowsWorkflow; activity = DefinitionCache.Instance.GetActivityFromCache(_definition, out windowsWorkflow); if (activity == null) { // The workflow cannot be run. throw new InvalidOperationException(Resources.ActivityNotCached); } } string workflowXaml; string runtimeAssemblyPath; if (string.IsNullOrEmpty(xaml)) { workflowXaml = DefinitionCache.Instance.GetWorkflowXaml(_definition); runtimeAssemblyPath = DefinitionCache.Instance.GetRuntimeAssemblyPath(_definition); } else { workflowXaml = xaml; runtimeAssemblyPath = null; } _location = null; SortStartParameters(activity as DynamicActivity, commandParameterCollection); // Set location if ComputerName wasn't specified in the parameters. if (string.IsNullOrEmpty(_location)) _location = Constants.DefaultComputerName; if (_jobMetadata.ContainsKey(Constants.JobMetadataLocation)) _jobMetadata.Remove(Constants.JobMetadataLocation); _jobMetadata.Add(Constants.JobMetadataLocation, _location); if (_jobMetadata.ContainsKey(Constants.WorkflowJobCreationContext)) _jobMetadata.Remove(Constants.WorkflowJobCreationContext); _jobMetadata.Add(Constants.WorkflowJobCreationContext, _jobCreationContext); PSWorkflowDefinition definition = new PSWorkflowDefinition(activity, workflowXaml, runtimeAssemblyPath, _definition.RequiredAssemblies); PSWorkflowContext metadatas = new PSWorkflowContext(_workflowParameters, _psWorkflowCommonParameters, _jobMetadata, _privateMetadata); _workflowInstance = _runtime.Configuration.CreatePSWorkflowInstance(definition, metadatas, _inputCollection, this); this.ConfigureWorkflowHandlers(); // Create a WorkflowApplication instance. _tracer.WriteMessage(ClassNameTrace, "LoadWorkflow", WorkflowGuidForTraces, this, "Calling instance loader"); #if DEBUG try { _workflowInstance.CreateInstance(); } catch (Exception e) { if (e.Message.IndexOf("Cannot create unknown type", StringComparison.OrdinalIgnoreCase) >= 0) { // Capture environment to help diagnose: MSFT:246456 PSObject inputObject = new PSObject(); inputObject.Properties.Add( new PSNoteProperty("activity", activity)); inputObject.Properties.Add( new PSNoteProperty("workflowXaml", workflowXaml)); inputObject.Properties.Add( new PSNoteProperty("runtimeAssemblyPath", runtimeAssemblyPath)); inputObject.Properties.Add( new PSNoteProperty("_definition.RequiredAssemblies", _definition.RequiredAssemblies)); string tempPath = System.IO.Path.GetTempFileName(); System.Management.Automation.PowerShell.Create().AddCommand("Export-CliXml"). AddParameter("InputObject", inputObject). AddParameter("Depth", 10). AddParameter("Path", tempPath).Invoke(); throw new Exception("Bug MSFT:246456 detected. Please capture " + tempPath + ", open a new issue " + "at https://github.com/PowerShell/PowerShell/issues/new and attach the file."); } else { throw; } } #else _workflowInstance.CreateInstance(); #endif InitializeWithWorkflow(_workflowInstance); WorkflowInstanceLoaded = true; _tracer.WriteMessage(ClassNameTrace, "LoadWorkflow", WorkflowGuidForTraces, this, "END"); }
private void CreateChildJob(JobInvocationInfo specification, Activity activity, ContainerParentJob newJob, CommandParameterCollection commandParameterCollection, Dictionary<string, object> parameterDictionary, string computerName, string[] computerNames) { if (!string.IsNullOrEmpty(computerName)) { string[] childTargetComputerList = { computerName }; // Set the target computer for this child job... parameterDictionary[Constants.ComputerName] = childTargetComputerList; } var childSpecification = new JobInvocationInfo(specification.Definition, parameterDictionary); // Job objects will be disposed of on parent job removal. var childJob = new PSWorkflowJob(_runtime, childSpecification); childJob.JobMetadata = CreateJobMetadata(childJob, newJob.InstanceId, newJob.Id, newJob.Name, newJob.Command, computerNames); // Remove the parameter from the collection... for (int index = 0; index < commandParameterCollection.Count; index++) { if (string.Equals(commandParameterCollection[index].Name, Constants.ComputerName, StringComparison.OrdinalIgnoreCase)) { commandParameterCollection.RemoveAt(index); break; } } if (!string.IsNullOrEmpty(computerName)) { var computerNameParameter = new CommandParameter(Constants.ComputerName, computerName); commandParameterCollection.Add(computerNameParameter); } this.AddJob(childJob); childJob.LoadWorkflow(commandParameterCollection, activity, null); newJob.AddChildJob(childJob); StructuredTracer.ChildWorkflowJobAddition(childJob.InstanceId, newJob.InstanceId); Tracer.TraceJob(childJob); StructuredTracer.WorkflowJobCreated(newJob.InstanceId, childJob.InstanceId, childJob.WorkflowGuid); }
/// <summary> /// /// </summary> /// <param name="definition"></param> /// <param name="parameters"></param> public JobInvocationInfo(JobDefinition definition, CommandParameterCollection parameters) { _definition = definition; Parameters.Add(parameters ?? new CommandParameterCollection()); }
private CommandParameterCollection BindPositionalParameters(CommandParameterCollection parameters, CommandParameterSetInfo parameterSet) { var parametersWithoutName = from param in parameters where String.IsNullOrEmpty(param.Name) select param; if (parameterSet == null) { if (parametersWithoutName.Any()) { ThrowAmbiguousParameterSetException(); } return parameters; } var positionals = (from param in parameterSet.Parameters where param.Position >= 0 && !_boundParameters.Contains(param.MemberInfo) orderby param.Position ascending select param).ToList(); int i = 0; var parametersLeft = new CommandParameterCollection(parameters); foreach (var curParam in parametersWithoutName) { if (i >= positionals.Count) { break; // can't bind it } BindParameter(positionals[i], curParam.Value, true); parametersLeft.Remove(curParam); i++; } return parametersLeft; }
internal CommandProcessorBase(CommandInfo cmdInfo) { CommandInfo = cmdInfo; Parameters = new CommandParameterCollection(); }
private void CreateChildJob(JobInvocationInfo specification, Activity activity, ContainerParentJob newJob, CommandParameterCollection commandParameterCollection, Dictionary<string, object> parameterDictionary, string computerName, string[] computerNames) { if (!string.IsNullOrEmpty(computerName)) { string[] strArrays = new string[1]; strArrays[0] = computerName; string[] strArrays1 = strArrays; parameterDictionary["PSComputerName"] = strArrays1; } JobInvocationInfo jobInvocationInfo = new JobInvocationInfo(specification.Definition, parameterDictionary); PSWorkflowJob pSWorkflowJob = new PSWorkflowJob(this._runtime, jobInvocationInfo); pSWorkflowJob.JobMetadata = PSWorkflowJobManager.CreateJobMetadata(pSWorkflowJob, newJob.InstanceId, newJob.Id, newJob.Name, newJob.Command, computerNames); int num = 0; while (num < commandParameterCollection.Count) { if (!string.Equals(commandParameterCollection[num].Name, "PSComputerName", StringComparison.OrdinalIgnoreCase)) { num++; } else { commandParameterCollection.RemoveAt(num); break; } } if (!string.IsNullOrEmpty(computerName)) { CommandParameter commandParameter = new CommandParameter("PSComputerName", computerName); commandParameterCollection.Add(commandParameter); } this.AddJob(pSWorkflowJob); pSWorkflowJob.LoadWorkflow(commandParameterCollection, activity, null); newJob.AddChildJob(pSWorkflowJob); PSWorkflowJobManager.StructuredTracer.ChildWorkflowJobAddition(pSWorkflowJob.InstanceId, newJob.InstanceId); PSWorkflowJobManager.Tracer.TraceJob(pSWorkflowJob); PSWorkflowJobManager.StructuredTracer.WorkflowJobCreated(newJob.InstanceId, pSWorkflowJob.InstanceId, pSWorkflowJob.WorkflowGuid); }