1 files changed, 290 insertions, 76 deletions

diff --git a/OpenSim/Services/Connectors/Asset/AssetServicesConnector.cs b/OpenSim/Services/Connectors/Asset/AssetServicesConnector.cs
index bd43552..622780a 100644
--- a/OpenSim/Services/Connectors/Asset/AssetServicesConnector.cs
+++ b/OpenSim/Services/Connectors/Asset/AssetServicesConnector.cs
@@ -27,9 +27,11 @@
 
 using log4net;
 using System;
+using System.Threading;
 using System.Collections.Generic;
 using System.IO;
 using System.Reflection;
+using System.Timers;
 using Nini.Config;
 using OpenSim.Framework;
 using OpenSim.Framework.Console;
@@ -46,13 +48,22 @@ namespace OpenSim.Services.Connectors
 
         private string m_ServerURI = String.Empty;
         private IImprovedAssetCache m_Cache = null;
+        private int m_retryCounter;
+        private Dictionary<int, List<AssetBase>> m_retryQueue = new Dictionary<int, List<AssetBase>>();
+        private System.Timers.Timer m_retryTimer;
         private int m_maxAssetRequestConcurrency = 30;
         
         private delegate void AssetRetrievedEx(AssetBase asset);
 
         // Keeps track of concurrent requests for the same asset, so that it's only loaded once.
         // Maps: Asset ID -> Handlers which will be called when the asset has been loaded
-        private Dictionary<string, AssetRetrievedEx> m_AssetHandlers = new Dictionary<string, AssetRetrievedEx>();
+//        private Dictionary<string, AssetRetrievedEx> m_AssetHandlers = new Dictionary<string, AssetRetrievedEx>();
+
+        private Dictionary<string, List<AssetRetrievedEx>> m_AssetHandlers = new Dictionary<string, List<AssetRetrievedEx>>();
+
+        private Dictionary<string, string> m_UriMap = new Dictionary<string, string>();
+
+        private Thread[] m_fetchThreads;
 
         public int MaxAssetRequestConcurrency
         {
@@ -91,13 +102,113 @@ namespace OpenSim.Services.Connectors
             string serviceURI = assetConfig.GetString("AssetServerURI",
                     String.Empty);
 
+            m_ServerURI = serviceURI;
+
             if (serviceURI == String.Empty)
             {
                 m_log.Error("[ASSET CONNECTOR]: No Server URI named in section AssetService");
                 throw new Exception("Asset connector init error");
             }
 
-            m_ServerURI = serviceURI;
+
+            m_retryTimer = new System.Timers.Timer();
+            m_retryTimer.Elapsed += new ElapsedEventHandler(retryCheck);
+            m_retryTimer.Interval = 60000;
+
+            Uri serverUri = new Uri(m_ServerURI);
+
+            string groupHost = serverUri.Host;
+
+            for (int i = 0 ; i < 256 ; i++)
+            {
+                string prefix = i.ToString("x2");
+                groupHost = assetConfig.GetString("AssetServerHost_"+prefix, groupHost);
+
+                m_UriMap[prefix] = groupHost;
+                //m_log.DebugFormat("[ASSET]: Using {0} for prefix {1}", groupHost, prefix);
+            }
+
+            m_fetchThreads = new Thread[2];
+
+            for (int i = 0 ; i < 2 ; i++)
+            {
+                m_fetchThreads[i] = new Thread(AssetRequestProcessor);
+                m_fetchThreads[i].Start();
+            }
+        }
+
+        private string MapServer(string id)
+        {
+            if (m_UriMap.Count == 0)
+                return m_ServerURI;
+
+            UriBuilder serverUri = new UriBuilder(m_ServerURI);
+
+            string prefix = id.Substring(0, 2).ToLower();
+
+            string host;
+            
+            // HG URLs will not be valid UUIDS
+            if (m_UriMap.ContainsKey(prefix))
+                host = m_UriMap[prefix];
+            else
+                host = m_UriMap["00"];
+
+            serverUri.Host = host;
+
+            // m_log.DebugFormat("[ASSET]: Using {0} for host name for prefix {1}", host, prefix);
+
+            string ret = serverUri.Uri.AbsoluteUri;
+            if (ret.EndsWith("/"))
+                ret = ret.Substring(0, ret.Length - 1);
+            return ret;
+        }
+
+        protected void retryCheck(object source, ElapsedEventArgs e)
+        {
+            m_retryCounter++;
+            if (m_retryCounter > 60)
+                m_retryCounter -= 60;
+
+            List<int> keys = new List<int>();
+            foreach (int a in m_retryQueue.Keys)
+            {
+                keys.Add(a);
+            }
+            foreach (int a in keys)
+            {
+                //We exponentially fall back on frequency until we reach one attempt per hour
+                //The net result is that we end up in the queue for roughly 24 hours..
+                //24 hours worth of assets could be a lot, so the hope is that the region admin
+                //will have gotten the asset connector back online quickly!
+
+                int timefactor = a ^ 2; 
+                if (timefactor > 60)
+                {
+                    timefactor = 60;
+                }
+
+                //First, find out if we care about this timefactor
+                if (timefactor % a == 0)
+                {
+                    //Yes, we do!   
+                    List<AssetBase> retrylist = m_retryQueue[a];
+                    m_retryQueue.Remove(a);
+
+                    foreach(AssetBase ass in retrylist)
+                    {
+                        Store(ass); //Store my ass. This function will put it back in the dictionary if it fails
+                    }
+                }
+            }
+
+            if (m_retryQueue.Count == 0)
+            {
+                //It might only be one tick per minute, but I have
+                //repented and abandoned my wasteful ways
+                m_retryCounter = 0;
+                m_retryTimer.Stop();
+            }
         }
 
         protected void SetCache(IImprovedAssetCache cache)
@@ -107,15 +218,13 @@ namespace OpenSim.Services.Connectors
 
         public AssetBase Get(string id)
         {
-//            m_log.DebugFormat("[ASSET SERVICE CONNECTOR]: Synchronous get request for {0}", id);
-
-            string uri = m_ServerURI + "/assets/" + id;
+            string uri = MapServer(id) + "/assets/" + id;
 
             AssetBase asset = null;
             if (m_Cache != null)
                 asset = m_Cache.Get(id);
-
-            if (asset == null)
+            
+            if (asset == null || asset.Data == null || asset.Data.Length == 0)
             {
                 // XXX: Commented out for now since this has either never been properly operational or not for some time
                 // as m_maxAssetRequestConcurrency was being passed as the timeout, not a concurrency limiting option.
@@ -154,7 +263,7 @@ namespace OpenSim.Services.Connectors
                     return fullAsset.Metadata;
             }
 
-            string uri = m_ServerURI + "/assets/" + id + "/metadata";
+            string uri = MapServer(id) + "/assets/" + id + "/metadata";
 
             AssetMetadata asset = SynchronousRestObjectRequester.MakeRequest<int, AssetMetadata>("GET", uri, 0, m_Auth);
             return asset;
@@ -170,7 +279,7 @@ namespace OpenSim.Services.Connectors
                     return fullAsset.Data;
             }
 
-            using (RestClient rc = new RestClient(m_ServerURI))
+            using (RestClient rc = new RestClient(MapServer(id)))
             {
                 rc.AddResourcePath("assets");
                 rc.AddResourcePath(id);
@@ -178,83 +287,136 @@ namespace OpenSim.Services.Connectors
 
                 rc.RequestMethod = "GET";
 
-                Stream s = rc.Request(m_Auth);
-
-                if (s == null)
-                    return null;
-
-                if (s.Length > 0)
+                using (Stream s = rc.Request(m_Auth))
                 {
-                    byte[] ret = new byte[s.Length];
-                    s.Read(ret, 0, (int)s.Length);
+                    if (s == null)
+                        return null;
 
-                    return ret;
-                }
+                    if (s.Length > 0)
+                    {
+                        byte[] ret = new byte[s.Length];
+                        s.Read(ret, 0, (int)s.Length);
 
+                        return ret;
+                    }
+                }
                 return null;
             }
         }
 
-        public bool Get(string id, Object sender, AssetRetrieved handler)
+        private class QueuedAssetRequest
         {
-//            m_log.DebugFormat("[ASSET SERVICE CONNECTOR]: Potentially asynchronous get request for {0}", id);
+            public string uri;
+            public string id;
+        }
 
-            string uri = m_ServerURI + "/assets/" + id;
+        private OpenMetaverse.BlockingQueue<QueuedAssetRequest> m_requestQueue =
+                new OpenMetaverse.BlockingQueue<QueuedAssetRequest>();
 
-            AssetBase asset = null;
-            if (m_Cache != null)
-                asset = m_Cache.Get(id);
+        private void AssetRequestProcessor()
+        {
+            QueuedAssetRequest r;
 
-            if (asset == null)
+            while (true)
             {
-                lock (m_AssetHandlers)
-                {
-                    AssetRetrievedEx handlerEx = new AssetRetrievedEx(delegate(AssetBase _asset) { handler(id, sender, _asset); });
+                r = m_requestQueue.Dequeue();
 
-                    AssetRetrievedEx handlers;
-                    if (m_AssetHandlers.TryGetValue(id, out handlers))
-                    {
-                        // Someone else is already loading this asset. It will notify our handler when done.
-                        handlers += handlerEx;
-                        return true;
-                    }
-
-                    // Load the asset ourselves
-                    handlers += handlerEx;
-                    m_AssetHandlers.Add(id, handlers);
-                }
+                string uri = r.uri;
+                string id = r.id;
 
                 bool success = false;
                 try
                 {
-                    AsynchronousRestObjectRequester.MakeRequest<int, AssetBase>("GET", uri, 0,
-                        delegate(AssetBase a)
+                    AssetBase a = SynchronousRestObjectRequester.MakeRequest<int, AssetBase>("GET", uri, 0, 30000, m_Auth);
+                    if (a != null)
+                    {
+                        if (m_Cache != null)
+                            m_Cache.Cache(a);
+
+                        List<AssetRetrievedEx> handlers;
+                        lock (m_AssetHandlers)
                         {
-                            if (a != null && m_Cache != null)
-                                m_Cache.Cache(a);
+                            handlers = m_AssetHandlers[id];
+                            m_AssetHandlers.Remove(id);
+                        }
 
-                            AssetRetrievedEx handlers;
-                            lock (m_AssetHandlers)
+                        Util.FireAndForget(x =>
                             {
-                                handlers = m_AssetHandlers[id];
-                                m_AssetHandlers.Remove(id);
-                            }
-                            handlers.Invoke(a);
-                        }, m_maxAssetRequestConcurrency, m_Auth);
-                    
-                    success = true;
+
+                                foreach (AssetRetrievedEx h in handlers)
+                                {
+                                    // Util.FireAndForget(x =>
+                                    // {
+                                    try { h.Invoke(a); }
+                                    catch { }
+                                    // });
+                                }
+
+                                if (handlers != null)
+                                    handlers.Clear();
+
+                            });
+
+//                        if (handlers != null)
+//                            handlers.Clear();
+                        success = true;
+                    }
                 }
                 finally
                 {
                     if (!success)
                     {
+                        List<AssetRetrievedEx> handlers;
                         lock (m_AssetHandlers)
                         {
+                            handlers = m_AssetHandlers[id];
                             m_AssetHandlers.Remove(id);
                         }
+                        if (handlers != null)
+                            handlers.Clear();
                     }
                 }
             }
+        }
+
+        public bool Get(string id, Object sender, AssetRetrieved handler)
+        {
+            string uri = MapServer(id) + "/assets/" + id;
+
+            AssetBase asset = null;
+            if (m_Cache != null)
+                asset = m_Cache.Get(id);
+
+            if (asset == null || asset.Data == null || asset.Data.Length == 0)
+            {
+                lock (m_AssetHandlers)
+                {
+                    AssetRetrievedEx handlerEx = new AssetRetrievedEx(delegate(AssetBase _asset) { handler(id, sender, _asset); });
+
+//                    AssetRetrievedEx handlers;
+                    List<AssetRetrievedEx> handlers;
+                    if (m_AssetHandlers.TryGetValue(id, out handlers))
+                    {
+                        // Someone else is already loading this asset. It will notify our handler when done.
+//                        handlers += handlerEx;
+                        handlers.Add(handlerEx);
+                        return true;
+                    }
+
+                    // Load the asset ourselves
+//                    handlers += handlerEx;
+                    handlers = new List<AssetRetrievedEx>();
+                    handlers.Add(handlerEx);
+
+                    m_AssetHandlers.Add(id, handlers);
+                }
+
+                QueuedAssetRequest request = new QueuedAssetRequest();
+                request.id = id;
+                request.uri = uri;
+
+                m_requestQueue.Enqueue(request);
+            }
             else
             {
                 handler(id, sender, asset);
@@ -286,43 +448,95 @@ namespace OpenSim.Services.Connectors
 
         public string Store(AssetBase asset)
         {
-            if (asset.Local)
+            // Have to assign the asset ID here. This isn't likely to
+            // trigger since current callers don't pass emtpy IDs
+            // We need the asset ID to route the request to the proper
+            // cluster member, so we can't have the server assign one.
+            if (asset.ID == string.Empty)
             {
-                if (m_Cache != null)
-                    m_Cache.Cache(asset);
+                if (asset.FullID == UUID.Zero)
+                {
+                    asset.FullID = UUID.Random();
+                }
+                asset.ID = asset.FullID.ToString();
+            }
+            else if (asset.FullID == UUID.Zero)
+            {
+                UUID uuid = UUID.Zero;
+                if (UUID.TryParse(asset.ID, out uuid))
+                {
+                    asset.FullID = uuid;
+                }
+                else
+                {
+                    asset.FullID = UUID.Random();
+                }
+            }
 
+            if (m_Cache != null)
+                m_Cache.Cache(asset);
+            if (asset.Temporary || asset.Local)
+            {
                 return asset.ID;
             }
 
-            string uri = m_ServerURI + "/assets/";
+            string uri = MapServer(asset.FullID.ToString()) + "/assets/";
 
             string newID;
             try
             {
-                newID = SynchronousRestObjectRequester.MakeRequest<AssetBase, string>("POST", uri, asset, m_Auth);
+                newID = SynchronousRestObjectRequester.
+                        MakeRequest<AssetBase, string>("POST", uri, asset, 100000, m_Auth);
+                if (newID == null || newID == "")
+                {
+                    newID = UUID.Zero.ToString();
+                }
             }
             catch (Exception e)
             {
-                m_log.Warn(string.Format("[ASSET CONNECTOR]: Unable to send asset {0} to asset server. Reason: {1} ", asset.ID, e.Message), e);
-                return string.Empty;
+                newID = UUID.Zero.ToString();
             }
 
-            // TEMPORARY: SRAS returns 'null' when it's asked to store existing assets
-            if (newID == null)
+            if (newID == UUID.Zero.ToString())
             {
-                m_log.DebugFormat("[ASSET CONNECTOR]: Storing of asset {0} returned null; assuming the asset already exists", asset.ID);
-                return asset.ID;
+                //The asset upload failed, put it in a queue for later
+                asset.UploadAttempts++;
+                if (asset.UploadAttempts > 30)
+                {
+                    //By this stage we've been in the queue for a good few hours;
+                    //We're going to drop the asset.
+                    m_log.ErrorFormat("[Assets] Dropping asset {0} - Upload has been in the queue for too long.", asset.ID.ToString());
+                }
+                else
+                {
+                    if (!m_retryQueue.ContainsKey(asset.UploadAttempts))
+                    {
+                        m_retryQueue.Add(asset.UploadAttempts, new List<AssetBase>());
+                    }
+                    List<AssetBase> m_queue = m_retryQueue[asset.UploadAttempts];
+                    m_queue.Add(asset);
+                    m_log.WarnFormat("[Assets] Upload failed: {0} - Requeuing asset for another run.", asset.ID.ToString());
+                    m_retryTimer.Start();
+                }
             }
+            else
+            {
+                if (asset.UploadAttempts > 0)
+                {
+                    m_log.InfoFormat("[Assets] Upload of {0} succeeded after {1} failed attempts", asset.ID.ToString(), asset.UploadAttempts.ToString());
+                }
+                if (newID != String.Empty)
+                {
+                    // Placing this here, so that this work with old asset servers that don't send any reply back
+                    // SynchronousRestObjectRequester returns somethins that is not an empty string
+                    if (newID != null)
+                        asset.ID = newID;
 
-            if (string.IsNullOrEmpty(newID))
-                return string.Empty;
-
-            asset.ID = newID;
-
-            if (m_Cache != null)
-                m_Cache.Cache(asset);
-
-            return newID;
+                    if (m_Cache != null)
+                        m_Cache.Cache(asset);
+                }
+            }
+            return asset.ID;
         }
 
         public bool UpdateContent(string id, byte[] data)
@@ -343,7 +557,7 @@ namespace OpenSim.Services.Connectors
             }
             asset.Data = data;
 
-            string uri = m_ServerURI + "/assets/" + id;
+            string uri = MapServer(id) + "/assets/" + id;
 
             if (SynchronousRestObjectRequester.MakeRequest<AssetBase, bool>("POST", uri, asset, m_Auth))
             {
@@ -357,7 +571,7 @@ namespace OpenSim.Services.Connectors
 
         public bool Delete(string id)
         {
-            string uri = m_ServerURI + "/assets/" + id;
+            string uri = MapServer(id) + "/assets/" + id;
 
             if (SynchronousRestObjectRequester.MakeRequest<int, bool>("DELETE", uri, 0, m_Auth))
             {