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); } }