private void StartActivator(AutomationConfiguration configuration, Job job)
{
if (string.IsNullOrEmpty(job.Activator))
{
return;
}
this.Log.Info($"Starting the activator {job.Activator}");
var activatorConfiguration = configuration.Activators.SingleOrDefault(x => x.Id == job.Activator) ??
throw new ConfigurationException($"The activator {job.Activator} cannot be found");
var activator = Factory.CreateActivator(activatorConfiguration);
var messageProvider = activator as BaseMessageProvider ??
throw new ConfigurationException($"The activator {job.Activator} is not a BaseMessageProvider");
messageProvider.MessageReceived += (sender, message) => { this.ProcessMessageReceived(configuration, job, message); };
lock (RunningActivators)
{
RunningActivators.Add(activator);
activator.Start(activatorConfiguration.Config);
}
}
/// <summary>
/// Create a new instance of the processor.
/// </summary>
/// <param name="automationConfiguration">The configuration file of the automation.</param>
/// <param name="ruleId">The id of the rule to create.</param>
/// <returns>The instance of the rule.</returns>
public static IRule CreateRule(AutomationConfiguration automationConfiguration, string ruleId)
{
var ruleConfiguration = automationConfiguration.Rules.SingleOrDefault(x => x.Id == ruleId) ??
throw new ConfigurationException($"The rule {ruleId} cannot be found");
return(CreateRule(ruleConfiguration));
}
/// <summary>
/// Create a new instance of the processor.
/// </summary>
/// <param name="automationConfiguration">The configuration file of the automation.</param>
/// <param name="processorId">The id of the processor to create.</param>
/// <returns>The instance of the processor.</returns>
public static IProcessor CreateProcessor(AutomationConfiguration automationConfiguration, string processorId)
{
var processorConfiguration = automationConfiguration.Processors.SingleOrDefault(x => x.Id == processorId) ??
throw new ConfigurationException($"The processor {processorId} cannot be found");
return(CreateProcessor(processorConfiguration));
}
private void WakeUpActivator(AutomationConfiguration configuration, Job job)
{
if (string.IsNullOrEmpty(job.Activator))
{
return;
}
this.Log.Info($"WakeUp the activator {job.Activator}");
var activatorConfiguration = configuration.Activators.SingleOrDefault(x => x.Id == job.Activator) ??
throw new ConfigurationException($"The activator {job.Activator} cannot be found");
IActivator runningActivator;
lock (RunningActivators)
{
runningActivator = RunningActivators.FirstOrDefault(x => x.Id == job.Activator);
if (runningActivator == null)
{
throw new ConfigurationException($"The activator {job.Activator} is not running, ensure the RunAtStartup is true.");
}
}
runningActivator.WakeUp(activatorConfiguration.Config);
}
private void StartAutomation()
{
var configurationPath = Path.Combine(this.Environment.ContentRootPath, "configuration.json");
if (!File.Exists(configurationPath))
{
Log.Error($"Cannot find the configuration file {configurationPath} to register jobs.");
return;
}
var configuration = AutomationConfiguration.Read(configurationPath);
foreach (var job in configuration.Jobs.Where(job => job.RunAtStartup))
{
BackgroundJob.Enqueue <AutomationRunner>(automation => automation.RunAtStartup(configuration, job));
}
foreach (var job in configuration.Jobs)
{
RecurringJob.RemoveIfExists(job.Id);
}
foreach (var job in configuration.Jobs.Where(job => !string.IsNullOrWhiteSpace(job.CronSchedule)))
{
RecurringJob.AddOrUpdate <AutomationRunner>(job.Id, automation => automation.RunRecurring(configuration, job), job.CronSchedule, TimeZoneInfo.Utc);
}
}
/// <summary>
/// Run the specified job at startup.
/// </summary>
/// <param name="configuration">The complete configuration.</param>
/// <param name="job">The job to be executed.</param>
public void RunAtStartup(AutomationConfiguration configuration, Job job)
{
this.Log.Info($"Starting the job : {job.FriendlyName}");
this.RunConnector(configuration, job);
this.StartActivator(configuration, job);
}
public void Setup()
{
Console.WriteLine("Setup");
Armoury = Get <Armoury>();
VerificationErrors = new StringBuilder();
Configuration = Get <AutomationConfiguration>();
}
private AutomationInstance CreateAutomation(string uid, AutomationConfiguration configuration, WirehomeDictionary settings)
{
var repositoryEntitySource = _repositoryService.LoadEntity(configuration.Logic.Uid);
var scriptHost = _pythonScriptHostFactoryService.CreateScriptHost(_logger, new AutomationPythonProxy(uid, this));
scriptHost.Initialize(repositoryEntitySource.Script);
var context = new WirehomeDictionary
{
["automation_uid"] = uid,
["logic_id"] = configuration.Logic.Uid.Id,
["logic_version"] = configuration.Logic.Uid.Version
};
// TODO: Remove scope as soon as all automations are migrated.
scriptHost.SetVariable("scope", context);
scriptHost.SetVariable("context", context);
foreach (var variable in configuration.Logic.Variables)
{
scriptHost.SetVariable(variable.Key, variable.Value);
}
var automation = new AutomationInstance(uid, scriptHost);
foreach (var setting in settings)
{
automation.Settings[setting.Key] = setting.Value;
}
return(automation);
}
public ErrorditeDriver(AutomationSession automationSession, AutomationConfiguration configuration, IAppSession appSession)
{
_webDriver = new FirefoxDriver();
_webDriver.Manage().Timeouts().ImplicitlyWait(TimeSpan.FromSeconds(5)); //wait for 5 seconds
_automationSession = automationSession;
_configuration = configuration;
_appSession = appSession;
}
public void InitializeAutomation(string uid, AutomationConfiguration configuration)
{
if (uid == null)
{
throw new ArgumentNullException(nameof(uid));
}
if (configuration == null)
{
throw new ArgumentNullException(nameof(configuration));
}
if (!configuration.IsEnabled)
{
_logger.Log(LogLevel.Information, $"Automation '{uid}' not initialized because it is disabled.");
return;
}
var repositoryEntitySource = _repositoryService.LoadEntity(configuration.Logic.Uid);
var scriptHost = _pythonEngineService.CreateScriptHost(_logger);
scriptHost.Initialize(repositoryEntitySource.Script);
var scope = new WirehomeDictionary
{
["automation_uid"] = uid,
["logic_id"] = configuration.Logic.Uid.Id,
["logic_version"] = configuration.Logic.Uid.Version
};
scriptHost.SetVariable("scope", scope);
foreach (var variable in configuration.Logic.Variables)
{
scriptHost.SetVariable(variable.Key, variable.Value);
}
var automationInstance = new Automation(scriptHost);
automationInstance.Initialize();
lock (_automations)
{
if (_automations.TryGetValue(uid, out var existingAutomationInstance))
{
existingAutomationInstance.Deactivate();
}
automationInstance.Activate();
_automations[uid] = automationInstance;
}
_logger.Log(LogLevel.Information, $"Automation '{uid}' initialized.");
}
private void TryInitializeAutomation(string uid, AutomationConfiguration configuration)
{
try
{
InitializeAutomation(uid, configuration);
}
catch (Exception exception)
{
_logger.Log(LogLevel.Error, exception, $"Error while initializing automation '{uid}'.");
}
}
public void WriteAutomationConfiguration(string uid, AutomationConfiguration configuration)
{
if (uid == null)
{
throw new ArgumentNullException(nameof(uid));
}
if (configuration == null)
{
throw new ArgumentNullException(nameof(configuration));
}
_storageService.Write(configuration, AutomationsDirectory, uid, DefaultFilenames.Configuration);
}
/// <inheritdoc />
protected override Message InternalRun(AutomationConfiguration configuration, Job job, Message message)
{
var processor = Factory.CreateProcessor(configuration, this.Processor);
if (string.IsNullOrEmpty(this.RuleId))
{
processor.Execute(job, message);
return(message);
}
var rule = Factory.CreateRule(configuration, this.RuleId);
if (rule.IsMatch(job, message))
{
processor.Execute(job, message);
}
return(message);
}
/// <summary>
/// Start the program.
/// </summary>
/// <param name="args">Arguments of the console.</param>
private static void Main(string[] args)
{
var log4netConfig = new XmlDocument();
log4netConfig.Load(File.OpenRead("log4net.config"));
var repo = LogManager.CreateRepository(Assembly.GetEntryAssembly(), typeof(Hierarchy));
XmlConfigurator.Configure(repo, log4netConfig["log4net"]);
Log.Info("START CONSOLE");
var path = Path.Combine(Path.GetDirectoryName(Assembly.GetExecutingAssembly().Location), "configuration.json");
var configuration = AutomationConfiguration.Read(path);
foreach (var job in configuration.Jobs.Where(job => job.RunAtStartup))
{
new JobRunner().RunAtStartup(configuration, job);
}
Log.Info("STOP CONSOLE");
}
private void RunConnector(AutomationConfiguration configuration, Job job)
{
if (string.IsNullOrEmpty(job.Connector))
{
return;
}
this.Log.Info($"Starting the connector {job.Connector}");
var connectorConfiguration = configuration.Connectors.SingleOrDefault(x => x.Id == job.Connector) ??
throw new ConfigurationException($"The connector {job.Connector} cannot be found");
var connector = Factory.CreateConnector(connectorConfiguration);
var messageProvider = connector as BaseMessageProvider ??
throw new ConfigurationException($"The connector {job.Connector} is not a BaseMessageProvider");
messageProvider.MessageReceived += (sender, message) => { this.ProcessMessageReceived(configuration, job, message); };
connector.Execute(connectorConfiguration.Config);
}
private void ProcessMessageReceived(AutomationConfiguration configuration, Job job, Message message)
{
configuration.ThrowIfNull(nameof(configuration));
job.ThrowIfNull(nameof(job));
message.ThrowIfNull(nameof(message));
this.Log.Info($"{job.Id} : A new message has been received");
foreach (var actionRunner in job.Actions.Select(Factory.CreateAction))
{
try
{
actionRunner.Run(configuration, job, message);
}
catch (Exception e)
{
Console.WriteLine(e);
throw;
}
}
}
public void RunAtStartup(AutomationConfiguration configuration, Job job)
{
new JobRunner().RunAtStartup(configuration, job);
}
/// <summary>
/// Run the specified job multiple times.
/// </summary>
/// <param name="configuration">The complete configuration.</param>
/// <param name="job">The job to be executed.</param>
public void RunRecurring(AutomationConfiguration configuration, Job job)
{
this.Log.Info($"Running the job : {job.FriendlyName}");
this.RunConnector(configuration, job);
this.WakeUpActivator(configuration, job);
}
/// <inheritdoc />
protected override Message InternalRun(AutomationConfiguration configuration, Job job, Message message)
{
return(this.Actions.Select(Factory.CreateAction).Aggregate(message, (current, action) => action.Run(configuration, job, current)));
}
public void Post(string uid, [FromBody] AutomationConfiguration configuration)
{
_automationsRegistryService.InitializeAutomation(uid, configuration);
}
/// <summary>
/// Run the specified action.
/// </summary>
/// <param name="configuration">The configuration of the automation.</param>
/// <param name="job">The source job.</param>
/// <param name="message">The message to process.</param>
/// <returns>Return the message.</returns>
public Message Run(AutomationConfiguration configuration, Job job, Message message)
{
this.Log.Info($"{job.Id} : Running the action type {this.Type}");
return(this.InternalRun(configuration, job, message));
}
/// <summary> /// Run the specified action. /// </summary> /// <param name="configuration">The configuration of the automation.</param> /// <param name="job">The source job.</param> /// <param name="message">The message to process.</param> /// <returns>Return the message.</returns> protected abstract Message InternalRun(AutomationConfiguration configuration, Job job, Message message);
public void PostConfiguration(string uid, [FromBody] AutomationConfiguration configuration)
{
_automationRegistryService.WriteAutomationConfiguration(uid, configuration);
}
public void RunRecurring(AutomationConfiguration configuration, Job job)
{
new JobRunner().RunRecurring(configuration, job);
}