/*
* /// <summary>
* /// Configure a trigger for an event to start a process.
* /// </summary>
* public void AddProcessTrigger(Func<RFEvent, bool> evaluator, RFEngineProcessDefinition processConfig)
* {
* Triggers.Add(new RFSingleCommandTrigger(e => evaluator(e) ? new RFParamProcessInstruction(processConfig.Name, null) : null));
* }
*/
/// <summary>
/// Define a new process inside the engine triggered by a key update.
/// </summary>
/// <param name="processName">Unique user-friendly name.</param>
/// <param name="processor">
/// Function that creates the processor (may pass static config etc.)
/// </param>
/// <param name="triggerKey">Key that triggers the execution (matched by root).</param>
/// <returns></returns>
public RFEngineProcessDefinition AddProcessWithCatalogTrigger <P>(string processName, string description, Func <IRFEngineProcessor> processor,
RFCatalogKey triggerKey) where P : RFEngineProcessorParam
{
if (Processes.ContainsKey(processName))
{
throw new Exception(String.Format("Already registered process {0}", processName));
}
var p = processor(); // test instantiation
//Func<RFInstruction, RFEngineProcessorParam> instanceParams = i => i.ExtractParam();// new P().ExtractFrom;
var newProcess = new RFEngineProcessDefinition
{
Name = processName,
InstanceParams = i => i.ExtractParam()?.ConvertTo <P>(),
Processor = processor,
Description = description,
IsExclusive = p.IsExclusive
};
Processes.Add(processName, newProcess);
AddCatalogUpdateTrigger <RFCatalogKey>(k => k.MatchesRoot(triggerKey), newProcess);
return(newProcess);
}
/// <summary>
/// Configure a trigger to run a process on each interval (for schedulers).
/// </summary>
/// <param name="processConfig"></param>
public void AddIntervalTrigger(RFEngineProcessDefinition processConfig)
{
AddTrigger(new RFSingleCommandTrigger(e => e is RFIntervalEvent ie ?
new RFIntervalInstruction(processConfig.Name, ie) : null));
/*AddCatalogUpdateTrigger<RFCatalogKey>(
* i => i.Equals(IntervalDocumentKey()),
* processConfig);*/
}
/// <summary>
/// Configures process to automatically run after another process
/// </summary>
/// <param name="taskName"></param>
/// <param name="triggeringProcess"></param>
/// <param name="triggeredProcess"></param>
/// <returns></returns>
public RFEngineTaskDefinition AddChainedTask(string taskName, RFEngineProcessDefinition triggeringProcess, RFEngineProcessDefinition triggeredProcess, bool isSystem)
{
var task = new RFChainedEngineTaskDefinition
{
TaskName = taskName,
TaskProcess = triggeredProcess,
TriggerProcess = triggeringProcess,
IsSystem = isSystem
};
Tasks.Add(task);
task.AddToEngine(this);
return(task);
}
/// <summary>
/// Configures process to automatically run based on configuration
/// </summary>
/// <param name="taskName"></param>
/// <param name="process"></param>
/// <param name="isExclusive">If set the task won't run concurrently</param>
/// <param name="isSystem"></param>
/// <returns></returns>
public RFEngineTaskDefinition AddScheduledTask(string taskName, RFEngineProcessDefinition process, bool isSystem = false)
{
var task = new RFSchedulerTaskDefinition
{
RangeFunc = c => RFSchedulerRange.ReadFromConfig(RFSchedulerTaskDefinition.CONFIG_SECTION, taskName, c.UserConfig),
SchedulesFunc = c => RFSchedulerSchedule.ReadFromConfig(RFSchedulerTaskDefinition.CONFIG_SECTION, taskName, c.UserConfig).Single(),
TaskName = taskName,
TaskProcess = process,
IsSystem = isSystem
};
Tasks.Add(task);
task.AddToEngine(this);
return(task);
}
/// <summary>
/// Define a new process inside the engine.
/// </summary>
/// <param name="processName">Unique user-friendly name.</param>
/// <param name="processor">
/// Function that creates the processor (may pass static config etc.)
/// </param>
/// <param name="instanceParams">
/// Function that derives instance parameters based on processing instruction.
/// </param>
/// <returns></returns>
public RFEngineProcessDefinition <P> AddProcess <P>(string processName, string description, Func <RFEngineProcessor <P> > processor, Func <RFInstruction, P> instanceParams = null) where P : RFEngineProcessorParam
{
if (Processes.ContainsKey(processName))
{
throw new Exception(String.Format("Already registered process {0}", processName));
}
var p = processor(); // test instantiation
var newProcess = new RFEngineProcessDefinition <P>
{
Name = processName,
InstanceParams = instanceParams ?? (i => i.ExtractParam()?.ConvertTo <P>()),
Processor = processor,
Description = description,
IsExclusive = p.IsExclusive
};
Processes.Add(processName, newProcess);
return(newProcess);
}
public RFCatalogUpdateTrigger(Func <RFCatalogKey, bool> evaluatorFunc, RFEngineProcessDefinition processConfig) : base(
e => ((e is RFCatalogUpdateEvent) && evaluatorFunc((e as RFCatalogUpdateEvent).Key)) ? new RFParamProcessInstruction(processConfig.Name, new RFEngineProcessorKeyParam((e as RFCatalogUpdateEvent).Key)) : null)
{
}
/// <summary>
/// Configures process to automatically run on catalog update
/// </summary>
/// <param name="taskName"></param>
/// <param name="triggerKey"></param>
/// <param name="process"></param>
/// <returns></returns>
public RFEngineTaskDefinition AddTriggeredTask(string taskName, RFCatalogKey triggerKey, RFEngineProcessDefinition process)
{
var task = new RFTriggeredEngineTaskDefinition
{
TriggerKey = triggerKey,
TaskName = taskName,
TaskProcess = process
};
Tasks.Add(task);
task.AddToEngine(this);
return(task);
}
/// <summary>
/// Configures process to automatically run on specific schedule
/// </summary>
/// <param name="taskName"></param>
/// <param name="schedules"></param>
/// <param name="range"></param>
/// <param name="process"></param>
/// <returns></returns>
public RFEngineTaskDefinition AddScheduledTask(string taskName, Func <List <RFSchedulerSchedule> > schedulesFunc, Func <RFSchedulerRange> rangeFunc, RFEngineProcessDefinition process, bool isSystem)
{
var task = new RFSchedulerTaskDefinition
{
RangeFunc = _ => rangeFunc(),
SchedulesFunc = _ => schedulesFunc(),
TaskName = taskName,
TaskProcess = process,
IsSystem = isSystem
};
Tasks.Add(task);
task.AddToEngine(this);
return(task);
}
/// <summary>
/// Configures process to automatically run on specific schedule
/// </summary>
/// <param name="taskName"></param>
/// <param name="schedules"></param>
/// <param name="range"></param>
/// <param name="process"></param>
/// <returns></returns>
public RFEngineTaskDefinition AddScheduledTask(string taskName, List <RFSchedulerSchedule> schedules, RFSchedulerRange range, RFEngineProcessDefinition process, bool isSystem)
{
return(AddScheduledTask(taskName, () => schedules, () => range, process, isSystem));
}
/// <summary>
/// Configure a trigger for a catalog update to trigger a process (root-based matching)
/// </summary>
/// <typeparam name="K">Subclass of RFCatalogKey</typeparam>
public void AddCatalogUpdateTrigger <K>(Func <K, bool> evaluator, RFEngineProcessDefinition processConfig) where K : RFCatalogKey
{
Triggers.Add(new RFCatalogUpdateTrigger(e => (e is K) && evaluator(e as K), processConfig));
}
public RFEngineProcess(string name, RFEngineProcessDefinition config, RFKeyDomain keyDomain)
{
Name = name;
Config = config;
KeyDomain = keyDomain;
}
