public JobInvocationInfo(JobDefinition definition, CommandParameterCollection parameters)
{
this._name = string.Empty;
this._instanceId = Guid.NewGuid();
this._definition = definition;
this.Parameters.Add(parameters ?? new CommandParameterCollection());
}
/// <summary>
/// Creates a new job of the appropriate type given by JobDefinition passed in.
/// </summary>
/// <param name="definition">JobDefinition defining the command.</param>
/// <returns>Job2 object of the appropriate type specified by the definition.</returns>
/// <exception cref="InvalidOperationException">If JobSourceAdapter type specified
/// in definition is not registered.</exception>
/// <exception cref="Exception">JobSourceAdapter implementation exception thrown on error.
/// </exception>
public Job2 NewJob(JobDefinition definition)
{
if (definition == null)
{
throw new ArgumentNullException("definition");
}
JobSourceAdapter sourceAdapter = GetJobSourceAdapter(definition);
Job2 newJob;
#pragma warning disable 56500
try
{
newJob = sourceAdapter.NewJob(definition);
}
catch (Exception exception)
{
// Since we are calling into 3rd party code
// catching Exception is allowed. In all
// other cases the appropriate exception
// needs to be caught.
// sourceAdapter.NewJob returned unknown error.
_tracer.TraceException(exception);
throw;
}
#pragma warning restore 56500
return(newJob);
}
/// <summary>
/// Saves the job to a persisted store.
/// </summary>
/// <param name="job">Job2 type job to persist.</param>
/// <param name="definition">Job definition containing source adapter information.</param>
public void PersistJob(Job2 job, JobDefinition definition)
{
if (job == null)
{
throw new PSArgumentNullException("job");
}
if (definition == null)
{
throw new PSArgumentNullException("definition");
}
JobSourceAdapter sourceAdapter = GetJobSourceAdapter(definition);
try
{
sourceAdapter.PersistJob(job);
}
catch (Exception exception)
{
// Since we are calling into 3rd party code
// catching Exception is allowed. In all
// other cases the appropriate exception
// needs to be caught.
// sourceAdapter.NewJob returned unknown error.
_tracer.TraceException(exception);
throw;
}
}
public JobInvocationInfo(JobDefinition definition, CommandParameterCollection parameters)
{
this._name = string.Empty;
this._instanceId = Guid.NewGuid();
this._definition = definition;
this.Parameters.Add(parameters ?? new CommandParameterCollection());
}
/// <summary>
/// Create a new job definition with a single set of parameters.
/// </summary>
/// <param name="definition">The job definition.</param>
/// <param name="parameters">The parameter collection to use.</param>
public JobInvocationInfo(JobDefinition definition, Dictionary <string, object> parameters)
{
_definition = definition;
var convertedCollection = ConvertDictionaryToParameterCollection(parameters);
if (convertedCollection != null)
{
Parameters.Add(convertedCollection);
}
}
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);
}
}
/// <summary>
/// </summary>
/// <param name="definition"></param>
/// <param name="parameters"></param>
public JobInvocationInfo(JobDefinition definition, IEnumerable <CommandParameterCollection> parameters)
{
_definition = definition;
if (parameters == null)
{
return;
}
foreach (var parameter in parameters)
{
Parameters.Add(parameter);
}
}
public ScheduledJobInvocationInfo(JobDefinition definition, Dictionary<string, object> parameters) : base(definition, parameters)
{
if (definition != null)
{
base.Name = definition.Name;
return;
}
else
{
throw new PSArgumentNullException("definition");
}
}
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 JobInvocationInfo(JobDefinition definition, IEnumerable<CommandParameterCollection> parameters)
{
this._name = string.Empty;
this._instanceId = Guid.NewGuid();
this._definition = definition;
if (parameters != null)
{
foreach (CommandParameterCollection parameters2 in parameters)
{
this.Parameters.Add(parameters2);
}
}
}
public JobInvocationInfo(JobDefinition definition, IEnumerable <CommandParameterCollection> parameters)
{
this._name = string.Empty;
this._instanceId = Guid.NewGuid();
this._definition = definition;
if (parameters != null)
{
foreach (CommandParameterCollection parameters2 in parameters)
{
this.Parameters.Add(parameters2);
}
}
}
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);
}
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 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);
}
}
}
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 Job2 NewJob(JobDefinition definition)
{
Job2 job;
if (definition == null)
{
throw new ArgumentNullException("definition");
}
JobSourceAdapter jobSourceAdapter = this.GetJobSourceAdapter(definition);
try
{
job = jobSourceAdapter.NewJob(definition);
}
catch (Exception exception)
{
this.Tracer.TraceException(exception);
CommandProcessorBase.CheckForSevereException(exception);
throw;
}
return(job);
}
public void PersistJob(Job2 job, JobDefinition definition)
{
if (job == null)
{
throw new PSArgumentNullException("job");
}
if (definition == null)
{
throw new PSArgumentNullException("definition");
}
JobSourceAdapter jobSourceAdapter = this.GetJobSourceAdapter(definition);
try
{
jobSourceAdapter.PersistJob(job);
}
catch (Exception exception)
{
this.Tracer.TraceException(exception);
CommandProcessorBase.CheckForSevereException(exception);
throw;
}
}
private ScheduledJobDefinition CreateFilePathDefinition()
{
JobDefinition jobDefinition = new JobDefinition(typeof(ScheduledJobSourceAdapter), this.FilePath, this._name);
jobDefinition.ModuleName = "PSScheduledJob";
Dictionary<string, object> strs = this.CreateCommonParameters();
if (this.FilePath.EndsWith(".ps1", StringComparison.OrdinalIgnoreCase))
{
Collection<PathInfo> resolvedPSPathFromPSPath = base.SessionState.Path.GetResolvedPSPathFromPSPath(this.FilePath);
if (resolvedPSPathFromPSPath.Count == 1)
{
strs.Add("FilePath", resolvedPSPathFromPSPath[0].Path);
JobInvocationInfo scheduledJobInvocationInfo = new ScheduledJobInvocationInfo(jobDefinition, strs);
ScheduledJobDefinition scheduledJobDefinition = new ScheduledJobDefinition(scheduledJobInvocationInfo, this.Trigger, this.ScheduledJobOption, this._credential);
return scheduledJobDefinition;
}
else
{
string str = StringUtil.Format(ScheduledJobErrorStrings.InvalidFilePath, new object[0]);
Exception runtimeException = new RuntimeException(str);
ErrorRecord errorRecord = new ErrorRecord(runtimeException, "InvalidFilePathParameterForRegisterScheduledJobDefinition", ErrorCategory.InvalidArgument, this);
base.WriteError(errorRecord);
return null;
}
}
else
{
string str1 = StringUtil.Format(ScheduledJobErrorStrings.InvalidFilePathFile, new object[0]);
Exception exception = new RuntimeException(str1);
ErrorRecord errorRecord1 = new ErrorRecord(exception, "InvalidFilePathParameterForRegisterScheduledJobDefinition", ErrorCategory.InvalidArgument, this);
base.WriteError(errorRecord1);
return null;
}
}
internal PSWorkflowJob CreateJobInternal(Guid jobInstanceId, Activity workflow, string command, string name, Dictionary<string, object> parameters, string xaml, Dictionary<string, object> creationContext)
{
AssertNotDisposed();
if (jobInstanceId == Guid.Empty)
throw new ArgumentNullException("jobInstanceId");
if (workflow == null)
throw new ArgumentNullException("workflow");
if (command == null)
throw new ArgumentNullException("command");
if (name == null)
throw new ArgumentNullException("name");
if (_wfJobTable.ContainsKey(jobInstanceId))
{
ArgumentException exception = new ArgumentException(Resources.DuplicateInstanceId);
Tracer.TraceException(exception);
throw exception;
}
lock (lockObjects.GetLockObject(jobInstanceId))
{
if (_wfJobTable.ContainsKey(jobInstanceId))
{
ArgumentException exception = new ArgumentException(Resources.DuplicateInstanceId);
Tracer.TraceException(exception);
throw exception;
}
JobDefinition definition = new JobDefinition(typeof(WorkflowJobSourceAdapter), command, name);
var parameterDictionary = new Dictionary<string, object>(StringComparer.CurrentCultureIgnoreCase);
if (parameters != null)
{
foreach (KeyValuePair<string, object> param in parameters)
{
parameterDictionary.Add(param.Key, param.Value);
}
}
string[] computerNames = null;
bool gotComputerNames = false;
object value;
if (parameterDictionary.Count != 0 && parameterDictionary.TryGetValue(Constants.ComputerName, out value))
{
if (LanguagePrimitives.TryConvertTo(value, CultureInfo.InvariantCulture, out computerNames))
gotComputerNames = computerNames != null;
}
if (gotComputerNames)
{
if (computerNames.Length > 1)
throw new ArgumentException(Resources.OneComputerNameAllowed);
parameterDictionary.Remove(Constants.ComputerName);
}
var childSpecification = new JobInvocationInfo(definition, parameterDictionary);
childSpecification.Command = command;
// If actual computernames were specified, then set the PSComputerName parameter.
if (gotComputerNames)
{
var computerNameParameter = new CommandParameter(Constants.ComputerName, computerNames);
childSpecification.Parameters[0].Add(computerNameParameter);
}
// Job objects will be disposed of on parent job removal.
var childJob = new PSWorkflowJob(_runtime, childSpecification, jobInstanceId, creationContext);
childJob.JobMetadata = CreateJobMetadataWithNoParentDefined(childJob, computerNames);
childJob.LoadWorkflow(childSpecification.Parameters[0], workflow, xaml);
this.AddJob(childJob);
return childJob;
}
}
internal PSWorkflowJob CreateJobInternal(Guid jobInstanceId, Activity workflow, string command, string name, Dictionary<string, object> parameters, string xaml)
{
object obj = null;
PSWorkflowJob pSWorkflowJob;
if (jobInstanceId != Guid.Empty)
{
if (workflow != null)
{
if (command != null)
{
if (name != null)
{
if (!this._wfJobTable.ContainsKey(jobInstanceId))
{
lock (this.lockObjects.GetLockObject(jobInstanceId))
{
if (!this._wfJobTable.ContainsKey(jobInstanceId))
{
JobDefinition jobDefinition = new JobDefinition(typeof(WorkflowJobSourceAdapter), command, name);
Dictionary<string, object> strs = new Dictionary<string, object>(StringComparer.CurrentCultureIgnoreCase);
if (parameters != null)
{
foreach (KeyValuePair<string, object> parameter in parameters)
{
strs.Add(parameter.Key, parameter.Value);
}
}
string[] strArrays = null;
bool flag = false;
if (strs.Count != 0 && strs.TryGetValue("PSComputerName", out obj) && LanguagePrimitives.TryConvertTo<string[]>(obj, CultureInfo.InvariantCulture, out strArrays))
{
flag = strArrays != null;
}
if (flag)
{
if ((int)strArrays.Length <= 1)
{
strs.Remove("PSComputerName");
}
else
{
throw new ArgumentException(Resources.OneComputerNameAllowed);
}
}
JobInvocationInfo jobInvocationInfo = new JobInvocationInfo(jobDefinition, strs);
jobInvocationInfo.Command = command;
if (flag)
{
CommandParameter commandParameter = new CommandParameter("PSComputerName", strArrays);
jobInvocationInfo.Parameters[0].Add(commandParameter);
}
PSWorkflowJob pSWorkflowJob1 = new PSWorkflowJob(this._runtime, jobInvocationInfo, jobInstanceId);
pSWorkflowJob1.JobMetadata = PSWorkflowJobManager.CreateJobMetadataWithNoParentDefined(pSWorkflowJob1, strArrays);
pSWorkflowJob1.LoadWorkflow(jobInvocationInfo.Parameters[0], workflow, xaml);
this.AddJob(pSWorkflowJob1);
pSWorkflowJob = pSWorkflowJob1;
}
else
{
ArgumentException argumentException = new ArgumentException(Resources.DuplicateInstanceId);
PSWorkflowJobManager.Tracer.TraceException(argumentException);
throw argumentException;
}
}
return pSWorkflowJob;
}
else
{
ArgumentException argumentException1 = new ArgumentException(Resources.DuplicateInstanceId);
PSWorkflowJobManager.Tracer.TraceException(argumentException1);
throw argumentException1;
}
}
else
{
throw new ArgumentNullException("name");
}
}
else
{
throw new ArgumentNullException("command");
}
}
else
{
throw new ArgumentNullException("workflow");
}
}
else
{
throw new ArgumentNullException("jobInstanceId");
}
}
/// <summary>
/// Populates job properties with valid values.
/// </summary>
/// <param name="updateJobParams">Job properties specified via PowerShell.</param>
/// <param name="existingJobDefinition">Existing job definition.</param>
private void PopulateExistingJobParams(PSJobParams updateJobParams, JobDefinition existingJobDefinition)
{
JobProperties jobProperties = this.GetExistingJobPropertiesParams(updateJobParams, existingJobDefinition.Properties);
existingJobDefinition.Properties = jobProperties;
}
private ScheduledJobDefinition CreateScriptBlockDefinition()
{
JobDefinition jobDefinition = new JobDefinition(typeof(ScheduledJobSourceAdapter), ScriptBlock.ToString(), _name);
jobDefinition.ModuleName = ModuleName;
Dictionary<string, object> parameterCollection = CreateCommonParameters();
// ScriptBlock, mandatory
parameterCollection.Add(ScheduledJobInvocationInfo.ScriptBlockParameter, ScriptBlock);
JobInvocationInfo jobInvocationInfo = new ScheduledJobInvocationInfo(jobDefinition, parameterCollection);
ScheduledJobDefinition definition = new ScheduledJobDefinition(jobInvocationInfo, Trigger,
ScheduledJobOption, _credential);
return definition;
}
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);
}
internal WorkflowJobDefinition(JobDefinition jobDefinition) : this(jobDefinition, string.Empty, WorkflowJobDefinition.EmptyEnumerable, string.Empty, string.Empty)
{
}
private JobSourceAdapter GetJobSourceAdapter(JobDefinition definition)
{
string jobSourceAdapterTypeName;
JobSourceAdapter adapter;
if (!string.IsNullOrEmpty(definition.JobSourceAdapterTypeName))
{
jobSourceAdapterTypeName = definition.JobSourceAdapterTypeName;
}
else
{
if (definition.JobSourceAdapterType == null)
{
throw new InvalidOperationException(ResourceManagerCache.GetResourceString("RemotingErrorIdStrings", "JobSourceAdapterNotFound"));
}
jobSourceAdapterTypeName = definition.JobSourceAdapterType.Name;
}
bool flag = false;
lock (this._syncObject)
{
flag = this._sourceAdapters.TryGetValue(jobSourceAdapterTypeName, out adapter);
}
if (flag)
{
return(adapter);
}
if (string.IsNullOrEmpty(definition.ModuleName))
{
throw new InvalidOperationException(ResourceManagerCache.GetResourceString("RemotingErrorIdStrings", "JobSourceAdapterNotFound"));
}
Exception innerException = null;
try
{
InitialSessionState initialSessionState = InitialSessionState.CreateDefault2();
initialSessionState.Commands.Clear();
initialSessionState.Formats.Clear();
initialSessionState.Commands.Add(new SessionStateCmdletEntry("Import-Module", typeof(ImportModuleCommand), null));
using (PowerShell shell = PowerShell.Create(initialSessionState))
{
shell.AddCommand("Import-Module");
shell.AddParameter("Name", definition.ModuleName);
shell.Invoke();
if (shell.ErrorBuffer.Count > 0)
{
innerException = shell.ErrorBuffer[0].Exception;
}
}
}
catch (RuntimeException exception2)
{
innerException = exception2;
}
catch (InvalidOperationException exception3)
{
innerException = exception3;
}
catch (ScriptCallDepthException exception4)
{
innerException = exception4;
}
catch (SecurityException exception5)
{
innerException = exception5;
}
catch (ThreadAbortException exception6)
{
innerException = exception6;
}
if (innerException != null)
{
throw new InvalidOperationException(ResourceManagerCache.GetResourceString("RemotingErrorIdStrings", "JobSourceAdapterNotFound"), innerException);
}
return(this.AssertAndReturnJobSourceAdapter(jobSourceAdapterTypeName));
}
private void UpdateJobInvocationInfo()
{
string command;
Dictionary<string, object> strs = this.UpdateParameters();
string name = this._definition.Name;
if (this.ScriptBlock == null)
{
if (this.FilePath == null)
{
command = this._definition.InvocationInfo.Command;
}
else
{
command = this.FilePath;
}
}
else
{
command = this.ScriptBlock.ToString();
}
JobDefinition jobDefinition = new JobDefinition(typeof(ScheduledJobSourceAdapter), command, name);
jobDefinition.ModuleName = "PSScheduledJob";
JobInvocationInfo scheduledJobInvocationInfo = new ScheduledJobInvocationInfo(jobDefinition, strs);
this._definition.UpdateJobInvocationInfo(scheduledJobInvocationInfo, false);
}
private ScheduledJobDefinition CreateScriptBlockDefinition()
{
JobDefinition jobDefinition = new JobDefinition(typeof(ScheduledJobSourceAdapter), this.ScriptBlock.ToString(), this._name);
jobDefinition.ModuleName = "PSScheduledJob";
Dictionary<string, object> strs = this.CreateCommonParameters();
strs.Add("ScriptBlock", this.ScriptBlock);
JobInvocationInfo scheduledJobInvocationInfo = new ScheduledJobInvocationInfo(jobDefinition, strs);
ScheduledJobDefinition scheduledJobDefinition = new ScheduledJobDefinition(scheduledJobInvocationInfo, this.Trigger, this.ScheduledJobOption, this._credential);
return scheduledJobDefinition;
}
internal WorkflowJobDefinition(JobDefinition jobDefinition, string modulePath, IEnumerable<string> dependentWorkflows, string dependentAssemblyPath, string xaml) : this(jobDefinition.JobSourceAdapterType, jobDefinition.Command, jobDefinition.Name, modulePath, dependentWorkflows, dependentAssemblyPath, xaml)
{
base.InstanceId = jobDefinition.InstanceId;
}
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);
}
}
}
internal static WorkflowJobDefinition AsWorkflowJobDefinition(JobDefinition definition)
{
WorkflowJobDefinition workflowJobDefinition = definition as WorkflowJobDefinition;
WorkflowJobDefinition workflowJobDefinition1 = workflowJobDefinition;
if (workflowJobDefinition == null)
{
WorkflowJobDefinition workflowJobDefinition2 = DefinitionCache.Instance.GetDefinition(definition.InstanceId) as WorkflowJobDefinition;
workflowJobDefinition1 = workflowJobDefinition2;
if (workflowJobDefinition2 == null)
{
workflowJobDefinition1 = new WorkflowJobDefinition(definition);
}
}
return workflowJobDefinition1;
}
/// <summary>
///
/// </summary>
/// <param name="definition"></param>
/// <param name="parameters"></param>
public JobInvocationInfo(JobDefinition definition, IEnumerable<CommandParameterCollection> parameters)
{
_definition = definition;
if (parameters == null) return;
foreach (var parameter in parameters)
{
Parameters.Add(parameter);
}
}
/// <summary>
/// Create a new job with the specified definition
/// </summary>
/// <param name="definition">job definition to use</param>
/// <returns>job object</returns>
public Job2 NewJob(JobDefinition definition)
{
return(NewJob(new JobInvocationInfo(definition, new Dictionary <string, object>())));
}
private ScheduledJobDefinition CreateFilePathDefinition()
{
JobDefinition jobDefinition = new JobDefinition(typeof(ScheduledJobSourceAdapter), FilePath, _name);
jobDefinition.ModuleName = ModuleName;
Dictionary<string, object> parameterCollection = CreateCommonParameters();
// FilePath, mandatory
if (!FilePath.EndsWith(".ps1", StringComparison.OrdinalIgnoreCase))
{
string msg = StringUtil.Format(ScheduledJobErrorStrings.InvalidFilePathFile);
Exception reason = new RuntimeException(msg);
ErrorRecord errorRecord = new ErrorRecord(reason, "InvalidFilePathParameterForRegisterScheduledJobDefinition", ErrorCategory.InvalidArgument, this);
WriteError(errorRecord);
return null;
}
Collection<PathInfo> pathInfos = SessionState.Path.GetResolvedPSPathFromPSPath(FilePath);
if (pathInfos.Count != 1)
{
string msg = StringUtil.Format(ScheduledJobErrorStrings.InvalidFilePath);
Exception reason = new RuntimeException(msg);
ErrorRecord errorRecord = new ErrorRecord(reason, "InvalidFilePathParameterForRegisterScheduledJobDefinition", ErrorCategory.InvalidArgument, this);
WriteError(errorRecord);
return null;
}
parameterCollection.Add(ScheduledJobInvocationInfo.FilePathParameter, pathInfos[0].Path);
JobInvocationInfo jobInvocationInfo = new ScheduledJobInvocationInfo(jobDefinition, parameterCollection);
ScheduledJobDefinition definition = new ScheduledJobDefinition(jobInvocationInfo, Trigger,
ScheduledJobOption, _credential);
return definition;
}
/// <summary>
/// Helper method to find and return the job source adapter if currently loaded or
/// otherwise load the associated module and the requested source adapter.
/// </summary>
/// <param name="definition">JobDefinition supplies the JobSourceAdapter information.</param>
/// <returns>JobSourceAdapter.</returns>
private JobSourceAdapter GetJobSourceAdapter(JobDefinition definition)
{
string adapterTypeName;
if (!string.IsNullOrEmpty(definition.JobSourceAdapterTypeName))
{
adapterTypeName = definition.JobSourceAdapterTypeName;
}
else if (definition.JobSourceAdapterType != null)
{
adapterTypeName = definition.JobSourceAdapterType.Name;
}
else
{
throw new InvalidOperationException(RemotingErrorIdStrings.JobSourceAdapterNotFound);
}
JobSourceAdapter adapter;
bool adapterFound = false;
lock (_syncObject)
{
adapterFound = _sourceAdapters.TryGetValue(adapterTypeName, out adapter);
}
if (!adapterFound)
{
if (!string.IsNullOrEmpty(definition.ModuleName))
{
// Attempt to load the module.
Exception ex = null;
try
{
InitialSessionState iss = InitialSessionState.CreateDefault2();
iss.Commands.Clear();
iss.Formats.Clear();
iss.Commands.Add(new SessionStateCmdletEntry("Import-Module", typeof(Microsoft.PowerShell.Commands.ImportModuleCommand), null));
using (PowerShell powerShell = PowerShell.Create(iss))
{
powerShell.AddCommand("Import-Module");
powerShell.AddParameter("Name", definition.ModuleName);
powerShell.Invoke();
if (powerShell.ErrorBuffer.Count > 0)
{
ex = powerShell.ErrorBuffer[0].Exception;
}
}
}
catch (RuntimeException e)
{
ex = e;
}
catch (InvalidOperationException e)
{
ex = e;
}
catch (ScriptCallDepthException e)
{
ex = e;
}
catch (SecurityException e)
{
ex = e;
}
catch (ThreadAbortException e)
{
ex = e;
}
if (ex != null)
{
throw new InvalidOperationException(RemotingErrorIdStrings.JobSourceAdapterNotFound, ex);
}
// Now try getting the job source adapter again.
adapter = AssertAndReturnJobSourceAdapter(adapterTypeName);
}
else
{
throw new InvalidOperationException(RemotingErrorIdStrings.JobSourceAdapterNotFound);
}
}
return(adapter);
}
internal Activity GetActivity(JobDefinition definition, string xaml)
{
bool flag = false;
WorkflowJobDefinition workflowJobDefinition = new WorkflowJobDefinition(definition, string.Empty, WorkflowJobDefinition.EmptyEnumerable, string.Empty, xaml);
Activity activityFromCache = this.GetActivityFromCache(workflowJobDefinition, out flag);
Activity activity = activityFromCache;
if (activityFromCache == null)
{
activity = this.CompileActivityAndSaveInCache(workflowJobDefinition, null, null, out flag);
}
Activity activity1 = activity;
return activity1;
}
internal Activity GetActivity(JobDefinition definition, string xaml, string[] dependentWorkflows)
{
bool flag = false;
IEnumerable<string> emptyEnumerable;
JobDefinition jobDefinition = definition;
string empty = string.Empty;
string[] strArrays = dependentWorkflows;
if (strArrays != null)
{
emptyEnumerable = (IEnumerable<string>)strArrays;
}
else
{
emptyEnumerable = WorkflowJobDefinition.EmptyEnumerable;
}
WorkflowJobDefinition workflowJobDefinition = new WorkflowJobDefinition(jobDefinition, empty, emptyEnumerable, string.Empty, xaml);
Activity activityFromCache = this.GetActivityFromCache(workflowJobDefinition, out flag);
Activity activity = activityFromCache;
if (activityFromCache == null)
{
activity = this.CompileActivityAndSaveInCache(workflowJobDefinition, null, null, out flag);
}
Activity activity1 = activity;
return activity1;
}
internal Activity GetActivity(JobDefinition definition, out bool windowsWorkflow)
{
WorkflowJobDefinition workflowJobDefinition = new WorkflowJobDefinition(definition);
Activity activityFromCache = this.GetActivityFromCache(workflowJobDefinition, out windowsWorkflow);
Activity activity = activityFromCache;
if (activityFromCache == null)
{
activity = this.CompileActivityAndSaveInCache(workflowJobDefinition, null, null, out windowsWorkflow);
}
Activity activity1 = activity;
return activity1;
}
/// <summary>
/// </summary>
/// <param name="definition"></param>
/// <param name="parameters"></param>
public JobInvocationInfo(JobDefinition definition, CommandParameterCollection parameters)
{
_definition = definition;
Parameters.Add(parameters ?? new CommandParameterCollection());
}
internal bool RemoveCachedActivity(JobDefinition definition)
{
Activity activity = null;
bool flag;
WorkflowJobDefinition workflowJobDefinition = new WorkflowJobDefinition(definition);
this._cachedActivities.TryRemove(workflowJobDefinition, out activity);
lock (this._syncObject)
{
if (!this._workflowDetailsCache.ContainsKey(workflowJobDefinition))
{
return false;
}
else
{
flag = this._workflowDetailsCache.Remove(workflowJobDefinition);
}
}
return flag;
}
/// <summary>
/// Create a new job definition with a single set of parameters.
/// </summary>
/// <param name="definition">The job definition</param>
/// <param name="parameters">The parameter collection to use</param>
public JobInvocationInfo(JobDefinition definition, Dictionary<string, object> parameters)
{
_definition = definition;
var convertedCollection = ConvertDictionaryToParameterCollection(parameters);
if (convertedCollection != null)
{
Parameters.Add(convertedCollection);
}
}
internal bool RemoveCachedActivity(Guid instanceId)
{
JobDefinition jobDefinition = new JobDefinition(null, null, null);
jobDefinition.InstanceId = instanceId;
return this.RemoveCachedActivity(jobDefinition);
}
/// <summary>
///
/// </summary>
/// <param name="definition"></param>
/// <param name="parameters"></param>
public JobInvocationInfo(JobDefinition definition, CommandParameterCollection parameters)
{
_definition = definition;
Parameters.Add(parameters ?? new CommandParameterCollection());
}
/// <summary>
/// Create new ScheduledJobInvocationInfo object with update information and
/// update the job definition object.
/// </summary>
private void UpdateJobInvocationInfo()
{
Dictionary<string, object> parameters = UpdateParameters();
string name = _definition.Name;
string command;
if (ScriptBlock != null)
{
command = ScriptBlock.ToString();
}
else if (FilePath != null)
{
command = FilePath;
}
else
{
command = _definition.InvocationInfo.Command;
}
JobDefinition jobDefinition = new JobDefinition(typeof(ScheduledJobSourceAdapter), command, name);
jobDefinition.ModuleName = ModuleName;
JobInvocationInfo jobInvocationInfo = new ScheduledJobInvocationInfo(jobDefinition, parameters);
_definition.UpdateJobInvocationInfo(jobInvocationInfo, false);
}
/// <summary>
/// Create a new job with the specified definition
/// </summary>
/// <param name="definition">job definition to use</param>
/// <returns>job object</returns>
public Job2 NewJob(JobDefinition definition)
{
return NewJob(new JobInvocationInfo(definition, new Dictionary<string, object>()));
}
/// <summary>
/// Create a job.
/// </summary>
/// <param name="createJobParams">Job properties entered via powershell.</param>
/// <returns>The Job definition.</returns>
public PSSchedulerJobDefinition CreateJob(PSJobParams createJobParams)
{
if (string.IsNullOrWhiteSpace(createJobParams.ResourceGroupName))
{
throw new PSManagement.PSArgumentNullException(paramName: "ResourceGroupName");
}
if (string.IsNullOrWhiteSpace(createJobParams.JobCollectionName))
{
throw new PSManagement.PSArgumentNullException(paramName: "JobCollectionName");
}
if (string.IsNullOrWhiteSpace(createJobParams.JobName))
{
throw new PSManagement.PSArgumentNullException(paramName: "JobName");
}
if (!DoesResourceGroupExists(createJobParams.ResourceGroupName))
{
throw new PSManagement.PSArgumentException(Resources.SchedulerInvalidResourceGroup);
}
IList<JobCollectionDefinition> jobCollection = ListJobCollection(createJobParams.ResourceGroupName, createJobParams.JobCollectionName);
if (jobCollection == null || jobCollection.Count < 1)
{
throw new PSManagement.PSInvalidOperationException(string.Format(Resources.JobCollectionDoesnotExist, createJobParams.JobCollectionName, createJobParams.ResourceGroupName));
}
else
{
if (JobExists(createJobParams.ResourceGroupName, createJobParams.JobCollectionName, createJobParams.JobName))
{
throw new PSManagement.PSArgumentException(string.Format(Resources.SchedulerExistingJob, createJobParams.JobName, createJobParams.JobCollectionName));
}
IList<JobDefinition> listOfJobs = ListJobs(createJobParams.ResourceGroupName, createJobParams.JobCollectionName, jobState: null);
if (listOfJobs != null)
{
Validate(jobCollection[0], listOfJobs.Count);
}
}
JobAction jobAction = this.GetJobAction(createJobParams);
JobRecurrence jobRecurrence = this.GetJobRecurrence(createJobParams.JobRecurrence);
var properties = new JobProperties()
{
Action = jobAction,
Recurrence = jobRecurrence,
StartTime = createJobParams.StartTime,
State = createJobParams.JobState.GetValueOrDefaultEnum<JobState?>(defaultValue: null)
};
var jobDefinition = new JobDefinition(name: createJobParams.JobName)
{
Properties = properties
};
JobDefinition jobDefinitionResult = this.SchedulerManagementClient.Jobs.CreateOrUpdate(createJobParams.ResourceGroupName, createJobParams.JobCollectionName, createJobParams.JobName, jobDefinition);
return Converter.ConvertJobDefinitionToPS(jobDefinitionResult);
}
