public static void AddToEngine(RFEngineDefinition engineConfig, string connectionString, string environment)
{
var heartbeater = engineConfig.AddProcess(
processName: "System Monitor",
description: "Sends heartbeats to support dashboard",
processor: () => new RFSystemMonitor(new RFSystemMonitor.Config
{
ConnectionString = connectionString,
PublishToDashboard = RFSettings.GetAppSetting("RFMonitors.PublishToDashboard", false),
DashboardURL = RFSettings.GetAppSetting("RFMonitors.DashboardURL", null),
Environment = environment,
StateKey = RFStateKey.CreateKey(engineConfig.KeyDomain, engineConfig.EngineName, "System Monitor", null)
}));
// scheduler to kick off monitoring
var monitoringScheduler = engineConfig.AddProcess(
processName: "Trigger Monitoring",
description: "Timed trigger for system monitoring",
processor: () => new RFSchedulerProcessor(new RFSchedulerConfig
{
Schedules = new List <RFSchedulerSchedule> {
new RFIntervalSchedule(new TimeSpan(0, RFSettings.GetAppSetting("RFMonitors.PublishMinutes", 5), 0))
},
Range = RFWeeklyWindow.AllWeek(),
//IntervalKey = engineConfig.IntervalDocumentKey(),
TriggerKey = RFSchedulerTriggerKey.Create(engineConfig.KeyDomain, MonitoringTriggers.Heartbeat)
}));
engineConfig.AddIntervalTrigger(monitoringScheduler);
engineConfig.AddCatalogUpdateTrigger <RFSchedulerTriggerKey>(t => t.TriggerName == MonitoringTriggers.Heartbeat, heartbeater);
}
public static string Restart(string requestingUser)
{
var serviceName = RFSettings.GetAppSetting("RFMaintainers.ServiceName", null);
if (!string.IsNullOrWhiteSpace(serviceName))
{
var serviceTimeout = TimeSpan.FromSeconds(RFSettings.GetAppSetting("RFMaintainers.ServiceTimeoutSeconds", 60));
RFStatic.Log.Warning(typeof(RFServiceMaintainer), "Service is being restarted on request from {0}", requestingUser);
var service = new ServiceController(serviceName);
try
{
service.Stop();
service.WaitForStatus(ServiceControllerStatus.Stopped, serviceTimeout);
service.Start();
service.WaitForStatus(ServiceControllerStatus.Running, serviceTimeout);
return(SUCCESS);
}
catch (Exception ex)
{
return(ex.InnerException != null?String.Format("{0} : {1}", ex.Message, ex.InnerException.Message) : ex.Message);
}
}
else
{
return("Maintenance not configured");
}
}
public void Send(string subject, params object[] formats)
{
try
{
if (!string.IsNullOrWhiteSpace(Config.To) && Config.Enabled)
{
var sender = RFSettings.GetAppSetting("SmtpSender", null);
if (string.IsNullOrWhiteSpace(subject))
{
throw new RFLogicException(this, "E-mail subject cannot be empty.");
}
var body = GenerateBody();
var mailMessage = new MailMessage
{
Body = body,
IsBodyHtml = true,
From = new MailAddress(sender),
Subject = String.Format(subject, formats),
Sender = new MailAddress(sender)
};
foreach (var recipient in Config.To.Split(new char[] { ',', ';' }, StringSplitOptions.RemoveEmptyEntries))
{
mailMessage.To.Add(recipient.Trim());
}
if (!string.IsNullOrWhiteSpace(Config.Cc))
{
foreach (var cc in Config.Cc.Split(new char[] { ',', ';' }, StringSplitOptions.RemoveEmptyEntries))
{
mailMessage.CC.Add(cc.Trim());
}
}
if (!string.IsNullOrWhiteSpace(Config.Bcc))
{
foreach (var bcc in Config.Bcc.Split(new char[] { ',', ';' }, StringSplitOptions.RemoveEmptyEntries))
{
mailMessage.Bcc.Add(bcc.Trim());
}
}
foreach (var att in Attachments)
{
mailMessage.Attachments.Add(att);
}
mailMessage = PostProcess(mailMessage);
var smtpClient = new SmtpClient();
smtpClient.Send(mailMessage);
}
}
catch (Exception ex)
{
RFStatic.Log.Exception(this, "Send", ex);
throw;
}
}
public static void AddToEngine(RFEngineDefinition engineConfig, string connectionString)
{
var logMaintainer = engineConfig.AddProcess(
processName: "Log Maintainer",
description: "Maintains system log files",
processor: () => new RFLogMaintainer(new RFLogMaintainer.Config
{
ConnectionString = connectionString,
LogArchiveDirectory = RFSettings.GetAppSetting("RFMaintainers.LogArchiveDirectory", null),
LogDirectories = (RFSettings.GetAppSetting("RFMaintainers.LogDirectories", "")).Split(';'),
SystemLogRetentionDays = RFSettings.GetAppSetting("RFMaintainers.SystemLogRetentionDays", 7),
MaintainLogFiles = RFSettings.GetAppSetting("RFMaintainers.MaintainLogFiles", false),
MaintainSystemLog = RFSettings.GetAppSetting("RFMaintainers.MaintainSystemLog", false),
MaintainDispatchQueue = RFSettings.GetAppSetting("RFMaintainers.MaintainDispatchQueue", false)
}));
var catalogMaintainer = engineConfig.AddProcess(
processName: "Catalog Maintainer",
description: "Maintains data catalog",
processor: () => new RFSQLCatalogMaintainer(new RFSQLCatalogMaintainer.Config
{
ConnectionString = connectionString,
MaintainCatalog = RFSettings.GetAppSetting("RFMaintainers.MaintainCatalog", false)
}));
var databaseMaintainer = engineConfig.AddProcess(
processName: "Database Maintainer",
description: "Maintains database backups",
processor: () => new RFDatabaseMaintainer(new RFDatabaseMaintainer.Config
{
ConnectionString = connectionString,
MaintainDatabase = RFSettings.GetAppSetting("RFMaintainers.MaintainDatabase", false),
BackupDirectory = RFSettings.GetAppSetting("RFMaintainers.BackupDirectory", null),
WeeklyRotation = RFSettings.GetAppSetting("RFMaintainers.WeeklyRotation", false),
BackupPassword = RFSettings.GetAppSetting("RFMaintainers.BackupPassword", null),
WorkingDirectoryLocal = RFSettings.GetAppSetting("RFMaintainers.WorkingDirectoryLocal", null),
WorkingDirectoryUNC = RFSettings.GetAppSetting("RFMaintainers.WorkingDirectoryUNC", null),
OptimizeDatabase = RFSettings.GetAppSetting("RFMaintainers.OptimizeDatabase", false)
}));
var maintenanceTime = new TimeSpan(0, 15, 0);
string maintenanceTimeConfig = RFSettings.GetAppSetting("RFMaintainers.MaintenanceTime", null);
if (!string.IsNullOrWhiteSpace(maintenanceTimeConfig))
{
maintenanceTime = TimeSpan.ParseExact(maintenanceTimeConfig, @"hh\:mm", null);
}
engineConfig.AddScheduledTask("Daily Maintenance: Logs", new RFDailySchedule(maintenanceTime).Single(), RFWeeklyWindow.TueSat(), logMaintainer, true);
engineConfig.AddChainedTask("Daily Maintenance: Catalog", logMaintainer, catalogMaintainer, true);
engineConfig.AddChainedTask("Daily Maintenance: Backup", catalogMaintainer, databaseMaintainer, true);
}
public static void InitializeEngine()
{
var builder = new ContainerBuilder();
builder.RegisterControllers(Assembly.GetExecutingAssembly());
builder.RegisterApiControllers(Assembly.GetExecutingAssembly());
var clientControllerAssembly = RFSettings.GetAppSetting("ControllersAssembly", null);
if (!string.IsNullOrWhiteSpace(clientControllerAssembly))
{
builder.RegisterControllers(AppDomain.CurrentDomain.GetAssemblies().FirstOrDefault(a => a.GetModules().First().Name == clientControllerAssembly));
builder.RegisterApiControllers(AppDomain.CurrentDomain.GetAssemblies().FirstOrDefault(a => a.GetModules().First().Name == clientControllerAssembly));
}
var engine = RIFFSection.GetDefaultEngine();
var config = engine.BuildEngineConfiguration();
EngineConfig = engine;
var enableWebProcessing = RFSettings.GetAppSetting("EnableWebProcessing", false);
var context =
enableWebProcessing ?
RFEnvironments.StartConsole(engine.Environment, config, engine.Database, new string[] { "RIFF.Core", "RIFF.Framework", engine.Assembly }).Start() :
RFEnvironments.StartWeb(engine.Environment, engine.Database, new string[] { "RIFF.Core", "RIFF.Framework", engine.Assembly });
UserRole = context.UserRole;
// this context is for read-only operations
builder.RegisterInstance(context).As <IRFProcessingContext>();
builder.RegisterInstance(context).As <IRFSystemContext>();
builder.RegisterInstance(config).As <RFEngineDefinition>();
var engineConsole = config.Console;
if (config.Console == null)
{
throw new Exception("Error initializing engine. Check log for details.");
}
engineConsole.Initialize(context, config, engine.Database);
ConsoleExecutor = new RFConsoleExecutor(config, context, engine, engineConsole);
Context = context;
var httpConfig = GlobalConfiguration.Configuration;
builder.RegisterWebApiFilterProvider(httpConfig);
Container = builder.Build();
DependencyResolver.SetResolver(new AutofacDependencyResolver(Container));
httpConfig.DependencyResolver = new AutofacWebApiDependencyResolver(Container);
}
public RFServiceClient()
{
try
{
var binding = new System.ServiceModel.NetNamedPipeBinding("riffBinding");
var uri = RFSettings.GetAppSetting("RFServiceUri");
var endpoint = new System.ServiceModel.EndpointAddress(uri);
var channelFactory = new ChannelFactory <IRFService>(binding, endpoint);
RFService = channelFactory.CreateChannel();
}
catch
{
if (RFService != null)
{
((ICommunicationObject)RFService).Abort();
}
throw;
}
}
public override void OnAuthorization(AuthorizationContext filterContext)
{
// no permission
if (AccessLevel == RFAccessLevel.NotSet && string.IsNullOrWhiteSpace(Permission))
{
SetCachePolicy(filterContext);
return;
}
if (!filterContext.HttpContext.User.Identity.IsAuthenticated)
{
if (RFSettings.GetAppSetting("DisableAuthentication", false))
{
return;
}
// auth failed, redirect to login page
filterContext.Result = new HttpUnauthorizedResult();
}
var userName = filterContext.HttpContext.User.Identity.Name;
var controllerName = filterContext.RouteData.GetRequiredString("controller");
var areaName = filterContext.RouteData.DataTokens["area"]?.ToString() ?? "Core";
var actionName = filterContext.RouteData.GetRequiredString("action");
var accessOk = AccessLevel == RFAccessLevel.NotSet || RIFFStart.UserRole.HasPermission(userName, areaName, controllerName, AccessLevel.ToString());
var permissionOk = string.IsNullOrWhiteSpace(Permission) || RIFFStart.UserRole.HasPermission(userName, areaName, controllerName, Permission);
if (!accessOk || !permissionOk)
{
RFStatic.Log.Warning(this, "Denying authorization to user {0} to area {1}/{2}/{3}:{4}",
userName, areaName, controllerName, AccessLevel.ToString(), Permission);
var message = String.Format("Unauthorized - permission required: {0}/{1}/{2}/{3}", areaName,
controllerName, AccessLevel.ToString(), Permission);
switch (ResponseType)
{
case ResponseType.Page:
{
var viewData = new ViewDataDictionary(new RIFF.Web.Core.Models.ErrorModel
{
Message = message
});
viewData.Add("Title", "Unauthorized");
filterContext.Result = new ViewResult {
ViewName = "RIFFError", ViewData = viewData
};
}
break;
case ResponseType.Json:
filterContext.Result = new JsonResult
{
ContentType = "application/json",
Data = JsonError.Throw(actionName, message)
};
break;
}
}
else
{
SetCachePolicy(filterContext);
}
}
public void StartEnvironment()
{
try
{
Console.WriteLine("Welcome to RIFF {0}", RFCore.sVersion);
// currently only a single engine is supported
var engine = RIFFSection.GetDefaultEngine();
var engineConfig = engine.BuildEngineConfiguration();
try
{
rfEventLog.WriteEntry(String.Format("Starting engine {0} in environment {1} from {2} (RFCore {3})", engine.EngineName, engine.Environment, engine.Assembly, RFCore.sVersion), EventLogEntryType.Information);
}
catch (SecurityException)
{
RFStatic.Log.Error(this, "EventLog source has not been created. Please run \"RIFF.Service.exe /install\" as Administrator to create.");
return;
}
if (_args != null && _args.Length > 0)
{
_environment = RFEnvironments.StartConsole(engine.Environment, engineConfig, engine.Database, new string[] { engine.Assembly });
_context = _environment.Start();
if (_args[0] == "command")
{
// run console command
var engineConsole = engineConfig.Console;
if (engineConsole != null)
{
engineConsole.Initialize(_context, engineConfig, engine.Database);
}
var executor = new RFConsoleExecutor(engineConfig, _context, engine, engineConsole);
executor.ExecuteCommand(String.Join(" ", _args.Skip(1)));
}
else
{
// run named service
var param = String.Join(" ", _args);
var tokens = new Interfaces.Formats.CSV.CSVParser(param, ' ').Where(t => !string.IsNullOrWhiteSpace(t)).ToArray();
var serviceName = tokens[0];
var serviceParam = tokens.Length > 1 ? tokens[1] : null;
RFStatic.Log.Info(this, $"Starting service: {serviceName}" + (serviceParam != null ? $"with param: {serviceParam}" : string.Empty));
_context.RaiseEvent(this, new RFServiceEvent {
ServiceName = serviceName, ServiceCommand = "start", ServiceParams = serviceParam
});
}
}
else
{
if (RFSettings.GetAppSetting("UseMSMQ", true))
{
CleanUpMSMQ(Environment.MachineName, engine.Environment);
}
// WCF service
_environment = RFEnvironments.StartLocal(engine.Environment, engineConfig, engine.Database, new string[] { engine.Assembly });
_context = _environment.Start();
_context.RaiseEvent(this, new RFServiceEvent {
ServiceName = RFSchedulerService.SERVICE_NAME, ServiceCommand = "start", ServiceParams = null
});
var wcfService = new RFService(_context, engineConfig, engine.Database);
var uriSetting = RFSettings.GetAppSetting("RFServiceUri");
if (uriSetting.NotBlank())
{
_serviceHost = new ServiceHost(wcfService, new Uri(uriSetting));
}
else
{
_serviceHost = new ServiceHost(wcfService);
}
_serviceHost.Open();
}
}
catch (Exception ex)
{
rfEventLog.WriteEntry("OnStart Error: " + ex.Message, EventLogEntryType.Error);
RFStatic.Log.Exception(this, ex, "Error initializing RFService.");
throw;
}
}
public RFMirrorActivity(IRFProcessingContext context, string userName) : base(context, userName)
{
_dc = new RFFrameworkDataContext(RFSettings.GetAppSetting("RFFramework.DataContext"));
_mirrorRoot = RFLocalMirrorSite.GetRootDirectory(RFEnum.FromString("Mirror"), context.UserConfig);
}
