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