protected void LogInSystemLog(object caller, string level, object o)
{
try
{
using (var connection = new SqlConnection(_connectionString))
{
connection.Open();
using (var insertCommand = new SqlCommand("INSERT INTO RIFF.SystemLog( [Timestamp], [Hostname], [Level], [Source], [Message], [Content], [Thread], [AppDomain] ) VALUES " +
"( @Timestamp, @Hostname, @Level, @Source, @Message, @Content, @Thread, @AppDomain )", connection))
{
insertCommand.Parameters.AddWithValue("@Timestamp", new DateTimeOffset(DateTime.Now));
insertCommand.Parameters.AddWithValue("@Hostname", Environment.MachineName.ToLower());
insertCommand.Parameters.AddWithValue("@Level", level);
insertCommand.Parameters.AddWithValue("@Source", caller != null ? caller.ToString() : String.Empty);
insertCommand.Parameters.AddWithValue("@Message", o.GetType().Name);
insertCommand.Parameters.AddWithValue("@Content", RFXMLSerializer.SerializeContract(o));
insertCommand.Parameters.AddWithValue("@Thread", System.Threading.Thread.CurrentThread.ManagedThreadId);
insertCommand.Parameters.AddWithValue("@AppDomain", AppDomain.CurrentDomain.FriendlyName);
insertCommand.ExecuteNonQuery();
}
}
}
catch (Exception ex)
{
Exception(this, ex, "Error logging in System Log");
}
}
public static Type GetTypeByFullName(string type)
{
foreach (var t in RFXMLSerializer.GetKnownTypes(null))
{
if (t.FullName == type)
{
return(t);
}
}
/*
* foreach (Assembly a in AppDomain.CurrentDomain.GetAssemblies())
* {
* if (!a.FullName.Contains("IKVM"))
* {
* foreach (Type t in a.GetTypes())
* {
* if (t.FullName == type)
* {
* return t;
* }
* }
* }
* }*/
return(Type.GetType(type));
}
public object Read(Message message)
{
var reader = new StreamReader(message.BodyStream);
var contentType = reader.ReadLine();
var content = reader.ReadToEnd();
return(RFXMLSerializer.DeserializeContract(contentType, content));
}
public void Write(Message message, object obj)
{
message.BodyStream = new MemoryStream();
var writer = new StreamWriter(message.BodyStream);
writer.WriteLine(obj.GetType().FullName);
writer.WriteLine(RFXMLSerializer.SerializeContract(obj));
writer.Flush();
}
/// <summary>
/// Non-realtime context for Web processing.
/// </summary>
/// <param name="dbConnection">Database connection string.</param>
/// <returns>Context for accessing the environment.</returns>
public static IRFProcessingContext StartWeb(string environment, string dbConnection, IEnumerable <string> engineAssemblies)
{
LoadReferencedAssemblies();
var se = new RFWebEnvironment(environment: environment, dbConnection: dbConnection);
RFXMLSerializer.Initialize(engineAssemblies);
RFRazor.Initialize(engineAssemblies);
return(se.Start());
}
/// <summary>
/// Start a simple one-process engine using default providers.
/// </summary>
/// <param name="config">Engine configuration.</param>
/// <param name="dbConnection">Database connection string.</param>
/// <returns>Context for accessing the environment.</returns>
public static IRFEnvironment StartLocal(string environment, RFEngineDefinition config, string dbConnection, IEnumerable <string> engineAssemblies)
{
LoadReferencedAssemblies();
var le = new RFServiceEnvironment(environment, config, dbConnection);
RFXMLSerializer.Initialize(engineAssemblies);
RFRazor.Initialize(engineAssemblies);
return(le);
}
/// <summary>
/// Environment for a single request, underneath an optional parent environment.
/// </summary>
/// <param name="dbConnection">Database connection string.</param>
/// <returns>Context for accessing the environment.</returns>
public static IRFEnvironment StartConsole(string environment, RFEngineDefinition config, string dbConnection, IEnumerable <string> engineAssemblies = null)
{
LoadReferencedAssemblies();
var se = new RFConsoleEnvironment(
environment: environment,
config: config,
dbConnection: dbConnection
);
RFXMLSerializer.Initialize(engineAssemblies);
RFRazor.Initialize(engineAssemblies);
return(se);
}
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);
}
protected RFCatalogEntry ExtractDocument(Dictionary <string, object> dataRow, bool ignoreContent)
{
var type = dataRow["ContentType"].ToString();
if (ignoreContent)
{
return(new RFDocument
{
Content = null,
Type = type
});
}
else
{
var binaryContent = dataRow["BinaryContent"] as byte[];
if (binaryContent != null && binaryContent.Length > 0)
{
return(new RFDocument
{
Content = DeserializeContent(type, binaryContent),
Type = type
});
}
else if (dataRow.ContainsKey("Content"))
{
return(new RFDocument
{
Content = RFXMLSerializer.DeserializeContract(type, dataRow["Content"].ToString()),
Type = type
});
}
return(new RFDocument
{
Content = null,
Type = type
});
}
}
protected RFCatalogEntry ExtractEntry(RFStoreType storeType, Dictionary <string, object> dataRow, bool ignoreContent)
{
RFCatalogEntry entry = null;
switch (storeType)
{
case RFStoreType.Document:
entry = ExtractDocument(dataRow, ignoreContent);
break;
default:
throw new Exception(String.Format("Unrecognized store type {0}", storeType));
}
// common fields
var type = dataRow["KeyType"].ToString();
entry.Key = (RFCatalogKey)RFXMLSerializer.DeserializeContract(type, dataRow["SerializedKey"].ToString());
entry.Metadata = RFMetadata.Deserialize(dataRow["Metadata"].ToString()) ?? new RFMetadata();
entry.UpdateTime = (DateTimeOffset)dataRow["UpdateTime"];
entry.Version = (int)dataRow["Version"];
entry.IsValid = (bool)dataRow["IsValid"];
return(entry);
}
public RFInstruction GetInstruction(string dispatchKey)
{
try
{
using (var conn = new SqlConnection(_context.SystemConfig.DocumentStoreConnectionString))
{
conn.Open();
var sqlCommand = "SELECT * FROM RIFF.DispatchQueue WHERE Environment = @Environment AND DispatchKey = @DispatchKey";
using (var getCommand = new SqlCommand(sqlCommand, conn))
{
getCommand.Parameters.AddWithValue("@Environment", _context.SystemConfig.Environment);
getCommand.Parameters.AddWithValue("@DispatchKey", dispatchKey);
var dataTable = new DataTable();
using (var reader = getCommand.ExecuteReader(System.Data.CommandBehavior.SingleResult))
{
dataTable.Load(reader);
if (dataTable.Rows != null && dataTable.Rows.Count > 0)
{
var dataRow = dataTable.Rows[0];
var instructionType = dataRow["InstructionType"].ToString();
var instructionContent = dataRow["InstructionContent"].ToString();
return(RFXMLSerializer.DeserializeContract(instructionType, instructionContent) as RFInstruction);
}
return(null);
}
}
}
}
catch (Exception ex)
{
_context.Log.Exception(this, "Error reading Dispatch Store Error", ex);
throw;
}
}
public RFXMLObject(object o)
{
Xml = RFXMLSerializer.PrettySerializeContract(o);
}
/*
* public virtual RFEngineProcessorParam ExtractFrom(RFInstruction i)
* {
* return new RFEngineProcessorParam();
* }*/
public override int GetHashCode()
{
return(RFXMLSerializer.SerializeContract(this).GetHashCode());
}
protected static byte[] SerializeContent(object o)
{
return(RFXMLSerializer.BinarySerializeContract(o));
}
protected static object DeserializeContent(string type, byte[] data)
{
return(RFXMLSerializer.BinaryDeserializeContract(type, RFCompressor.DecompressBytes(data)));
}
public override List <RFCatalogKeyMetadata> SearchKeys(Type t, DateTime?startTime = null, DateTime?endTime = null, int limitResults = 0, RFDate?valueDate = null, bool latestOnly = false)
{
var keys = new List <RFCatalogKeyMetadata>();
var keyType = t.FullName;
var retrieveAllKeys = t.Equals(typeof(RFCatalogKey));
if (limitResults == 0)
{
limitResults = _maxResults;
}
// the current query does not support snapshot-in-time, need to extend KeysLatestView to
// take in a ValueDate param
if (valueDate != null)
{
latestOnly = false;
}
//Log.Debug(this, "GetKeyMetadata {0}", keyType);
try
{
var dataTable = new DataTable();
using (var connection = new SqlConnection(_connectionString))
{
connection.Open();
using (var getCommand = CreateCommand("[RIFF].[SearchKeys]", connection))
{
getCommand.CommandType = CommandType.StoredProcedure;
getCommand.Parameters.AddWithValue("@LimitResults", limitResults);
if (retrieveAllKeys)
{
getCommand.Parameters.AddWithValue("@KeyType", DBNull.Value);
}
else
{
getCommand.Parameters.AddWithValue("@KeyType", keyType);
}
if (startTime.HasValue)
{
getCommand.Parameters.AddWithValue("@StartTime", startTime);
}
if (endTime.HasValue)
{
getCommand.Parameters.AddWithValue("@EndTime", startTime);
}
if (valueDate.HasValue)
{
getCommand.Parameters.AddWithValue("@GraphInstanceDate", valueDate.Value.ToYMD());
}
if (latestOnly)
{
getCommand.Parameters.AddWithValue("@LatestInstanceOnly", true);
getCommand.Parameters.AddWithValue("@ExcludeFiles", true);
}
using (var reader = getCommand.ExecuteReader(System.Data.CommandBehavior.SingleResult))
{
dataTable.Load(reader);
}
}
}
if (dataTable != null && dataTable.Rows != null && dataTable.Rows.Count > 0)
{
foreach (DataRow dataRow in dataTable.Rows)
{
try
{
keys.Add(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"],
Instance = (dataRow["GraphInstanceName"] != DBNull.Value && dataRow["GraphInstanceDate"] != DBNull.Value) ? new RFGraphInstance
{
Name = dataRow["GraphInstanceName"].ToString(),
ValueDate = new RFDate((int)dataRow["GraphInstanceDate"])
} : null
});
}
catch (Exception ex)
{
Log.Exception(this, ex, "Error deserializing key metadata {0}", dataRow["SerializedKey"].ToString());
}
}
}
}
catch (Exception ex)
{
Log.Exception(this, "Error retrieving key metadata", ex);
}
return(keys);
}
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 override Dictionary <long, RFCatalogKey> GetKeysByType(Type t)
{
var keys = new Dictionary <long, RFCatalogKey>();
string keyType = t.FullName;
var retrieveAllKeys = t.Equals(typeof(RFCatalogKey));
Log.Debug(this, "GetKeysByType {0}", keyType);
try
{
var dataTable = new DataTable();
using (var connection = new SqlConnection(_connectionString))
{
connection.Open();
var getKeysSQL = String.Format("SELECT [CatalogKeyID], [KeyType], CAST([SerializedKey] AS VARCHAR({0})) AS [SerializedKey] FROM [RIFF].[CatalogKey]", _maxKeyLength);
if (!retrieveAllKeys)
{
getKeysSQL = getKeysSQL + " WHERE [KeyType] = @KeyType";
}
using (var getCommand = CreateCommand(getKeysSQL, connection))
{
if (!retrieveAllKeys)
{
getCommand.Parameters.AddWithValue("@KeyType", keyType);
}
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 deserializedKey = RFXMLSerializer.DeserializeContract(retrievedKeyType, serializedKey);
keys.Add(
catalogKeyID,
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 keys by type", ex);
}
return(keys);
}
public static IEnumerable <Type> GetKnownTypes()
{
return(RFXMLSerializer.GetKnownTypes(null));
}
private string RootString()
{
return(RFXMLSerializer.SerializeContract(RootKey()));
}
public override string ToString()
{
return(RFXMLSerializer.SerializeContract(this));
}
/*[DataMember]
* public RFEvent Event { get; protected set; }*/
/*
* public static RFInstruction Create(/*RFEvent e)
* {
* return new RFInstruction { Event = e };
* }*/
public int CompareTo(object obj)
{
// this is really slow
return(string.Compare(RFXMLSerializer.SerializeContract(this), RFXMLSerializer.SerializeContract(obj), StringComparison.Ordinal));
}
private void Update(string dispatchKey, string processName, string instanceName, RFDate?valueDate, DispatchState state, long?weight, RFProcessingResult result, RFInstruction instruction)
{
try
{
using (var conn = new SqlConnection(_context.SystemConfig.DocumentStoreConnectionString))
{
conn.Open();
using (var cmd = new SqlCommand("RIFF.UpdateDispatchQueue", conn))
{
cmd.CommandType = System.Data.CommandType.StoredProcedure;
cmd.Parameters.AddWithValue("@Environment", RFStringHelpers.StringToSQL(_context.SystemConfig.Environment, false, 10, false));
cmd.Parameters.AddWithValue("@ItemType", (int)ItemType.GraphProcessInstruction);
cmd.Parameters.AddWithValue("@DispatchKey", RFStringHelpers.StringToSQL(dispatchKey, false, 140, false));
cmd.Parameters.AddWithValue("@ProcessName", RFStringHelpers.StringToSQL(processName, true, 100, false));
cmd.Parameters.AddWithValue("@GraphInstance", RFStringHelpers.StringToSQL(instanceName, true, 20, false));
if (valueDate != null && valueDate.Value.IsValid())
{
cmd.Parameters.AddWithValue("@ValueDate", valueDate.Value.Date);
}
else
{
cmd.Parameters.AddWithValue("@ValueDate", DBNull.Value);
}
if (weight.HasValue)
{
cmd.Parameters.AddWithValue("@Weight", weight.Value);
}
else
{
cmd.Parameters.AddWithValue("@Weight", DBNull.Value);
}
cmd.Parameters.AddWithValue("@DispatchState", (int)state);
if (state == DispatchState.Started)
{
cmd.Parameters.AddWithValue("@LastStart", DateTimeOffset.Now);
}
else
{
cmd.Parameters.AddWithValue("@LastStart", DBNull.Value);
}
if (result?.Messages != null)
{
cmd.Parameters.AddWithValue("@Message", RFStringHelpers.StringToSQL(String.Join("|", result.Messages), true, 200, false));
}
else if (state == DispatchState.Finished || state == DispatchState.Skipped || state == DispatchState.Started)
{
cmd.Parameters.AddWithValue("@Message", String.Empty); // clear past error messages
}
else
{
cmd.Parameters.AddWithValue("@Message", DBNull.Value);
}
if (result != null)
{
cmd.Parameters.AddWithValue("@ShouldRetry", result.ShouldRetry);
}
else
{
cmd.Parameters.AddWithValue("@ShouldRetry", false);
}
if (state == DispatchState.Queued && instruction != null)
{
cmd.Parameters.AddWithValue("@InstructionType", RFStringHelpers.StringToSQL(instruction.GetType().FullName, false, 200, false));
cmd.Parameters.AddWithValue("@InstructionContent", RFXMLSerializer.SerializeContract(instruction));
}
else
{
cmd.Parameters.AddWithValue("@InstructionType", DBNull.Value);
cmd.Parameters.AddWithValue("@InstructionContent", DBNull.Value);
}
cmd.ExecuteNonQuery();
}
}
}
catch (Exception ex)
{
_context.Log.Exception(this, "Error updating Dispatch Store", ex);
}
}
