/// <summary>
/// Lê o item associado com a chave informada.
/// </summary>
/// <param name="key">Chave do item.</param>
/// <param name="item">Instancia do item que será recuperado.</param>
/// <param name="providerName">Nome do provedor de leitura que será utilizado.</param>
public void ReadThru(string key, out ProviderCacheItem item, string providerName)
{
item = null;
if (_readerProivder != null)
{
ReadThruProviderManager mgr = null;
if (string.IsNullOrEmpty(providerName))
{
providerName = this.DefaultReadThruProvider;
}
if (_readerProivder.ContainsKey(providerName.ToLower()))
{
_readerProivder.TryGetValue(providerName.ToLower(), out mgr);
try
{
if (mgr != null)
{
mgr.ReadThru(key, out item);
}
}
catch (Exception)
{
throw;
}
}
}
}
public ProviderCacheItem LoadFromSource(string key)
{
var query = $"SELECT customerid, address, country, city FROM customers WHERE customerid = '{key}'";
// Define a query returning a single row result set
NpgsqlCommand command = new NpgsqlCommand(query, _connection as NpgsqlConnection);
var reader = command.ExecuteReader();
ProviderCacheItem providerCacheItem = null;
while (reader.Read())
{
if (providerCacheItem == null)
{
var customer = new Customer()
{
customerid = reader[0] as string,
address = reader[1] as string,
country = reader[2] as string,
city = reader[3] as string,
};
providerCacheItem = new ProviderCacheItem(customer)
{
Dependency = new PostGreSQLDependency(_connectionString, customer.customerid, "public", "customers", "customer_channel"),
ResyncOptions = new ResyncOptions(true)
};
}
}
reader.Close();
return(providerCacheItem);
}
public WriteOperation(string key, ProviderCacheItem cacheItem, WriteOperationType opType, int retryCount)
{
this._key = key;
this._cacheItem = cacheItem;
this._opType = opType;
this._retryCount = retryCount;
}
/// <summary>
/// Ressincroniza a entrada do cache.
/// </summary>
/// <param name="key">Chave do item.</param>
/// <param name="entry">Instancia da entrada.</param>
/// <param name="flag">Conjunto associado.</param>
/// <param name="group">Grupo onde a entrada está inserida.</param>
/// <param name="subGroup">Subgrupo da entrada.</param>
/// <param name="providerName">Nome do provedor.</param>
/// <param name="operationContext">Contexto da operação.</param>
/// <returns></returns>
public object ResyncCacheItem(string key, out CacheEntry entry, ref BitSet flag, string group, string subGroup, string providerName, OperationContext operationContext)
{
ProviderCacheItem item = null;
this.ReadThru(key, out item, providerName);
UserBinaryObject obj2 = null;
try
{
obj2 = this.GetCacheEntry(key, item, ref flag, group, subGroup, out entry);
if (obj2 == null)
{
return(obj2);
}
CacheInsResultWithEntry entry2 = _context.CacheImpl.Insert(key, entry, false, null, 0, LockAccessType.IGNORE_LOCK, operationContext);
if (entry2.Result == CacheInsResult.Failure)
{
throw new OperationFailedException("Operation failed to synchronize with data source");
}
if (entry2.Result == CacheInsResult.NeedsEviction)
{
throw new OperationFailedException("The cache is full and not enough items could be evicted.");
}
}
catch (Exception exception)
{
throw new OperationFailedException("Error occurred while synchronization with data source. Error: " + exception.Message, exception);
}
return(obj2);
}
/// <summary>
/// Load the Orders from the database based on condition from the database.
/// </summary>
/// <param name="condition"></param>
/// <param name="userContext"></param>
/// <returns></returns>
private LoaderResult LoadOrders(string condition, object userContext)
{
LoaderResult result = new LoaderResult();
result.UserContext = userContext;
if (_connection != null)
{
SqlCommand command = new SqlCommand(_query + condition, _connection);
IDataReader reader = command.ExecuteReader();
while (reader.Read())
{
// Read and construct Order
Order order = new Order();
order.OrderID = int.Parse(reader[0].ToString());
order.OrderDate = Convert.ToDateTime(reader[1].ToString());
order.ShipName = reader[2] as string;
order.ShipAddress = reader[3] as string;
order.ShipCity = reader[4] as string;
order.ShipCountry = reader[5] as string;
// Create a Cache item
// You must create ProviderCacheItem before adding to the resultant data...
ProviderCacheItem cacheItem = new ProviderCacheItem(order);
// Add to Loader data...
result.Data.Add(new System.Collections.Generic.KeyValuePair <string, ProviderItemBase>(order.OrderID.ToString(), cacheItem));
}
}
result.HasMoreData = false;
return(result);
}
public WriteOperations(string key, ProviderCacheItem cacheItem, WriteOperationType opType, bool updateInCache)
{
this._key = key;
this._cacheItem = cacheItem;
this._opType = opType;
this._updateInCache = updateInCache;
}
public WriteOperation GetWriteOperation(LanguageContext languageContext, OperationContext operationContext)
{
object value;
ProviderCacheItem providerCacheItem = null;
if (_writeOperation != null)
{
return(new WriteOperation(_writeOperation.Key, _writeOperation.ProviderCacheItem, _writeOperation.OperationType, this._retryCount));
}
if (_entry != null)
{
if (_entry.Value is CallbackEntry)
{
value = ((CallbackEntry)_entry.Value).Value;
}
else
{
value = _entry.Value;
}
if (value != null)
{
if (_opCode != OpCode.Remove) // Don't need data for remove operation
{
value = _context.CacheWriteThruDataService.GetCacheData(value, _entry.Flag);
}
}
providerCacheItem = GetProviderCacheItemFromCacheEntry(_entry, value, operationContext);
}
//WriteOperations
return(new WriteOperation(_key.ToString(), providerCacheItem, SetWriteOperationType(_opCode), _retryCount));
}
/// <summary>
/// Responsible for loading an object from the external data source.
/// Key is passed as parameter.
/// <param name="key">item identifier; probably a primary key</param>
/// <returns>data contained in ProviderCacheItem</returns>
public ProviderCacheItem LoadFromSource(string key)
{
ProviderCacheItem cacheItem = new ProviderCacheItem(sqlDatasource.LoadCustomer(key));
cacheItem.ResyncOptions.ResyncOnExpiration = true;
cacheItem.ResyncOptions.ProviderName = sqlDatasource.ConnString;
return(cacheItem);
}
/// <summary>
/// Responsible for loading an object from the external data source.
/// Key is passed as parameter.
/// <param name="key">item identifier; probably a primary key</param>
/// <returns>data contained in ProviderCacheItem</returns>
public ProviderCacheItem LoadFromSource(string key)
{
ProviderCacheItem cacheItem = new ProviderCacheItem(sqlDatasource.LoadCustomer(key));
cacheItem.ResyncOptions.ResyncOnExpiration = true;
// Resync provider name will be picked from default provider.
return(cacheItem);
}
public ProviderCacheItem LoadFromSource(string key)
{
Customer value = LoadFromDataSource(key);
var cacheItem = new ProviderCacheItem(value);
cacheItem.ResyncOptions.ResyncOnExpiration = true;
return(cacheItem);
}
public static StoreItem ToSerializedStoreItem(this StoreItem storeItem, ProviderItemBase providerItem, ISerializer serializer)
{
ProviderCacheItem providerCacheItem = providerItem as ProviderCacheItem;
if (providerCacheItem == null)
{
throw new Exception("providerItembase is not cache item");
}
storeItem.UserObject = serializer.Serialize(providerCacheItem.GetValue <object>());
return(storeItem);
}
/// <summary>
/// Lê um item com base na chave informada.
/// </summary>
/// <param name="key"></param>
/// <param name="item"></param>
public void ReadThru(string key, out ProviderCacheItem item)
{
item = null;
try
{
_provider.LoadFromSource(key, out item);
}
catch (Exception exception)
{
throw new OperationFailedException(ResourceMessageFormatter.Create(() => Properties.Resources.OperationFailedException_IReadThruProviderLoadFromSourceFailed).Format(), exception);
}
}
/// <summary> Do write-thru now. </summary>
public void Process()
{
lock (this)
{
try
{
if (_val == null)
{
ProviderCacheItem item = null;
LanguageContext languageContext = LanguageContext.NONE;
OperationContext operationContext = new OperationContext();
CacheEntry entry = null;
object userBrinaryObject = null;
try
{
_parent.ReadThru(_key, out item, _resyncProviderName, out languageContext, operationContext);
userBrinaryObject = _parent.GetCacheEntry(_key, item, ref this._flag, _groupInfo != null ? _groupInfo.Group : null, _groupInfo != null ? _groupInfo.SubGroup : null, out entry, languageContext);
}
catch (Exception ex)
{
_val = ex;
_parent.Context.NCacheLog.Error("DatasourceMgr.ResyncCacheItem", ex.Message + " " + ex.StackTrace);
}
if (!(_val is Exception) && userBrinaryObject != null)
{
operationContext.Add(OperationContextFieldName.OperationType, OperationContextOperationType.CacheOperation);
CacheInsResultWithEntry result = _parent.Context.CacheImpl.Insert(_key, entry, true, null, 0, LockAccessType.IGNORE_LOCK, operationContext);
if (result != null && result.Result == CacheInsResult.IncompatibleGroup)
{
_parent.Context.CacheImpl.Remove(_key, ItemRemoveReason.Removed, true, null, 0, LockAccessType.IGNORE_LOCK, new OperationContext(OperationContextFieldName.OperationType, OperationContextOperationType.CacheOperation));
}
}
else
{
_parent.Context.CacheImpl.Remove(_key, ItemRemoveReason.Removed, true, null, 0, LockAccessType.IGNORE_LOCK, new OperationContext(OperationContextFieldName.OperationType, OperationContextOperationType.CacheOperation));
}
}
}
catch (Exception e)
{
_val = e;
_parent.Context.NCacheLog.Error("DatasourceMgr.ResyncCacheItem", e.Message + " " + e.StackTrace);
}
finally
{
_parent.Context.PerfStatsColl.IncrementCountStats(_parent.Context.CacheInternal.Count);
_parent.Queue.Remove(_key);
}
}
}
public void MakeStoreItem(string key, ProviderCacheItem providerItem)
{
try
{
Key = key;
ExpirationType = providerItem.Expiration.Type;
TimeToLive = providerItem.Expiration.ExpireAfter;
ItemPriority = providerItem.ItemPriority;
Group = providerItem.Group;
}
catch (Exception ex)
{
throw ex;
}
}
/// <summary>
/// Convert StoreItem to ProviderItemBase based on the serializer provided
/// </summary>
/// <param name="storeItem"></param>
/// <param name="serializer"></param>
/// <returns></returns>
public static ProviderItemBase ToProviderItemBase(this StoreItem storeItem, ISerializer serializer)
{
ProviderItemBase providerItem = null;
switch (storeItem.ItemType)
{
case ItemType.CacheItem:
providerItem = new ProviderCacheItem(storeItem.UserObject);
SetProviderItemBaseProperties(storeItem, providerItem);
providerItem.ToProviderCacheItem().SetValue(storeItem.UserObject);
return(providerItem);
}
return(providerItem);
}
/// <summary>
/// Carrega o próximo item do cache.
/// </summary>
/// <param name="data">Lista ordenada com os dados a serem inseridos</param>
/// <param name="index">Objeto de indexeção para saber em que estágio da geração do cache estamos</param>
/// <returns>Retorna true enquanto falta objetos para se carregar para o cache</returns>
public bool LoadNext(ref OrderedDictionary data, ref object index)
{
try
{
if (!_started)
{
Start(null);
}
if (_itemsLoader == null)
{
return(false);
}
Record record = null;
IRecordKeyGenerator generator = null;
while (true)
{
if (!_itemsLoader.MoveNext())
{
_itemsLoader.Dispose();
_itemsLoader = null;
OnLoadFinish();
return(false);
}
record = _itemsLoader.Current;
generator = _itemsLoader.CurrentGenerator;
if (generator == null)
{
continue;
}
break;
}
var key = generator.GetKey(record);
var values = new object[record.FieldCount];
for (var i = 0; i < record.FieldCount; i++)
{
values[i] = record.GetValue(i);
}
var cacheItem = new ProviderCacheItem(new CacheItemRecord(_itemsLoader.CurrentTypeName, values, record.Descriptor));
cacheItem.AbsoluteExpiration = DateTime.MaxValue;
data.Add(key, cacheItem);
return(true);
}
catch
{
throw;
}
}
public LoaderResult LoadNext(object userContext)
{
LoaderResult loaderResult = new LoaderResult();
string queryString = "SELECT * FROM Customers";
try
{
using (SqlConnection sqlConnection = new SqlConnection(_connectionString))
{
if (sqlConnection.State == ConnectionState.Closed)
{
sqlConnection.Open();
}
SqlCommand cmd = new SqlCommand(queryString, sqlConnection);
using (SqlDataReader reader = cmd.ExecuteReader())
{
while (reader.Read())
{
Customer customerObject = new Customer
{
CompanyName = reader["CompanyName"].ToString(),
ContactName = reader["ContactName"].ToString(),
ContactTitle = reader["ContactTitle"].ToString(),
Address = reader["Address"].ToString(),
CustomerId = reader["CustomerID"].ToString()
};
ProviderCacheItem cacheItem = new ProviderCacheItem(customerObject);
var key = $"Customer:{customerObject.CustomerId}";
var keyValuePair = new KeyValuePair <string, ProviderItemBase>(key, cacheItem);
loaderResult.Data.Add(keyValuePair);
}
}
sqlConnection.Close();
}
}
catch (Exception e)
{
Console.WriteLine(e.Message);
}
loaderResult.HasMoreData = false;
return(loaderResult);
}
/// <summary>
/// Método do processo da tarefa.
/// </summary>
public void Process()
{
lock (this)
{
try
{
if (_val == null)
{
ProviderCacheItem item = null;
CacheEntry cacheEntry = null;
UserBinaryObject obj2 = null;
try
{
_parent.ReadThru(_key, out item, _resyncProviderName);
obj2 = _parent.GetCacheEntry(_key, item, ref _flag, (_groupInfo != null) ? _groupInfo.Group : null, (_groupInfo != null) ? _groupInfo.SubGroup : null, out cacheEntry);
}
catch (Exception exception)
{
_val = exception;
_parent._context.Logger.Error(("DatasourceMgr.ResyncCacheItem: " + exception.StackTrace).GetFormatter());
}
if (!(_val is Exception) && (obj2 != null))
{
_parent._context.CacheImpl.Insert(_key, cacheEntry, true, null, 0, LockAccessType.IGNORE_LOCK, new OperationContext(OperationContextFieldName.OperationType, OperationContextOperationType.CacheOperation));
}
else
{
_parent._context.CacheImpl.Remove(_key, ItemRemoveReason.Expired, true, null, 0, LockAccessType.IGNORE_LOCK, new OperationContext(OperationContextFieldName.OperationType, OperationContextOperationType.CacheOperation));
}
}
}
catch (Exception exception2)
{
_val = exception2;
_parent._context.Logger.Error((exception2.Message + exception2.StackTrace).GetFormatter());
}
finally
{
_parent._queue.Remove(_key);
}
}
}
public IDictionary <string, ProviderCacheItem> LoadFromSource(ICollection <string> keys)
{
var dictionary = new Dictionary <string, ProviderCacheItem>();
try
{
foreach (string key in keys)
{
ProviderCacheItem cacheItem = new ProviderCacheItem(LoadFromDataSource(key));
cacheItem.ResyncOptions.ResyncOnExpiration = true;
dictionary.Add(key, cacheItem);
}
return(dictionary);
}
catch (Exception exp)
{
Console.WriteLine(exp.Message);
}
return(dictionary);
}
public ProviderCacheItem LoadFromSource(
string key)
{
if (key.StartsWith("Customer:CustomerID:"))
{
var customerId = key.Replace("Customer:CustomerID:", "").Trim();
var commandDefinition = new CommandDefinition(
$@" SELECT *
FROM dbo.Customers
WHERE CustomerID = @cId",
new { cid = customerId },
flags: CommandFlags.NoCache);
var customer = Connection.Query <Customer>(commandDefinition)
.FirstOrDefault();
if (customer == null)
{
return(null);
}
else
{
var providerCacheItem = new ProviderCacheItem(customer)
{
Dependency = GetCustomerSqlDependency(customerId),
ResyncOptions = new ResyncOptions(true)
};
return(providerCacheItem);
}
}
else
{
return(null);
}
}
/// <summary>
/// Responsible for loading multiple objects from the external data source.
/// </summary>
/// <param name="keys">Collection of keys to be fetched from data source</param>
/// <returns>Dictionary of keys with respective data contained in ProviderCacheItem</returns>
public IDictionary <string, ProviderCacheItem> LoadFromSource(ICollection <string> keys)
{
// initialize dictionary to return to cache
IDictionary <string, ProviderCacheItem> providerItems = new Dictionary <string, ProviderCacheItem>();
// iterate through all the keys and fetch data
foreach (string key in keys)
{
// get data from data source
object data = sqlDatasource.LoadCustomer(key);
// initialize ProviderCacheItem with the received data
ProviderCacheItem item = new ProviderCacheItem(data);
// you can change item properties before adding to cache. For example
// adding expiration
item.Expiration = new Expiration(ExpirationType.DefaultAbsolute);
// assigning group to key
item.Group = "customers";
// add the provider item with the key to result
providerItems.Add(key, item);
}
// return result to cache
return(providerItems);
}
/// <summary>
/// Responsible for loading the object from the external data source.
/// Key is passed as parameter.
/// </summary>
/// <param name="key">item identifier; probably a primary key</param>
/// <param name="cacheItem">It is used to provide CacheItem information like Cache policies, dependencies, expirations ...</param>
public void LoadFromSource(string key, out ProviderCacheItem cacheItem)
{
cacheItem = new ProviderCacheItem(_source.LoadCustomer(key));
}
ProviderCacheItem GetProviderCacheItemFromCacheEntry(CacheEntry cacheEntry, object value, OperationContext operationContext)
{
ProviderCacheItem providerCacheItem = new ProviderCacheItem(value);
if (cacheEntry.EvictionHint != null && cacheEntry.EvictionHint._hintType == EvictionHintType.PriorityEvictionHint)
{
providerCacheItem.ItemPriority = ((PriorityEvictionHint)cacheEntry.EvictionHint).Priority;
}
else
{
providerCacheItem.ItemPriority = cacheEntry.Priority;
}
if (cacheEntry.GroupInfo != null)
{
providerCacheItem.Group = cacheEntry.GroupInfo.Group;
providerCacheItem.SubGroup = cacheEntry.GroupInfo.SubGroup;
}
DateTime absoluteExpiration = DateTime.MaxValue.ToUniversalTime();
TimeSpan slidingExpiration = TimeSpan.Zero;
ExpirationHint hint = cacheEntry.ExpirationHint;
if (hint != null)
{
providerCacheItem.ResyncItemOnExpiration = hint.NeedsReSync;
AutoExpiration.DependencyHelper helper = new AutoExpiration.DependencyHelper();
providerCacheItem.Dependency = helper.GetActualCacheDependency(hint, ref absoluteExpiration, ref slidingExpiration);
}
if (absoluteExpiration != DateTime.MaxValue.ToUniversalTime())
{
providerCacheItem.AbsoluteExpiration = absoluteExpiration.ToLocalTime();
}
providerCacheItem.SlidingExpiration = slidingExpiration;
if (cacheEntry.QueryInfo != null)
{
if (cacheEntry.QueryInfo["tag-info"] != null)
{
Hashtable tagInfo = cacheEntry.QueryInfo["tag-info"] as Hashtable;
if (tagInfo != null)
{
ArrayList tagsList = tagInfo["tags-list"] as ArrayList;
if (tagsList != null && tagsList.Count > 0)
{
Tag[] tags = new Tag[tagsList.Count];
int i = 0;
foreach (string tag in tagsList)
{
tags[i++] = new Tag(tag);
}
providerCacheItem.Tags = tags;
}
}
}
if (cacheEntry.QueryInfo["named-tag-info"] != null)
{
Hashtable tagInfo = cacheEntry.QueryInfo["named-tag-info"] as Hashtable;
if (tagInfo != null)
{
Hashtable tagsList = tagInfo["named-tags-list"] as Hashtable;
if (tagsList != null)
{
NamedTagsDictionary namedTags = new NamedTagsDictionary();
foreach (DictionaryEntry tag in tagsList)
{
Type tagType = tag.Value.GetType();
string tagKey = tag.Key.ToString();
if (tagType == typeof(int))
{
namedTags.Add(tagKey, (int)tag.Value);
}
else if (tagType == typeof(long))
{
namedTags.Add(tagKey, (long)tag.Value);
}
else if (tagType == typeof(float))
{
namedTags.Add(tagKey, (float)tag.Value);
}
else if (tagType == typeof(double))
{
namedTags.Add(tagKey, (double)tag.Value);
}
else if (tagType == typeof(decimal))
{
namedTags.Add(tagKey, (decimal)tag.Value);
}
else if (tagType == typeof(bool))
{
namedTags.Add(tagKey, (bool)tag.Value);
}
else if (tagType == typeof(char))
{
namedTags.Add(tagKey, (char)tag.Value);
}
else if (tagType == typeof(string))
{
namedTags.Add(tagKey, (string)tag.Value);
}
else if (tagType == typeof(DateTime))
{
namedTags.Add(tagKey, (DateTime)tag.Value);
}
}
if (namedTags.Count > 0)
{
providerCacheItem.NamedTags = namedTags;
}
}
}
}
}
providerCacheItem.ResyncProviderName = cacheEntry.ResyncProviderName;
return(providerCacheItem);
}
/// <summary>
/// Processa os dados carregados do LoadNext.
/// </summary>
/// <param name="data"></param>
private void ProcessDataFromLoadNext(OrderedDictionary data)
{
int num = 0;
byte[] buffer = null;
foreach (DictionaryEntry entry in data)
{
EvictionHint hint2;
num = 0;
object key = null;
ProviderCacheItem item = null;
Colosoft.Caching.Expiration.ExpirationHint expiryHint = null;
string resyncProviderName = null;
Hashtable queryInfo = null;
try
{
if ((!(entry.Key is string) || !(entry.Value is ProviderCacheItem)))
{
throw new InvalidOperationException("Invalid Key/Value type specified");
}
key = entry.Key;
item = (ProviderCacheItem)entry.Value;
if (item == null)
{
continue;
}
CacheLoaderUtil.EvaluateExpirationParameters(item.AbsoluteExpiration, item.SlidingExpiration);
expiryHint = Expiration.DependencyHelper.GetExpirationHint(item.Dependency, item.AbsoluteExpiration, item.SlidingExpiration);
if ((expiryHint != null) && item.ResyncItemOnExpiration)
{
expiryHint.SetBit(2);
}
resyncProviderName = (item.ResyncProviderName == null) ? null : item.ResyncProviderName.ToLower();
queryInfo = new Hashtable();
TypeInfoMap typeInfoMap = _cache.GetTypeInfoMap();
if (typeInfoMap != null)
{
queryInfo["query-info"] = CacheLoaderUtil.GetQueryInfo(item.Value, typeInfoMap);
}
if (item.Tags != null)
{
queryInfo["tag-info"] = CacheLoaderUtil.GetTagInfo(item.Value, item.Tags);
}
if (item.NamedTags != null)
{
Hashtable hashtable2 = CacheLoaderUtil.GetNamedTagsInfo(item.Value, item.NamedTags, typeInfoMap);
if (hashtable2 != null)
{
queryInfo["named-tag-info"] = hashtable2;
}
}
}
catch (Exception exception3)
{
OnProcessEntryError(entry, exception3);
continue;
}
var set = new BitSet();
object currentValue = item.Value;
try
{
hint2 = new PriorityEvictionHint(item.ItemPriority);
if (!(currentValue is ICacheItemRecord))
{
buffer = this.SafeSerialize(currentValue) as byte[];
if ((buffer != null) && _cache.CompressionEnabled)
{
buffer = IO.Compression.CompressionUtil.Compress(buffer, ref set, _cache.CompressThresholdSize);
}
if (buffer != null)
{
currentValue = UserBinaryObject.CreateUserBinaryObject(buffer);
}
}
}
catch (Exception ex)
{
OnLoadProcessingError(ex);
continue;
}
while (num <= this.NoOfRetries)
{
if (_cache.IsRunning)
{
if (!CanInsertEntry(key, currentValue))
{
break;
}
try
{
_cache.Insert(key, currentValue, expiryHint, null, hint2, item.Group, item.SubGroup, queryInfo, set, null, 0, LockAccessType.IGNORE_LOCK, null, resyncProviderName, new OperationContext(OperationContextFieldName.OperationType, OperationContextOperationType.CacheOperation));
}
catch (Exception exception4)
{
num++;
System.Threading.Thread.Sleep(this.RetryInterval);
if (num > this.NoOfRetries)
{
OnInsertEntryError(key, currentValue, exception4);
if (exception4 is OperationFailedException)
{
if (((OperationFailedException)exception4).IsTracable || !_logger.IsErrorEnabled)
{
continue;
}
_logger.Error("CacheStartupLoader.Load()".GetFormatter(), exception4);
break;
}
if (_logger.IsErrorEnabled)
{
_logger.Error("CacheStartupLoader.Load()".GetFormatter(), exception4);
break;
}
}
continue;
}
OnInsertedEntry(key, currentValue);
}
break;
}
}
}
/// <summary>
/// Responsible for loading the object from the external data source.
/// Key is passed as parameter.
/// </summary>
/// <param name="key"></param>
/// <returns></returns>
///
public void ReadThru(string key, out ProviderCacheItem item, OperationContext operationContext)
{
item = null;
try
{
if (_dsReader is ICustomReadThru)
{
if (operationContext.Contains(OperationContextFieldName.ReadThru))
{
((ICustomReadThru)_dsReader).DoReadThru =
Convert.ToBoolean(operationContext.GetValueByField(OperationContextFieldName.ReadThru));
}
if (operationContext.Contains(OperationContextFieldName.ReadThru))
{
((ICustomReadThru)_dsReader).ProviderName =
operationContext.GetValueByField(OperationContextFieldName.ReadThruProviderName) as string;
}
if (operationContext.Contains(OperationContextFieldName.GroupInfo))
{
GroupInfo gi = operationContext.GetValueByField(OperationContextFieldName.GroupInfo) as GroupInfo;
if (gi != null)
{
((ICustomReadThru)_dsReader).Group = gi.Group;
((ICustomReadThru)_dsReader).SubGroup = gi.SubGroup;
}
}
}
Stopwatch readThruWatch = new Stopwatch();
readThruWatch.Start();
_dsReader.LoadFromSource(key, out item);
readThruWatch.Stop();
double elapsedByReadThru = readThruWatch.Elapsed.TotalSeconds;
if (elapsedByReadThru > ServiceConfiguration.CommandExecutionThreshold &&
ServiceConfiguration.EnableCommandThresholdLogging)
{
if (_context.NCacheLog != null)
{
_context.NCacheLog.Warn("ReadThruProviderMgr.ReadThru",
"ReadThru took " + elapsedByReadThru +
" seconds to complete. Which is longer than expected.");
}
}
this._context.PerfStatsColl.IncrementReadThruPerSec();
}
catch (Exception e)
{
//Client doesnt throw the inner exception
//Client casts the thrown exception message into Operation failed Exception therefore the current inner exception will be casted
//in Operation failed exception > Inner Exception > Inner Exception
throw new OperationFailedException("IReadThruProvider.LoadFromSource failed. Error: " + e.ToString(), e);
}
finally
{
try
{
// reset all here
((ICustomReadThru)_dsReader).DoReadThru = false;
((ICustomReadThru)_dsReader).Group = null;
((ICustomReadThru)_dsReader).SubGroup = null;
((ICustomReadThru)_dsReader).ProviderName = null;
}
catch {}
}
}
/// <summary>
/// Recupera uma entrada do cache.
/// </summary>
/// <param name="key"></param>
/// <param name="item"></param>
/// <param name="flag"></param>
/// <param name="group"></param>
/// <param name="subGroup"></param>
/// <param name="cacheEntry"></param>
/// <returns></returns>
public UserBinaryObject GetCacheEntry(string key, ProviderCacheItem item, ref BitSet flag, string group, string subGroup, out CacheEntry cacheEntry)
{
UserBinaryObject val = null;
cacheEntry = null;
object serializableObject = null;
if ((item != null) && (item.Value != null))
{
if ((item.Group == null) && (item.SubGroup != null))
{
throw new OperationFailedException("Error occurred while synchronization with data source; group must be specified for sub group");
}
if ((group != null) && !CacheHelper.CheckDataGroupsCompatibility(new GroupInfo(item.Group, item.SubGroup), new GroupInfo(group, subGroup)))
{
throw new OperationFailedException("Error occurred while synchronization with data source; groups are incompatible");
}
if (flag == null)
{
flag = new BitSet();
}
serializableObject = item.Value;
Hashtable hashtable = new Hashtable();
TypeInfoMap typeInfoMap = _context.CacheRoot.GetTypeInfoMap();
hashtable["query-info"] = CacheLoaderUtil.GetQueryInfo(item.Value, typeInfoMap);
if (item.Tags != null)
{
Hashtable tagInfo = CacheLoaderUtil.GetTagInfo(item.Value, item.Tags);
if (tagInfo != null)
{
hashtable.Add("tag-info", tagInfo);
}
}
if (item.NamedTags != null)
{
try
{
Hashtable hashtable3 = CacheLoaderUtil.GetNamedTagsInfo(item.Value, item.NamedTags, typeInfoMap);
if (hashtable3 != null)
{
hashtable.Add("named-tag-info", hashtable3);
}
}
catch (Exception exception)
{
throw new OperationFailedException("Error occurred while synchronization with data source; " + exception.Message);
}
}
if (!item.Value.GetType().IsSerializable&& !_type.IsAssignableFrom(item.Value.GetType()))
{
throw new OperationFailedException("Read through provider returned an object that is not serializable.");
}
serializableObject = SerializationUtil.SafeSerialize(serializableObject, _context.SerializationContext, ref flag);
if (_context.CompressionEnabled)
{
item.Value = CompressionUtil.Compress(item.Value as byte[], ref flag, _context.CompressionThreshold);
}
val = UserBinaryObject.CreateUserBinaryObject(serializableObject as byte[]);
EvictionHint evictionHint = new PriorityEvictionHint(item.ItemPriority);
ExpirationHint expiryHint = DependencyHelper.GetExpirationHint(item.Dependency, item.AbsoluteExpiration, item.SlidingExpiration);
if (expiryHint != null)
{
expiryHint.CacheKey = key;
if (item.ResyncItemOnExpiration)
{
expiryHint.SetBit(2);
}
}
cacheEntry = new CacheEntry(val, expiryHint, evictionHint);
cacheEntry.Flag = flag;
cacheEntry.GroupInfo = new GroupInfo(item.Group, item.SubGroup);
cacheEntry.QueryInfo = hashtable;
cacheEntry.ResyncProviderName = (item.ResyncProviderName == null) ? null : item.ResyncProviderName.ToLower();
}
return(val);
}
/// <summary>
/// Responsible for loading the object from the external data source.
/// Key is passed as parameter.
/// <param name="key">item identifier; probably a primary key</param>
/// <param name="exh">Current expiration hint; you can modify the value and attach a new hint</param>
/// <param name="evh">Current eviction hint; you can modify the value and attach a new hint</param>
/// <returns></returns>
public void LoadFromSource(string key, out ProviderCacheItem cacheItem)
{
cacheItem = new ProviderCacheItem(sqlDatasource.LoadCustomer(key));
cacheItem.ResyncItemOnExpiration = true;
cacheItem.ResyncProviderName = sqlDatasource.ConnString;
}
public InternalWriteOperation(string key, ProviderCacheItem cacheItem, WriteOperationType opType, int retryCount) : base(key, cacheItem, opType, retryCount)
{
}
