Handles access to a disk-based file cache. Handles locking and versioning. Supports subfolders for scalability. More...

Collaboration diagram for ImageResizer.Plugins.DiskCache.CustomDiskCache:

Public Member Functions
	CustomDiskCache (ILoggerProvider lp, string physicalCachePath, int subfolders, bool hashModifiedDate)

	CustomDiskCache (ILoggerProvider lp, string physicalCachePath, int subfolders, bool hashModifiedDate, long asyncMaxQueuedBytes)

CacheResult	GetCachedFile (string keyBasis, string extension, ResizeImageDelegate writeCallback, DateTime sourceModifiedUtc, int timeoutMs)
	If the cached data exists and is up-to-date, returns the path to it. Otherwise, this function tries to cache the data and return the path. More...

CacheResult	GetCachedFile (string keyBasis, string extension, ResizeImageDelegate writeCallback, DateTime sourceModifiedUtc, int timeoutMs, bool asynchronous)
	May return either a physical file name or a MemoryStream with the data. Faster than GetCachedFile, as writes are (usually) asynchronous. If the write queue is full, the write is forced to be synchronous again. Identical to GetCachedFile() when asynchronous=false More...

Protected Attributes
string	physicalCachePath

int	subfolders

bool	hashModifiedDate

ILoggerProvider	lp

LockProvider	locks = new LockProvider()

LockProvider	queueLocks = new LockProvider()

Properties
string	PhysicalCachePath `[get]`

LockProvider	Locks `[get]`
	Provides string-based locking for file write access. More...

LockProvider	QueueLocks `[get]`
	Provides string-based locking for image resizing (not writing, just processing). Prevents duplication of efforts in asynchronous mode, where 'Locks' is not being used. More...

AsyncWriteCollection	CurrentWrites `[get]`
	Contains all the queued and in-progress writes to the cache. More...

CacheIndex	Index `[get]`
	Provides an in-memory index of the cache. More...

Events
CacheResultHandler	CacheResultReturned
	Fired immediately before GetCachedFile return the result value. More...

Detailed Description

Handles access to a disk-based file cache. Handles locking and versioning. Supports subfolders for scalability.

Definition at line 20 of file CustomDiskCache.cs.

Member Function Documentation

CacheResult ImageResizer.Plugins.DiskCache.CustomDiskCache.GetCachedFile	(	string	keyBasis,
		string	extension,
		ResizeImageDelegate	writeCallback,
		DateTime	sourceModifiedUtc,
		int	timeoutMs
	)

inline

If the cached data exists and is up-to-date, returns the path to it. Otherwise, this function tries to cache the data and return the path.

Parameters

keyBasis	The basis for the key. Should not include the modified date, that is handled inside the function.
extension	The extension to use for the cached file.
writeCallback	A method that accepts a Stream argument and writes the data to it.
sourceModifiedUtc	The modified date of the source file. Should be DateTime.MinValue if not available
timeoutMs

Returns

Definition at line 90 of file CustomDiskCache.cs.

                                                                                                                                                           {
             return GetCachedFile(keyBasis, extension, writeCallback, sourceModifiedUtc, timeoutMs, false);
         }

CacheResult ImageResizer.Plugins.DiskCache.CustomDiskCache.GetCachedFile	(	string	keyBasis,
		string	extension,
		ResizeImageDelegate	writeCallback,
		DateTime	sourceModifiedUtc,
		int	timeoutMs,
		bool	asynchronous
	)

inline

May return either a physical file name or a MemoryStream with the data. Faster than GetCachedFile, as writes are (usually) asynchronous. If the write queue is full, the write is forced to be synchronous again. Identical to GetCachedFile() when asynchronous=false

Parameters

keyBasis
extension
writeCallback
sourceModifiedUtc
timeoutMs

Returns

Definition at line 106 of file CustomDiskCache.cs.

                                                                                                                                                                              {
             Stopwatch sw = null;
             if (lp.Logger != null) { sw = new Stopwatch(); sw.Start(); }
 
 
             bool hasModifiedDate = !sourceModifiedUtc.Equals(DateTime.MinValue);
 
 
             //Hash the modified date if needed.
             if (hashModifiedDate && hasModifiedDate)
                 keyBasis += "|" + sourceModifiedUtc.Ticks.ToString(NumberFormatInfo.InvariantInfo);
 
             //Relative to the cache directory. Not relative to the app or domain root
             string relativePath = new UrlHasher().hash(keyBasis, subfolders, "/") + '.' + extension;
 
             //Physical path
             string physicalPath = PhysicalCachePath.TrimEnd('\\', '/') + System.IO.Path.DirectorySeparatorChar +
                     relativePath.Replace('/', System.IO.Path.DirectorySeparatorChar);
 
 
             CacheResult result = new CacheResult(CacheQueryResult.Hit, physicalPath, relativePath);
 
 
             bool compareModifiedDates = hasModifiedDate && !hashModifiedDate;
             
             bool asyncFailed = false;
             
 
             //2013-apr-25: What happens if the file is still being written to disk - it's present but not complete? To handle that, we use mayBeLocked.
 
             bool mayBeLocked = Locks.MayBeLocked(relativePath.ToUpperInvariant());
 
              //On the first check, verify the file exists using System.IO directly (the last 'true' parameter).
             if (!asynchronous) {
                 //On the first check, verify the file exists using System.IO directly (the last 'true' parameter)
                 //May throw an IOException if the file cannot be opened, and is locked by an external processes for longer than timeoutMs. 
                 //This method may take longer than timeoutMs under absolute worst conditions. 
                 if (!TryWriteFile(result, physicalPath, relativePath, writeCallback, sourceModifiedUtc, timeoutMs, !mayBeLocked)) {
                     //On failure
                     result.Result = CacheQueryResult.Failed;
                 }
             }
             else if ((!compareModifiedDates ? !Index.existsCertain(relativePath, physicalPath) : !Index.modifiedDateMatchesCertainExists(sourceModifiedUtc, relativePath, physicalPath)) || mayBeLocked)
             {
                 
                 //Looks like a miss. Let's enter a lock for the creation of the file. This is a different locking system than for writing to the file - far less contention, as it doesn't include the 
                 //This prevents two identical requests from duplicating efforts. Different requests don't lock.
 
                 //Lock execution using relativePath as the sync basis. Ignore casing differences. This prevents duplicate entries in the write queue and wasted CPU/RAM usage.
                 if (!QueueLocks.TryExecute(relativePath.ToUpperInvariant(), timeoutMs,
                     delegate() {
 
                         //Now, if the item we seek is in the queue, we have a memcached hit. If not, we should check the index. It's possible the item has been written to disk already.
                         //If both are a miss, we should see if there is enough room in the write queue. If not, switch to in-thread writing. 
 
                         AsyncWrite t = CurrentWrites.Get(relativePath, sourceModifiedUtc);
 
                         if (t != null) result.Data = t.GetReadonlyStream();
 
                         
 
                         //On the second check, use cached data for speed. The cached data should be updated if another thread updated a file (but not if another process did).
                         //When t == null, and we're inside QueueLocks, all work on the file must be finished, so we have no need to consult mayBeLocked.
                         if (t == null && 
                             (!compareModifiedDates ? !Index.exists(relativePath, physicalPath) : !Index.modifiedDateMatches(sourceModifiedUtc, relativePath, physicalPath)))
                         {
 
                             result.Result = CacheQueryResult.Miss;
                             //Still a miss, we even rechecked the filesystem. Write to memory.
                             MemoryStream ms = new MemoryStream(4096);  //4K initial capacity is minimal, but this array will get copied around alot, better to underestimate.
                             //Read, resize, process, and encode the image. Lots of exceptions thrown here.
                             writeCallback(ms);
                             ms.Position = 0;
 
                             AsyncWrite w = new AsyncWrite(CurrentWrites,ms, physicalPath, relativePath, sourceModifiedUtc);
                             if (CurrentWrites.Queue(w, delegate(AsyncWrite job) {
                                 try {
                                     Stopwatch swio = new Stopwatch();
                                     
                                     swio.Start();
                                     //TODO: perhaps a different timeout?
                                     if (!TryWriteFile(null, job.PhysicalPath, job.RelativePath, delegate(Stream s) { ((MemoryStream)job.GetReadonlyStream()).WriteTo(s); }, job.ModifiedDateUtc, timeoutMs, true)) {
                                         swio.Stop();
                                         //We failed to lock the file.
                                         if (lp.Logger != null) 
                                             lp.Logger.Warn("Failed to flush async write, timeout exceeded after {1}ms - {0}",  result.RelativePath, swio.ElapsedMilliseconds);
                                         
                                     } else {
                                         swio.Stop();
                                         if (lp.Logger != null)
                                             lp.Logger.Trace("{0}ms: Async write started {1}ms after enqueue for {2}", swio.ElapsedMilliseconds.ToString().PadLeft(4), DateTime.UtcNow.Subtract(w.JobCreatedAt).Subtract(swio.Elapsed).TotalMilliseconds, result.RelativePath);
                                     }
 
                                 } catch (Exception ex) {
                                     if (lp.Logger != null) {
                                         lp.Logger.Error("Failed to flush async write, {0} {1}\n{2}",ex.ToString(), result.RelativePath,ex.StackTrace);
                                     }
                                 } finally {
                                     CurrentWrites.Remove(job); //Remove from the queue, it's done or failed. 
                                 }
 
                             })) {
                                 //We queued it! Send back a read-only memory stream
                                 result.Data = w.GetReadonlyStream();
                             } else {
                                 asyncFailed = false;
                                 //We failed to queue it - either the ThreadPool was exhausted or we exceeded the MB limit for the write queue.
                                 //Write the MemoryStream to disk using the normal method.
                                 //This is nested inside a queuelock because if we failed here, the next one will also. Better to force it to wait until the file is written to disk.
                                 if (!TryWriteFile(result, physicalPath, relativePath, delegate(Stream s) { ms.WriteTo(s); }, sourceModifiedUtc, timeoutMs, false)) {
                                     if (lp.Logger != null)
                                         lp.Logger.Warn("Failed to queue async write, also failed to lock for sync writing: {0}", result.RelativePath);
                                         
                                 }
                             }
 
                         }
 
                     })) {
                     //On failure
                     result.Result = CacheQueryResult.Failed;
                 }
 
             }
             if (lp.Logger != null) {
                 sw.Stop();
                 lp.Logger.Trace("{0}ms: {3}{1} for {2}, Key: {4}", sw.ElapsedMilliseconds.ToString(NumberFormatInfo.InvariantInfo).PadLeft(4), result.Result.ToString(), result.RelativePath, asynchronous ? (asyncFailed ? "Fallback to sync  " : "Async ") : "", keyBasis);
             }
             //Fire event
             if (CacheResultReturned != null) CacheResultReturned(this, result);
             return result;
         }

Property Documentation

AsyncWriteCollection ImageResizer.Plugins.DiskCache.CustomDiskCache.CurrentWrites

get

Contains all the queued and in-progress writes to the cache.

Definition at line 65 of file CustomDiskCache.cs.

CacheIndex ImageResizer.Plugins.DiskCache.CustomDiskCache.Index

get

Provides an in-memory index of the cache.

Definition at line 75 of file CustomDiskCache.cs.

LockProvider ImageResizer.Plugins.DiskCache.CustomDiskCache.Locks

get

Provides string-based locking for file write access.

Definition at line 49 of file CustomDiskCache.cs.

LockProvider ImageResizer.Plugins.DiskCache.CustomDiskCache.QueueLocks

get

Provides string-based locking for image resizing (not writing, just processing). Prevents duplication of efforts in asynchronous mode, where 'Locks' is not being used.

Definition at line 57 of file CustomDiskCache.cs.

Event Documentation

CacheResultHandler ImageResizer.Plugins.DiskCache.CustomDiskCache.CacheResultReturned

Fired immediately before GetCachedFile return the result value.

Definition at line 42 of file CustomDiskCache.cs.

The documentation for this class was generated from the following file:

C:/Users/nathanael/Documents/resizer/Plugins/DiskCache/CustomDiskCache.cs

Public Member Functions

Protected Attributes

Properties

Events

Detailed Description

Member Function Documentation

Property Documentation

Event Documentation