Inheritance diagram for ImageResizer.Plugins.DiskCache.CleanupWorker:

Collaboration diagram for ImageResizer.Plugins.DiskCache.CleanupWorker:

Public Member Functions
	CleanupWorker (ILoggerProvider lp, CleanupStrategy cs, CleanupQueue queue, CustomDiskCache cache)
	Creates and starts a thread that consumes the queue, pausing until notified when 'queue' empties. More...

void	MayHaveWork ()
	Tells the worker to check the queue for more work. More...

void	BeLazy ()
	Tells the worker to avoid work for a little bit. More...

override IEnumerable< IIssue >	GetIssues ()
	Returns a copy of the list of reported issues. More...

void	Dispose ()

void	FlushAccessedDate (CleanupWorkItem item)

Public Member Functions inherited from ImageResizer.Configuration.Issues.IssueSink
	IssueSink (string defaultSource)

virtual void	AcceptIssue (IIssue i)
	Adds the specified issue to the list unless it is an exact duplicate of another instance. More...

Protected Member Functions
void	main ()
	Thread runs this method. More...

void	mainInner ()
	Processes work items from the queue, using at most 50% More...

bool	DoWorkFor (TimeSpan length)
	Processes items from the queue for roughly the specified amount of time. Returns false if the queue was empty. More...

void	DoTask (CleanupWorkItem item)

string	addSlash (string s, bool physical)

void	PopulateFolder (CleanupWorkItem item, bool recursive)

void	RemoveFile (CleanupWorkItem item)

void	CleanFolder (CleanupWorkItem item, bool recursvie)

Protected Attributes
long	lastFoundItemsOverMax = DateTime.MinValue.Ticks
	The last time a cache folder exceeded both the optimum and maximum limits for file count. If recent, indicates a misconfiguration; the subfolders="" count needs to be increased. More...

long	lastBusy = DateTime.MinValue.Ticks
	The last time a cache query came through More...

long	lastWorked = DateTime.MinValue.Ticks
	The last time we did work (or attempted to do work, failing if the queue was empty) More...

bool	otherProcessManagingCleanup = false
	When true, indicates that another process is managing cleanup operations - this thread is idle, waiting for the other process to end before it can pick up work. More...

readonly object	_timesLock = new object()

volatile bool	shuttingDown = false

Protected Attributes inherited from ImageResizer.Configuration.Issues.IssueSink
string	defaultSource = null

Properties
bool	ExteralProcessCleaning `[get]`
	When true, indicates that another process is managing cleanup operations - this thread is idle, waiting for the other process to end before it can pick up work. More...

Detailed Description

Definition at line 14 of file CleanupWorker.cs.

Constructor & Destructor Documentation

ImageResizer.Plugins.DiskCache.CleanupWorker.CleanupWorker	(	ILoggerProvider	lp,
		CleanupStrategy	cs,
		CleanupQueue	queue,
		CustomDiskCache	cache
	)

inline

Creates and starts a thread that consumes the queue, pausing until notified when 'queue' empties.

Parameters

cs
queue
cache

Definition at line 29 of file CleanupWorker.cs.

                                                                                                                :base("DiskCache-CleanupWorker") {
             this.cs = cs;
             this.queue = queue;
             this.cache = cache;
             this.lp = lp;
             t = new Thread(main);
             t.IsBackground = true;
             t.Start();
         }

Member Function Documentation

void ImageResizer.Plugins.DiskCache.CleanupWorker.BeLazy ( )

inline

Tells the worker to avoid work for a little bit.

Definition at line 58 of file CleanupWorker.cs.

                              {
             lock(_timesLock) lastBusy = DateTime.UtcNow.Ticks;
             
         }

bool ImageResizer.Plugins.DiskCache.CleanupWorker.DoWorkFor ( TimeSpan length )

inlineprotected

Processes items from the queue for roughly the specified amount of time. Returns false if the queue was empty.

Parameters

length

Returns

Definition at line 210 of file CleanupWorker.cs.

                                                   {
             if (queue.IsEmpty) return false;
 
             DateTime startedAt = DateTime.UtcNow;
             //Proccess as many items from the queue as possible
             while (DateTime.UtcNow.Subtract(startedAt) < length && !queue.IsEmpty) {
                 //Check for shutdown
                 if (shuttingDown) return true;
                 try {
                     DoTask(queue.Pop());
                 } catch (Exception e) {
                     if (Debugger.IsAttached) throw;
                     if (lp.Logger != null) lp.Logger.Error("Failed exeuting task {0}", e.Message + e.StackTrace);
                     this.AcceptIssue(new Issue("Failed exeuting task", e.Message + e.StackTrace, IssueSeverity.Critical));
                 }
             }
             return true;
         }

override IEnumerable<IIssue> ImageResizer.Plugins.DiskCache.CleanupWorker.GetIssues ( )

inlinevirtual

Returns a copy of the list of reported issues.

Returns

Reimplemented from ImageResizer.Configuration.Issues.IssueSink.

Definition at line 190 of file CleanupWorker.cs.

                                                         {
             List<IIssue> issues = new List<IIssue>(base.GetIssues());
             if (ExteralProcessCleaning) 
                 issues.Add(new Issue("An external process indicates it is managing cleanup of the disk cache. " + 
                 "This process is not currently managing disk cache cleanup. If configured as a web garden, keep in mind that the negligible performance gains are likely to be outweighed by the loss of cache optimization quality.", IssueSeverity.Warning));
             lock (_timesLock) {
                 if (this.lastFoundItemsOverMax > (DateTime.UtcNow.Subtract(new TimeSpan(0, 5, 0)).Ticks))
                     issues.Add(new Issue("Your cache configuration may not be optimal. If this message persists, you should increase the 'subfolders' value in the <diskcache /> element in Web.config",
                         "In the last 5 minutes, a cache folder exceeded both the optimum and maximum limits for file count. This usually indicates that your 'subfolders' setting is too low, and that cached images are being deleted shortly after their creation. \n" +
                         "To estimate the appropriate subfolders value, multiply the total number of images on the site times the average number of size variations, and divide by 400. I.e, 6,400 images with 2 variants would be 32. If in doubt, set the value higher, but ensure there is disk space available.", IssueSeverity.Error));
 
             }
             return issues;
         }

void ImageResizer.Plugins.DiskCache.CleanupWorker.main ( )

inlineprotected

Thread runs this method.

Definition at line 79 of file CleanupWorker.cs.

                               {
             try {
                 mainInner();
             } catch (Exception ex) {
                 if (Debugger.IsAttached) throw;
                 if (lp.Logger != null) lp.Logger.Error("Contact support! A critical (and unexpected) exception occured in the disk cache cleanup worker thread. This needs to be investigated. {0}", ex.Message + ex.StackTrace);
                 this.AcceptIssue(new Issue("Contact support! A critical (and unexpected) exception occured in the disk cache cleanup worker thread. This needs to be investigated. ", ex.Message + ex.StackTrace, IssueSeverity.Critical));
             }
         }

void ImageResizer.Plugins.DiskCache.CleanupWorker.mainInner ( )

inlineprotected

Processes work items from the queue, using at most 50%

Definition at line 91 of file CleanupWorker.cs.

                                   {
             //TODO: Verify that GetHashCode() is the same between .net 2 and 4. 
             string mutexKey = "ir.cachedir:" + cache.PhysicalCachePath.ToLowerInvariant().GetHashCode().ToString("x", NumberFormatInfo.InvariantInfo);
 
             //Sleep for the duration requested before trying anything. 
             _quitWait.WaitOne(cs.StartupDelay);
 
             Mutex cleanupLock = null;
             bool hasLock = false;
            
             try {
                 //Try to create and lock the mutex, or else open and lock it.
                 try{
                     cleanupLock = new Mutex(true, mutexKey, out hasLock);
                 }catch(UnauthorizedAccessException){
                     hasLock = false;
                 }
          
                 //Start the work loop
                 while (true) {
                     //Check for shutdown
                     if (shuttingDown) return;
 
                     //Try to acquire a reference to the lock if we didn't have access last time.
                     if (cleanupLock == null) {
                         //In this case, another process (running as another user account) has opened the lock. Eventually it may be garbage collected.
                         try {
                             cleanupLock = new Mutex(true, mutexKey, out hasLock);
                         } catch (UnauthorizedAccessException) {
                             hasLock = false;
                         }
                     }
 
                     otherProcessManagingCleanup = !hasLock;
                     if (!hasLock) {
                         //If we have a reference, Wait until the other process calls ReleaseMutex(), or for 30 seconds, whichever is shorter.
                         if (cleanupLock != null) hasLock = cleanupLock.WaitOne(30000);
                         else Thread.Sleep(10000); //Otherwise just sleep 10s and check again, waiting for the mutex to be garbage collected so we can recreate it.
                     }
                     otherProcessManagingCleanup = !hasLock;
                     if (!hasLock) {
                         //Still no luck, someone else is managing things...
                         //Clear out the todo-list
                         queue.Clear();
                         //Get back to doing nothing.
                         continue;
                     }
                     
 
                     //Is it time to do some work?
                     bool noWorkInTooLong = false; //Has it been too long since we did something?
                     lock (_timesLock) noWorkInTooLong = (DateTime.UtcNow.Subtract(new DateTime(lastWorked)) > cs.MaxDelay);
 
                     bool notBusy = false; //Is the server busy recently?
                     lock (_timesLock) notBusy = (DateTime.UtcNow.Subtract(new DateTime(lastBusy)) > cs.MinDelay);
                     //doSomeWork keeps being true in absence of incoming requests
 
                     //If the server isn't busy, or if this worker has been lazy to long long, do some work and time it.
                     Stopwatch workedForTime = null;
                     if (noWorkInTooLong || notBusy) {
                         workedForTime = new Stopwatch();
                         workedForTime.Start();
                         DoWorkFor(cs.OptimalWorkSegmentLength);
                         lock (_timesLock) lastWorked = DateTime.UtcNow.Ticks; 
                         workedForTime.Stop();
                     }
 
                     //Check for shutdown
                     if (shuttingDown) return;
 
                     
                     //Nothing to do, queue is empty.
                     if (queue.IsEmpty)
                         //Wait perpetually until notified of more queue items.
                         _queueWait.WaitOne();
                     else if (notBusy)
                         //Don't flood the system even when it's not busy. 50% usage here. Wait for the length of time worked or the optimal work time, whichever is longer.
                         //A directory listing can take 30 seconds sometimes and kill the cpu.
                         _quitWait.WaitOne((int)Math.Max(cs.OptimalWorkSegmentLength.TotalMilliseconds, workedForTime.ElapsedMilliseconds));
 
                     else {
                         //Estimate how long before we can run more code.
                         long busyTicks = 0;
                         lock (_timesLock) busyTicks = (cs.MinDelay - DateTime.UtcNow.Subtract(new DateTime(lastBusy))).Ticks;
                         long maxTicks = 0;
                         lock (_timesLock) maxTicks = (cs.MaxDelay - DateTime.UtcNow.Subtract(new DateTime(lastWorked))).Ticks;
                         //Use the longer value and add a second to avoid rounding and timing errors.
                         _quitWait.WaitOne(new TimeSpan(Math.Max(busyTicks, maxTicks)) + new TimeSpan(0, 0, 1));
                     } 
 
                     //Check for shutdown
                     if (shuttingDown) return;
                 }
             } finally {
                 if (hasLock) cleanupLock.ReleaseMutex();
                 otherProcessManagingCleanup = false;
             }
         }

void ImageResizer.Plugins.DiskCache.CleanupWorker.MayHaveWork ( )

inline

Tells the worker to check the queue for more work.

Definition at line 41 of file CleanupWorker.cs.

                                   {
             _queueWait.Set();
         }

Member Data Documentation

long ImageResizer.Plugins.DiskCache.CleanupWorker.lastBusy = DateTime.MinValue.Ticks

protected

The last time a cache query came through

Definition at line 54 of file CleanupWorker.cs.

long ImageResizer.Plugins.DiskCache.CleanupWorker.lastFoundItemsOverMax = DateTime.MinValue.Ticks

protected

The last time a cache folder exceeded both the optimum and maximum limits for file count. If recent, indicates a misconfiguration; the subfolders="" count needs to be increased.

Definition at line 49 of file CleanupWorker.cs.

long ImageResizer.Plugins.DiskCache.CleanupWorker.lastWorked = DateTime.MinValue.Ticks

protected

The last time we did work (or attempted to do work, failing if the queue was empty)

Definition at line 65 of file CleanupWorker.cs.

bool ImageResizer.Plugins.DiskCache.CleanupWorker.otherProcessManagingCleanup = false

protected

When true, indicates that another process is managing cleanup operations - this thread is idle, waiting for the other process to end before it can pick up work.

Definition at line 74 of file CleanupWorker.cs.

Property Documentation

bool ImageResizer.Plugins.DiskCache.CleanupWorker.ExteralProcessCleaning

get

When true, indicates that another process is managing cleanup operations - this thread is idle, waiting for the other process to end before it can pick up work.

Definition at line 70 of file CleanupWorker.cs.

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

C:/Users/nathanael/Documents/resizer/Plugins/DiskCache/Cleanup/CleanupWorker.cs

Public Member Functions

Protected Member Functions

Protected Attributes

Properties

Detailed Description

Constructor & Destructor Documentation

Member Function Documentation

Member Data Documentation

Property Documentation