public virtual IFlowEngine NewBRE(IRulesDriver rulesDriver)
{
BREImpl bre = new BREImpl();
// Lets register handlers
if (logHandler != null)
{
bre.LogHandlers += logHandler;
}
if (exceptionHandler != null)
{
bre.ExceptionHandlers += exceptionHandler;
}
if (resultHandler != null)
{
bre.ResultHandlers += resultHandler;
}
if (!bre.Init(rulesDriver))
{
return(null);
}
else
{
return(bre);
}
}
public TimedRulesDriver(IRulesDriver rulesDriver, Func <IMetrics> metrics, string timerContext = "RulesDriver")
{
_rulesDriver = rulesDriver;
_metrics = new Lazy <IMetrics>(metrics);
_getVersionTimer = timerContext.GetTimer("GetVersion");
_getRulesetTimer = timerContext.GetTimer("GetRuleset");
}
public RulesRepository(IRulesDriver rulesDriver, IRulesetVersionProvider versionProvider, TimeSpan failureDelay,
TimeSpan maxWaitTimeout, ILogger logger = null, IScheduler scheduler = null)
{
logger = logger ?? NullLogger.Instance;
scheduler = scheduler ?? DefaultScheduler.Instance;
_pipeline = Observable.Defer(versionProvider.OnVersion)
.Timeout(maxWaitTimeout)
.Do(_ => LastCheckTime = scheduler.Now.UtcDateTime)
.DistinctUntilChanged()
.Do(version => logger.LogInformation($"Detected new rules version: {version}"))
.Select(version => Observable.FromAsync(ct => rulesDriver.GetRuleset(version, ct)).Do(_ => CurrentLabel = version))
.Switch()
.Do(_ => logger.LogInformation("Updated rules"))
.SubscribeOn(scheduler)
.Catch((Exception exception) =>
{
logger.LogWarning(exception, "Failed to update rules");
return(Observable.Empty <Dictionary <string, RuleDefinition> >()
.Delay(failureDelay));
})
.Repeat()
.Replay(1);
_subscription = new CompositeDisposable(
_pipeline.Subscribe(rules => OnRulesChange?.Invoke(rules)),
_pipeline.Connect()
);
}
public TestScope(IRulesDriver rules, IContextDriver context, Func <Task> init, Func <Task> dispose)
{
_rulesDriver = rules;
_contextDriver = context;
_init = init;
_dispose = dispose;
}
public static async Task <TweekIdentityProvider> Create(IRulesDriver driver)
{
var allRules = await driver.GetAllRules();
var initialIdentities = ExtractIdentitiesWithAuth(allRules.Keys);
return(new TweekIdentityProvider(driver, initialIdentities));
}
public override IFlowEngine NewBRE(IRulesDriver rulesDriver)
{
if (bref == null)
bref = new BREFactory(new DispatchException(HandleExceptionEvent),
new DispatchLog(HandleLogEvent));
return bref.NewBRE(rulesDriver);
}
public IFlowEngine NewBRE(IRulesDriver rulesDriver) {
BREImpl bre = new BREImpl();
// Lets register the result handler
if (resultHandler != null) bre.ResultHandlers += resultHandler;
if (!bre.Init(rulesDriver)) return null;
else return bre;
}
private TweekIdentityProvider(IRulesDriver driver, HashSet <string> initialIdentitiesWithAuth)
{
_identitiesWithAuth = initialIdentitiesWithAuth;
driver.OnRulesChange += (newRules) =>
{
_identitiesWithAuth = ExtractIdentitiesWithAuth(newRules.Keys);
};
}
public BRECloneFactory(IRulesDriver rulesDriver, DispatchRuleResult resultHandler)
{
if (rulesDriver == null)
throw new BREException("A non-null IRulesDriver must be passed to BRECloneFactory");
this.rulesDriver = rulesDriver;
if (bref == null) bref = new BREFactory(resultHandler);
}
public IFlowEngine NewBRE(IRulesDriver rulesDriver)
{
if (bref == null)
{
bref = new BREFactory();
}
return(bref.NewBRE(rulesDriver));
}
/// <summary> Initializes the object.<P>
/// The default constructor exists so that objects may register
/// as listeners before any action takes place.
/// </P>
/// </summary>
/// <param name="aObj">The XML configuration document
/// (either System.Xml.XPath.XPathDocument or string poiting to a XML file
/// </param>
/// <returns> True if successful, False otherwise
///
/// </returns>
public bool Init(object aObj)
{
if (running)
{
DispatchException("BRE already running: a violent Stop will be tried!", LogEventImpl.ERROR);
Stop();
}
else
{
DispatchLog("BRE Starting...", LogEventImpl.INFO);
}
if (aObj == null)
{
DispatchException("Business Rules provided by external entity\nObject passed to init() must not be Null", LogEventImpl.FATAL);
return(false);
}
if (aObj is IRulesDriver)
{
rulesDriver = (IRulesDriver)aObj;
rulesDriver.LogDispatcher = this;
xmlDocument = null;
}
else if (aObj is XPathDocument)
{
xmlDocument = (XPathDocument)aObj;
}
else
{
DispatchException("Business Rules provided by external entity\nObject passed to init() must be of type System.Xml.XPath.XPathDocument or org.nxbre.ri.drivers.IRulesDriver and not " + aObj.GetType(), LogEventImpl.FATAL);
return(false);
}
DispatchLog("BRE Initializing...", LogEventImpl.INFO);
if (ruleContext == null)
{
ruleContext = new BRERuleContextImpl(new Stack(),
new Hashtable(),
new Hashtable(),
new Hashtable());
}
// pre-load all operators
foreach (Type type in Assembly.GetExecutingAssembly().GetTypes())
{
if (null != type.GetInterface(typeof(IBREOperator).FullName, false))
{
GetOperator(type.FullName);
}
}
// pre-load factories
initialized = LoadFactories(GetXmlDocumentRules().Select("//" + RULE + "[@" + RULE_ATTRS.FACTORY + "]"));
return(initialized);
}
public override IFlowEngine NewBRE(IRulesDriver rulesDriver)
{
if (bref == null)
{
bref = new BREFactory(new DispatchException(HandleExceptionEvent),
new DispatchLog(HandleLogEvent));
}
return(bref.NewBRE(rulesDriver));
}
private void Init(IRulesDriver driver)
{
bre = new BREFactory(new DispatchException(HandleExceptionEvent)).NewBRE(driver);
prepared_bre = null;
if (bre == null)
{
throw new BREException("The initialization of the Flow Engine Binder failed.");
}
}
public virtual IFlowEngine NewBRE(IRulesDriver rulesDriver) {
BREImpl bre = new BREImpl();
// Lets register handlers
if (logHandler != null) bre.LogHandlers += logHandler;
if (exceptionHandler != null) bre.ExceptionHandlers += exceptionHandler;
if (resultHandler != null) bre.ResultHandlers += resultHandler;
if (!bre.Init(rulesDriver)) return null;
else return bre;
}
public IFlowEngine NewBRE(IRulesDriver rulesDriver)
{
var bre = new BREImpl();
// Lets register the result handler
if (resultHandler != null)
{
bre.ResultHandlers += resultHandler;
}
return(!bre.Init(rulesDriver) ? null : bre);
}
public static async Task <Func <(RulesRepository, PathExpander)> > Factory(IRulesDriver driver, GetRuleParser parserResolver)
{
var instance = Parse(await driver.GetAllRules(), parserResolver);
driver.OnRulesChange += (newRules) =>
{
using (TraceTime("loading new rules"))
{
instance = Parse(newRules, parserResolver);
}
};
return(() => instance);
}
public BRECloneFactory(IRulesDriver rulesDriver, DispatchRuleResult resultHandler)
{
if (rulesDriver == null)
{
throw new BREException("A non-null IRulesDriver must be passed to BRECloneFactory");
}
this.rulesDriver = rulesDriver;
if (bref == null)
{
bref = new BREFactory(resultHandler);
}
}
private void Init(IRulesDriver driver)
{
// listen to events from Flow Engine and Flow Engine Rule Base
TraceListener tl = new FEBErrorListener();
Logger.FlowEngineSource.Listeners.Add(tl);
Logger.FlowEngineRuleBaseSource.Listeners.Add(tl);
// instantiate the rule engine
bre = new BREFactory().NewBRE(driver);
prepared_bre = null;
if (bre == null)
{
throw new BREException("The initialization of the Flow Engine Binder failed.");
}
}
public IFlowEngine NewBRE(IRulesDriver rulesDriver)
{
BREImpl bre = new BREImpl();
// Lets register the result handler
if (resultHandler != null)
{
bre.ResultHandlers += resultHandler;
}
if (!bre.Init(rulesDriver))
{
return(null);
}
else
{
return(bre);
}
}
public BRECloneFactory(IRulesDriver rulesDriver)
: this(rulesDriver, null)
{
}
private bool DoInit(object aObj)
{
if (running) {
if (Logger.IsFlowEngineError) Logger.FlowEngineSource.TraceEvent(TraceEventType.Error, 0, "BRE already running: a violent Stop will be tried!");
Stop();
}
else {
if (Logger.IsInferenceEngineInformation) Logger.FlowEngineSource.TraceEvent(TraceEventType.Information, 0, "BRE Starting...");
}
if (aObj == null)
{
if (Logger.IsFlowEngineCritical) Logger.FlowEngineSource.TraceEvent(TraceEventType.Critical, 0, "Business Rules provided by external entity\nObject passed to init() must not be Null");
return false;
}
if (aObj is IRulesDriver) {
rulesDriver = (IRulesDriver) aObj;
xmlDocument = null;
}
else if (aObj is XPathDocument) {
xmlDocument = (XPathDocument) aObj;
}
else {
if (Logger.IsFlowEngineCritical) Logger.FlowEngineSource.TraceEvent(TraceEventType.Critical, 0, "Business Rules provided by external entity\nObject passed to init() must be of type System.Xml.XPath.XPathDocument or NxBRE.FlowEngine.IO.IRulesDriver and not " + aObj.GetType());
return false;
}
if (Logger.IsInferenceEngineInformation) Logger.FlowEngineSource.TraceEvent(TraceEventType.Information, 0, "BRE Initializing...");
if (ruleContext == null)
ruleContext = new BRERuleContextImpl(new Stack(),
new Hashtable(),
new Hashtable(),
new Hashtable());
// pre-load all operators
foreach(Type type in Reflection.NxBREAssembly.GetTypes())
if (null != type.GetInterface(typeof(IBREOperator).FullName, false))
GetOperator(type.FullName);
// pre-load factories
initialized = LoadFactories(GetXmlDocumentRules().Select("//"+RULE+"[@"+RULE_ATTRS.FACTORY+"]"));
return initialized;
}
public NatsVersionProvider(IRulesDriver rulesDriver, string natsEndpoint, ILogger logger = null)
{
_rulesDriver = rulesDriver;
_natsEndpoint = natsEndpoint;
_logger = logger ?? NullLogger.Instance;
}
public BRECloneFactory(IRulesDriver rulesDriver,
DispatchException exceptionHandler,
DispatchLog logHandler):this(rulesDriver, exceptionHandler, logHandler, null) {}
/// <summary>
/// Initialize the engine by loading rules from a rules driver.
/// </summary>
/// <param name="rulesDriver"></param>
/// <returns></returns>
public bool Init(IRulesDriver rulesDriver)
{
return DoInit(rulesDriver);
}
/// <summary>
/// Initialize the engine by loading rules from a rules driver.
/// </summary>
/// <param name="rulesDriver"></param>
/// <returns></returns>
public bool Init(IRulesDriver rulesDriver)
{
return(DoInit(rulesDriver));
}
private bool DoInit(object aObj)
{
if (running)
{
if (Logger.IsFlowEngineError)
{
Logger.FlowEngineSource.TraceEvent(TraceEventType.Error, 0, "BRE already running: a violent Stop will be tried!");
}
Stop();
}
else
{
if (Logger.IsInferenceEngineInformation)
{
Logger.FlowEngineSource.TraceEvent(TraceEventType.Information, 0, "BRE Starting...");
}
}
if (aObj == null)
{
if (Logger.IsFlowEngineCritical)
{
Logger.FlowEngineSource.TraceEvent(TraceEventType.Critical, 0, "Business Rules provided by external entity\nObject passed to init() must not be Null");
}
return(false);
}
var obj = aObj as IRulesDriver;
if (obj != null)
{
rulesDriver = obj;
xmlDocument = null;
}
else if (aObj is XPathDocument)
{
xmlDocument = (XPathDocument)aObj;
}
else
{
if (Logger.IsFlowEngineCritical)
{
Logger.FlowEngineSource.TraceEvent(TraceEventType.Critical, 0, "Business Rules provided by external entity\nObject passed to init() must be of type System.Xml.XPath.XPathDocument or NxBRE.FlowEngine.IO.IRulesDriver and not " + aObj.GetType());
}
return(false);
}
if (Logger.IsInferenceEngineInformation)
{
Logger.FlowEngineSource.TraceEvent(TraceEventType.Information, 0, "BRE Initializing...");
}
if (ruleContext == null)
{
ruleContext = new BRERuleContextImpl(new Stack(),
new Hashtable(),
new Hashtable(),
new Hashtable());
}
// pre-load all operators
foreach (var type in Reflection.NxBREAssembly.GetTypes().Where(type => null != type.GetInterface(typeof(IBREOperator).FullName, false)))
{
GetOperator(type.FullName);
}
// pre-load factories
initialized = LoadFactories(GetXmlDocumentRules().Select("//" + RULE + "[@" + RULE_ATTRS.FACTORY + "]"));
return(initialized);
}
private void Init(IRulesDriver driver)
{
// listen to events from Flow Engine and Flow Engine Rule Base
TraceListener tl = new FEBErrorListener();
Logger.FlowEngineSource.Listeners.Add(tl);
Logger.FlowEngineRuleBaseSource.Listeners.Add(tl);
// instantiate the rule engine
bre = new BREFactory().NewBRE(driver);
prepared_bre = null;
if (bre == null) throw new BREException("The initialization of the Flow Engine Binder failed.");
}
public static async Task <ITweek> Create(IRulesDriver rulesDriver, GetRuleParser parserResolver)
{
var rulesLoader = await RulesLoader.Factory(rulesDriver, parserResolver);
return(new TweekRunner(rulesLoader));
}
private void Init(IRulesDriver driver) {
bre = new BREFactory(new DispatchException(HandleExceptionEvent)).NewBRE(driver);
if (bre == null)
throw new BREException("The initialization of the Flow Engine Binder failed.");
}
public IFlowEngine NewBRE(IRulesDriver rulesDriver)
{
if (bref == null) bref = new BREFactory();
return bref.NewBRE(rulesDriver);
}
public SampleVersionProvider(IRulesDriver rulesDriver, TimeSpan sampleInterval)
{
_rulesDriver = rulesDriver;
_sampleInterval = sampleInterval;
}
public BRECloneFactory(IRulesDriver rulesDriver,
DispatchException exceptionHandler,
DispatchLog logHandler) : this(rulesDriver, exceptionHandler, logHandler, null)
{
}
public BRECloneFactory(IRulesDriver rulesDriver) : this(rulesDriver, null, null, null)
{
}
/// <summary> Initializes the object.<P>
/// The default constructor exists so that objects may register
/// as listeners before any action takes place.
/// </P>
/// </summary>
/// <param name="aObj">The XML configuration document
/// (either System.Xml.XPath.XPathDocument or string poiting to a XML file
/// </param>
/// <returns> True if successful, False otherwise
///
/// </returns>
public bool Init(object aObj)
{
if (running) {
DispatchException("BRE already running: a violent Stop will be tried!", LogEventImpl.ERROR);
Stop();
}
else DispatchLog("BRE Starting...", LogEventImpl.INFO);
if (aObj == null)
{
DispatchException("Business Rules provided by external entity\nObject passed to init() must not be Null", LogEventImpl.FATAL);
return false;
}
if (aObj is IRulesDriver) {
rulesDriver = (IRulesDriver) aObj;
rulesDriver.LogDispatcher = this;
xmlDocument = null;
}
else if (aObj is XPathDocument) xmlDocument = (XPathDocument) aObj;
else
{
DispatchException("Business Rules provided by external entity\nObject passed to init() must be of type System.Xml.XPath.XPathDocument or org.nxbre.ri.drivers.IRulesDriver and not "+aObj.GetType(), LogEventImpl.FATAL);
return false;
}
DispatchLog("BRE Initializing...", LogEventImpl.INFO);
if (ruleContext == null)
ruleContext = new BRERuleContextImpl(new Stack(),
new Hashtable(),
new Hashtable(),
new Hashtable());
// pre-load all operators
foreach(Type type in Assembly.GetExecutingAssembly().GetTypes())
if (null != type.GetInterface(typeof(IBREOperator).FullName, false))
GetOperator(type.FullName);
// pre-load factories
initialized = LoadFactories(GetXmlDocumentRules().Select("//"+RULE+"[@"+RULE_ATTRS.FACTORY+"]"));
return initialized;
}
public RulesDriverDiagnosticsProvider(IRulesDriver driver)
{
_driver = driver;
}
public RulesDriverStatusService(IRulesDriver rulesDriver)
{
_rulesDriver = rulesDriver;
_rulesDriver.OnRulesChange += OnRulesChange;
}
public RepoVersionController(IRulesDriver rulesDriver)
{
_rulesDriver = rulesDriver;
}