/*
* /// <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);
}
protected static SqlCommand LoadEntryCommand(RFCatalogKey itemKey, int version, SqlConnection connection, SqlTransaction transaction = null)
{
if (itemKey.StoreType != RFStoreType.Document)
{
throw new Exception(String.Format("Unrecognized store type {0}", itemKey.StoreType));
}
SqlCommand sqlCommand = null;
if (transaction != null)
{
sqlCommand = CreateCommand("[RIFF].[GetDocument]", connection, transaction);
}
else
{
sqlCommand = CreateCommand("[RIFF].[GetDocument]", connection);
}
var keyString = itemKey.ToString();
sqlCommand.CommandType = CommandType.StoredProcedure;
sqlCommand.Parameters.AddWithValue("@KeyType", itemKey.GetType().FullName);
sqlCommand.Parameters.AddWithValue("@SerializedKey", keyString);
sqlCommand.Parameters.AddWithValue("@KeyHash", RFStringHelpers.QuickHash(keyString));
sqlCommand.Parameters.AddWithValue("@Version", version);
return(sqlCommand);
}
private void LogKey(RFCatalogKey key)
{
lock (mSync)
{
Keys.Add(key);
KeyCount++;
}
}
public T LoadDocumentContent <T>(RFCatalogKey key, RFCatalogOptions options = null) where T : class
{
var document = (LoadEntry(key, options) as RFDocument);
if (document != null && document.IsValid)
{
return(document.GetContent <T>());
}
return(null);
}
public RFGraphReactor(RFCatalogKey key, RFDateBehaviour dateBehaviour, string processName, IRFReadingContext context, Func <RFGraphInstance, RFDate> dateFunc,
Func <RFDate, RFDate> maxDateFunc)
{
_key = key;
_dateBehaviour = dateBehaviour;
_processName = processName;
_context = context;
_dateFunc = dateFunc;
_maxDateFunc = maxDateFunc;
}
public static RFDocument Create(RFCatalogKey key, object content, RFMetadata metadata = null)
{
return(new RFDocument
{
Key = key,
Content = content,
Type = content.GetType().FullName,
Metadata = metadata
});
}
/// <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);
}
public override RFCatalogKeyMetadata GetKeyMetadata(RFCatalogKey key)
{
var keyType = key.GetType().FullName;
var keyString = key.ToString();
var keyHash = RFStringHelpers.QuickHash(keyString);
//Log.Debug(this, "GetKeyMetadata {0}", keyType);
try
{
var dataTable = new DataTable();
using (var connection = new SqlConnection(_connectionString))
{
connection.Open();
using (var getCommand = CreateCommand("[RIFF].[GetKeyMetadata]", connection))
{
getCommand.CommandType = CommandType.StoredProcedure;
getCommand.Parameters.AddWithValue("@KeyType", keyType);
getCommand.Parameters.AddWithValue("@SerializedKey", keyString);
getCommand.Parameters.AddWithValue("@KeyHash", keyHash);
using (var reader = getCommand.ExecuteReader(System.Data.CommandBehavior.SingleResult))
{
dataTable.Load(reader);
}
}
}
if (dataTable != null && dataTable.Rows != null && dataTable.Rows.Count > 0)
{
var dataRow = dataTable.Rows[0];
return(new RFCatalogKeyMetadata
{
ContentType = dataRow["ContentType"].ToString(),
KeyType = dataRow["KeyType"].ToString(),
Key = RFXMLSerializer.DeserializeContract(dataRow["KeyType"].ToString(), dataRow["SerializedKey"].ToString()) as RFCatalogKey,
KeyReference = (long)dataRow["CatalogKeyID"],
Metadata = RFMetadata.Deserialize(dataRow["Metadata"].ToString()),
UpdateTime = (DateTimeOffset)dataRow["UpdateTime"],
IsValid = (bool)dataRow["IsValid"],
DataSize = (long)dataRow["DataSize"]
});
}
}
catch (Exception ex)
{
Log.Exception(this, "Error retrieving key metadata", ex);
}
return(null);
}
public void Invalidate(RFCatalogKey key)
{
try
{
var entry = LoadEntry(key);
if (entry != null)
{
entry.SetInvalid();
SaveEntry(entry, false, true);
}
}
catch (Exception ex)
{
throw new RFSystemException(this, ex, "Error invalidating {0}", key);
}
}
public static string KeyLabel(RFCatalogKey key)
{
return(key.FriendlyString());
}
public static RFGraphReactor SimpleReactor(RFCatalogKey key, RFDateBehaviour dateBehaviour, string processName, IRFReadingContext context, Func <RFDate, RFDate> maxInstanceFunc)
{
return(new RFGraphReactor(key, dateBehaviour, processName, context, d => d.ValueDate.Value, (d) => maxInstanceFunc(d)));
}
public virtual bool MatchesRoot(RFCatalogKey key)
{
return(key != null && RootString() == key.RootString());
}
public static RFGraphReactor RangeReactor(RFCatalogKey key, string processName, IRFReadingContext context, Func <RFGraphInstance, RFDate>
rangeUpdateFunc, Func <RFDate, RFDate> maxInstanceFunc)
{
return(new RFGraphReactor(key, RFDateBehaviour.Range, processName, context, rangeUpdateFunc, (d) => maxInstanceFunc(d)));
}
public RFGraphProcessDefinition MapState <S>(Expression <Func <S, object> > property, RFCatalogKey key) where S : RFGraphProcessorDomain
{
return(AddIOMapping(property, key, RFIOBehaviour.State));
}
public override RFCatalogEntry LoadItem(RFCatalogKey itemKey, int version = 0, bool ignoreContent = false)
{
RFCatalogEntry entry = null;
if (itemKey.Plane == RFPlane.User)
{
//Log.Debug(this, "LoadItem {0}", catalogKey.ToString());
}
try
{
var dataRow = new Dictionary <string, object>();
using (var connection = new SqlConnection(_connectionString))
{
connection.Open();
try
{
long catalogEntryID = 0;
using (var command = LoadEntryCommand(itemKey, version, connection))
{
using (var reader = command.ExecuteReader(System.Data.CommandBehavior.SingleRow))
{
if (reader.HasRows)
{
reader.Read();
catalogEntryID = reader.GetInt64(7);
dataRow.Add("CatalogKeyID", reader.GetInt64(0));
dataRow.Add("KeyType", reader.GetString(1));
dataRow.Add("SerializedKey", reader.GetString(2));
dataRow.Add("Version", reader.GetInt32(3));
dataRow.Add("Metadata", reader.IsDBNull(4) ? String.Empty : reader.GetString(4));
dataRow.Add("IsValid", reader.GetBoolean(5));
dataRow.Add("UpdateTime", reader.GetDateTimeOffset(6));
dataRow.Add("CatalogEntryID", catalogEntryID);
dataRow.Add("ContentType", reader.GetString(8));
dataRow.Add("BinaryContent", reader.IsDBNull(9) ? null : reader.GetSqlBinary(9).Value);
}
}
}
}
catch (SqlException)
{
throw;
}
catch (InvalidOperationException)
{
throw;
}
catch (Exception ex)
{
Log.Exception(this, ex, "Error loading entry {0}", itemKey);
}
}
if (dataRow.Any())
{
entry = ExtractEntry(itemKey.StoreType, dataRow, ignoreContent);
}
}
catch (SqlException)
{
throw;
}
catch (InvalidOperationException)
{
throw;
}
catch (Exception ex)
{
Log.Exception(this, ex, "Error loading entry {0}", itemKey);
}
return(entry);
}
public RFCatalogKeyMetadata GetKeyMetadata(RFCatalogKey key)
{
return(_catalog.GetKeyMetadata(key));
}
public Dictionary <RFGraphInstance, RFCatalogKey> GetKeyInstances(RFCatalogKey key)
{
return(_catalog.GetKeyInstances(key));
}
public override Dictionary <RFGraphInstance, RFCatalogKey> GetKeyInstances(RFCatalogKey key)
{
var t = key.GetType();
var keys = new Dictionary <RFGraphInstance, RFCatalogKey>();
string keyType = t.FullName;
Log.Debug(this, "GetKeyInstances {0}", keyType);
try
{
var dataTable = new DataTable();
using (var connection = new SqlConnection(_connectionString))
{
connection.Open();
string getKeysSQL = "RIFF.GetKeyInstances";
using (var getCommand = CreateCommand(getKeysSQL, connection))
{
var rootHash = RFStringHelpers.QuickHash(key.RootKey().ToString());
getCommand.CommandType = CommandType.StoredProcedure;
getCommand.Parameters.AddWithValue("@KeyType", keyType);
getCommand.Parameters.AddWithValue("@SerializedKey", RFXMLSerializer.SerializeContract(key));
getCommand.Parameters.AddWithValue("@RootHash", rootHash);
using (var reader = getCommand.ExecuteReader(System.Data.CommandBehavior.SingleResult))
{
dataTable.Load(reader);
}
}
}
if (dataTable != null && dataTable.Rows != null && dataTable.Rows.Count > 0)
{
// cache deserializer if key is explicit
foreach (DataRow dataRow in dataTable.Rows)
{
try
{
var catalogKeyID = (long)dataRow["CatalogKeyID"];
var retrievedKeyType = dataRow["KeyType"].ToString();
var serializedKey = dataRow["SerializedKey"].ToString();
var graphInstanceName = dataRow["GraphInstanceName"].ToString();
var graphInstanceDate = new RFDate((int)dataRow["GraphInstanceDate"]);
var deserializedKey = RFXMLSerializer.DeserializeContract(retrievedKeyType, serializedKey);
keys.Add(
new RFGraphInstance
{
Name = graphInstanceName,
ValueDate = graphInstanceDate
},
deserializedKey as RFCatalogKey);
}
catch (Exception ex)
{
Log.Exception(this, ex, "Error deserializing key {0}", dataRow["SerializedKey"].ToString());
}
}
}
}
catch (Exception ex)
{
Log.Exception(this, "Error retrieving key instances", ex);
}
return(keys);
}
public RFCatalogEntry LoadEntry(RFCatalogKey key, RFCatalogOptions options = null)
{
DefaultOptions(ref options);
if (key is RFCatalogKey)
{
lock (_memoryStore)
{
if (_memoryStore.ContainsKey(key.ToString()))
{
return(_memoryStore[key.ToString()]);
}
}
switch (options.DateBehaviour)
{
case RFDateBehaviour.NotSet:
case RFDateBehaviour.Exact:
{
var item = _catalog.LoadItem(key as RFCatalogKey, options.Version, options.IgnoreContent);
return((item != null && item.IsValid) ? item : null);
}
case RFDateBehaviour.Dateless:
{
var keyToLoad = key.CreateForInstance(new RFGraphInstance
{
Name = key.GraphInstance.Name,
ValueDate = null
});
var item = _catalog.LoadItem(keyToLoad, options.Version, options.IgnoreContent);
return((item != null && item.IsValid) ? item : null);
}
case RFDateBehaviour.Latest:
case RFDateBehaviour.Previous:
{
if (key.GraphInstance == null || !key.GraphInstance.ValueDate.HasValue)
{
throw new RFSystemException(this, "Unable to load latest date for key without date {0}", key);
}
var allKeys = _catalog.GetKeyInstances(key);
var candidateDates = new SortedSet <RFDate>();
foreach (var candidateKey in allKeys.Where(k => k.Key.Name == key.GraphInstance.Name))
{
if (candidateKey.Value.GraphInstance.ValueDate.Value <= key.GraphInstance.ValueDate.Value)
{
if ((options.DateBehaviour == RFDateBehaviour.Latest) ||
(options.DateBehaviour == RFDateBehaviour.Previous && candidateKey.Value.GraphInstance.ValueDate.Value < key.GraphInstance.ValueDate.Value))
{
candidateDates.Add(candidateKey.Value.GraphInstance.ValueDate.Value);
}
}
}
if (candidateDates.Count == 0)
{
SystemLog.Warning(this, "No latest date instance item found for key {0}", key);
return(null);
}
foreach (var latestDate in candidateDates.OrderByDescending(d => d))
{
var keyToLoad = key.CreateForInstance(new RFGraphInstance
{
Name = key.GraphInstance.Name,
ValueDate = latestDate
});
var item = _catalog.LoadItem(keyToLoad, options.Version, options.IgnoreContent);
if (item != null && item.IsValid)
{
return(item);
}
}
return(null);
}
default:
throw new RFSystemException(this, "Unsupported date behaviour in LoadEntry: {0}", options.DateBehaviour);
}
}
else
{
throw new RFSystemException(this, "Unknown store key type {0}", key.ToString());
}
}
public RFGraphProcessDefinition MapRangeInput <S>(Expression <Func <S, object> > property, RFCatalogKey key, Func <RFGraphInstance, List <RFDate> > rangeRequestFunc,
Func <RFGraphInstance, RFDate> rangeUpdateFunc) where S : RFGraphProcessorDomain
{
return(AddIOMapping(property, key, RFIOBehaviour.Input, rangeRequestFunc, rangeUpdateFunc));
}
public void SaveDocument(RFCatalogKey key, object content, bool raiseEvent = true)
{
SaveEntry(RFDocument.Create(key, content), raiseEvent);
}
protected RFGraphProcessDefinition AddIOMapping <S>(Expression <Func <S, object> > property, RFCatalogKey key, RFIOBehaviour expectedBehvaiour, Func <RFGraphInstance, List <RFDate> > rangeRequestFunc = null,
Func <RFGraphInstance, RFDate> rangeUpdateFunc = null) where S : RFGraphProcessorDomain
{
var processor = Processor();
var domain = processor.CreateDomain();
if (domain.GetType() != typeof(S))
{
throw new RFLogicException(this, "IO Domain Type mismatch on processor {0}: {1} vs {2}", RFGraphDefinition.GetFullName(GraphName, Name),
domain.GetType().Name, typeof(S).Name);
}
var propertyInfo = property.GetProperty <S>();
var ioBehaviour = RFReflectionHelpers.GetIOBehaviour(propertyInfo);
if (ioBehaviour != expectedBehvaiour)
{
throw new RFLogicException(this, "Inconsistent IO direction {0} on property {1}, expected {2}.", ioBehaviour, propertyInfo.FullName(), expectedBehvaiour);
}
var dateBehaviour = RFReflectionHelpers.GetDateBehaviour(propertyInfo);
if (dateBehaviour == RFDateBehaviour.Range && (rangeRequestFunc == null || rangeUpdateFunc == null))
{
throw new RFLogicException(this, "Range input doesn't have range functions specified on property {0}.", propertyInfo.FullName());
}
IOMappings.Add(new RFGraphIOMapping {
Key = key, Property = propertyInfo, RangeRequestFunc = rangeRequestFunc, RangeUpdateFunc = rangeUpdateFunc, DateBehaviour = dateBehaviour
});
return(this);
}
public RFEngineProcessorKeyParam(RFCatalogKey key)
{
Key = key;
}
