This repository contains the cache microservice built using the ServiceBricks foundation. The cache microservice exposes a key/value pair object that can be used for simple data storage. It includes a semaphore, exposing a locking mechanism that can be used by multiple servers when needing to access a shared resource. A background expiration task can be enabled, with an initial delay and interval, to delete expired cache items once their expiration date occurs. The expiration process duals as an orphaned lock cleanup, should a lock not be released within the timeout period.
Key and Value pair storage object along with an expiration date to denote when it can be deleted.
public partial class CacheDataDto : DataTransferObject
{
public DateTimeOffset CreateDate { get; set; }
public DateTimeOffset UpdateDate { get; set; }
public string CacheKey { get; set; }
public string CacheValue { get; set; }
public DateTimeOffset? ExpirationDate { get; set; }
}This background timer can be enabled, with an initial delay and interval, to execute the CacheExpirationTask.
This background task queries for all CacheData records with an expiration date is less than the current date/time, then deletes expired records.
None
None
None
This provides a locking mechanism for shared resources in the infrastructure. Using the CacheData object, multiple concurrent services try creating the same key/record in the backing storage, the one that wins pulls records, then releases/deletes the lock. Processes will delay and retry creating the lock until it obtains it or times out. See the SemaphoreOptions for the full list of values used.
This interface stores a key in cache used for syncing across load-balanced applications so that only one server would process records at a time (see SingleWorkService). It provides a heartbeat, so that other instances will pickup and start processing, should the main running server be shut down.
This abstract class implements the WorkService and the ISingleServerProcessService to provide a single ordered work queue across multi-application instances.
This abstract class provides a way to lock the underlying data store and use it as a queue, so that multiple, simultaneous running workers do not return the same records. While the APIConcurrrency rule provides some protection, this class will provide the full solution.
{
"ServiceBricks":{
"Cache":{
"Expiration": {
"TimerEnabled": false,
"TimerIntervalMilliseconds": 7000,
"TimerDueMilliseconds": 1000
},
"Semaphore": {
"DelayMilliseconds": 3000,
"CancellationMilliseconds": 20000,
"OrphanTimeoutMilliseconds": 10000
}
}
}
}ServiceBricks is the cornerstone for building a microservices foundation. Visit http://ServiceBricks.com to learn more.