4 files changed, 143 insertions, 40 deletions

diff --git a/OpenSim/Region/CoreModules/Asset/CenomeAssetCache.cs b/OpenSim/Region/CoreModules/Asset/CenomeAssetCache.cs
index e40caec..f43305f 100644
--- a/OpenSim/Region/CoreModules/Asset/CenomeAssetCache.cs
+++ b/OpenSim/Region/CoreModules/Asset/CenomeAssetCache.cs
@@ -194,6 +194,12 @@ namespace OpenSim.Region.CoreModules.Asset
 
         #region IImprovedAssetCache Members
 
+
+        public bool Check(string id)
+        {
+            return false;
+        }
+
         /// <summary>
         /// Cache asset.
         /// </summary>
diff --git a/OpenSim/Region/CoreModules/Asset/CoreAssetCache.cs b/OpenSim/Region/CoreModules/Asset/CoreAssetCache.cs
index 9742a5c..58ce61a 100644
--- a/OpenSim/Region/CoreModules/Asset/CoreAssetCache.cs
+++ b/OpenSim/Region/CoreModules/Asset/CoreAssetCache.cs
@@ -112,6 +112,10 @@ namespace OpenSim.Region.CoreModules.Asset
         ////////////////////////////////////////////////////////////
         // IImprovedAssetCache
         //
+        public bool Check(string id)
+        {
+            return false;
+        }
 
         public void Cache(AssetBase asset)
         {
diff --git a/OpenSim/Region/CoreModules/Asset/FlotsamAssetCache.cs b/OpenSim/Region/CoreModules/Asset/FlotsamAssetCache.cs
index 8e800cb..a0f1e8c 100644
--- a/OpenSim/Region/CoreModules/Asset/FlotsamAssetCache.cs
+++ b/OpenSim/Region/CoreModules/Asset/FlotsamAssetCache.cs
@@ -251,57 +251,70 @@ namespace OpenSim.Region.CoreModules.Asset
 
         private void UpdateFileCache(string key, AssetBase asset)
         {
-            string filename = GetFileName(asset.ID);
-
-            try
+            // TODO: Spawn this off to some seperate thread to do the actual writing
+            if (asset != null)
             {
-                // If the file is already cached just update access time.
-                if (File.Exists(filename))
-                {
-                    lock (m_CurrentlyWriting)
-                    {
-                        if (!m_CurrentlyWriting.Contains(filename))
-                            File.SetLastAccessTime(filename, DateTime.Now);
-                    }
-                }
-                else
+                string filename = GetFileName(key);
+
+                try
                 {
-                    // Once we start writing, make sure we flag that we're writing
-                    // that object to the cache so that we don't try to write the
-                    // same file multiple times.
-                    lock (m_CurrentlyWriting)
+                    // If the file is already cached, don't cache it, just touch it so access time is updated
+                    if (File.Exists(filename))
                     {
-#if WAIT_ON_INPROGRESS_REQUESTS
-                        if (m_CurrentlyWriting.ContainsKey(filename))
+                        // We don't really want to know about sharing
+                        // violations here. If the file is locked, then
+                        // the other thread has updated the time for us.
+                        try
                         {
-                            return;
+                            lock (m_CurrentlyWriting)
+                            {
+                                if (!m_CurrentlyWriting.Contains(filename))
+                                    File.SetLastAccessTime(filename, DateTime.Now);
+                            }
                         }
-                        else
+                        catch
                         {
-                            m_CurrentlyWriting.Add(filename, new ManualResetEvent(false));
-                       }
-
-#else
-                        if (m_CurrentlyWriting.Contains(filename))
-                        {
-                            return;
                         }
-                        else
+                    } else {
+
+                        // Once we start writing, make sure we flag that we're writing
+                        // that object to the cache so that we don't try to write the 
+                        // same file multiple times.
+                        lock (m_CurrentlyWriting)
                         {
-                            m_CurrentlyWriting.Add(filename);
-                        }
+#if WAIT_ON_INPROGRESS_REQUESTS
+                            if (m_CurrentlyWriting.ContainsKey(filename))
+                            {
+                                return;
+                            }
+                            else
+                            {
+                                m_CurrentlyWriting.Add(filename, new ManualResetEvent(false));
+                            }
+
+#else
+                            if (m_CurrentlyWriting.Contains(filename))
+                            {
+                                return;
+                            }
+                            else
+                            {
+                                m_CurrentlyWriting.Add(filename);
+                            }
 #endif
-                    }
 
-                    Util.FireAndForget(
-                        delegate { WriteFileCache(filename, asset); });
+                        }
+
+                        Util.FireAndForget(
+                            delegate { WriteFileCache(filename, asset); });
+                    }
+                }
+                catch (Exception e)
+                {
+                    m_log.ErrorFormat(
+                        "[FLOTSAM ASSET CACHE]: Failed to update cache for asset {0}.  Exception {1} {2}",
+                        asset.ID, e.Message, e.StackTrace);
                 }
-            }
-            catch (Exception e)
-            {
-                m_log.ErrorFormat(
-                    "[FLOTSAM ASSET CACHE]: Failed to update cache for asset {0}.  Exception {1} {2}",
-                    asset.ID, e.Message, e.StackTrace);
             }
         }
 
@@ -335,6 +348,17 @@ namespace OpenSim.Region.CoreModules.Asset
             return asset;
         }
 
+        private bool CheckFromMemoryCache(string id)
+        {
+            AssetBase asset = null;
+
+            if (m_MemoryCache.TryGetValue(id, out asset))
+                return true;
+
+            return false;
+        }
+
+
         /// <summary>
         /// Try to get an asset from the file cache.
         /// </summary>
@@ -407,6 +431,50 @@ namespace OpenSim.Region.CoreModules.Asset
             return asset;
         }
 
+        private bool CheckFromFileCache(string id)
+        {
+            bool found = false;
+
+            string filename = GetFileName(id);
+            if (File.Exists(filename))
+            {
+                // actually check if we can open it, and so update expire
+                FileStream stream = null;
+                try
+                {
+                    stream = File.Open(filename, FileMode.Open, FileAccess.Read, FileShare.Read);
+                    if (stream != null)
+                    {
+                        found = true;
+                        stream.Close();
+                    }
+
+                }
+                catch (System.Runtime.Serialization.SerializationException e)
+                {
+                    found = false;
+                    m_log.ErrorFormat(
+                        "[FLOTSAM ASSET CACHE]: Failed to check file {0} for asset {1}.  Exception {2} {3}",
+                        filename, id, e.Message, e.StackTrace);
+
+                    // If there was a problem deserializing the asset, the asset may
+                    // either be corrupted OR was serialized under an old format
+                    // {different version of AssetBase} -- we should attempt to
+                    // delete it and re-cache
+                    File.Delete(filename);
+                }
+                catch (Exception e)
+                {
+                    found = false;
+                    m_log.ErrorFormat(
+                        "[FLOTSAM ASSET CACHE]: Failed to check file {0} for asset {1}.  Exception {2} {3}",
+                        filename, id, e.Message, e.StackTrace);
+                }
+            }
+
+            return found;
+        }
+
         public AssetBase Get(string id)
         {
             m_Requests++;
@@ -443,11 +511,26 @@ namespace OpenSim.Region.CoreModules.Asset
             return asset;
         }
 
+        public bool Check(string id)
+        {
+            if (m_MemoryCacheEnabled && CheckFromMemoryCache(id))
+                return true;
+
+            if (m_FileCacheEnabled && CheckFromFileCache(id))
+                return true;
+            return false;
+        }
+
         public AssetBase GetCached(string id)
         {
             return Get(id);
         }
 
+        public AssetBase CheckCached(string id)
+        {
+            return Get(id);
+        }
+
         public void Expire(string id)
         {
             if (m_LogLevel >= 2)
@@ -928,6 +1011,11 @@ namespace OpenSim.Region.CoreModules.Asset
             return asset.Data;
         }
 
+        public bool CheckData(string id)
+        {
+            return Check(id); ;
+        }
+
         public bool Get(string id, object sender, AssetRetrieved handler)
         {
             AssetBase asset = Get(id);
diff --git a/OpenSim/Region/CoreModules/Asset/GlynnTuckerAssetCache.cs b/OpenSim/Region/CoreModules/Asset/GlynnTuckerAssetCache.cs
index 9592ca0..ce9b546 100644
--- a/OpenSim/Region/CoreModules/Asset/GlynnTuckerAssetCache.cs
+++ b/OpenSim/Region/CoreModules/Asset/GlynnTuckerAssetCache.cs
@@ -115,6 +115,11 @@ namespace OpenSim.Region.CoreModules.Asset
         // IImprovedAssetCache
         //
 
+        public bool Check(string id)
+        {
+            return false;
+        }
+
         public void Cache(AssetBase asset)
         {
             if (asset != null)