After seeing sdague do his happy dance over trunk working "the best he has ever seen". I'm not sure I should be doing this commit, but oh well.

So anyway, it moves the Asset downloading (packet sending) to a module (AssetDownloadModule). 
So now at last, AssetCache should be just dealing with fetching assets from the asset server and caching them. 

1 files changed, 268 insertions, 2 deletions

diff --git a/OpenSim/Region/Environment/Modules/AssetDownloadModule.cs b/OpenSim/Region/Environment/Modules/AssetDownloadModule.cs
index 012f920..ca01cae 100644
--- a/OpenSim/Region/Environment/Modules/AssetDownloadModule.cs
+++ b/OpenSim/Region/Environment/Modules/AssetDownloadModule.cs
@@ -26,25 +26,57 @@
 * 
 */
 
+using System;
+using System.Collections.Generic;
+using System.Threading;
 using Nini.Config;
 using OpenSim.Framework;
 using OpenSim.Region.Environment.Interfaces;
 using OpenSim.Region.Environment.Scenes;
+using libsecondlife;
+using libsecondlife.Packets;
 
 namespace OpenSim.Region.Environment.Modules
 {
     public class AssetDownloadModule : IRegionModule
     {
         private Scene m_scene;
+        private Dictionary<LLUUID, Scene> RegisteredScenes = new Dictionary<LLUUID, Scene>();
+        ///
+        /// Assets requests (for each user) which are waiting for asset server data.  This includes texture requests
+        /// </summary>
+        private Dictionary<LLUUID, Dictionary<LLUUID,AssetRequest>> RequestedAssets;
+
+        /// <summary>
+        /// Asset requests with data which are ready to be sent back to requesters.  This includes textures.
+        /// </summary>
+        private List<AssetRequest> AssetRequests;
+
+        private Thread m_thread;
 
         public AssetDownloadModule()
         {
+            RequestedAssets = new Dictionary<LLUUID, Dictionary<LLUUID, AssetRequest>>();
+            AssetRequests = new List<AssetRequest>();
         }
 
         public void Initialise(Scene scene, IConfigSource config)
         {
-            m_scene = scene;
-            m_scene.EventManager.OnNewClient += NewClient;
+            if (!RegisteredScenes.ContainsKey(scene.RegionInfo.RegionID))
+            {
+                RegisteredScenes.Add(scene.RegionInfo.RegionID, scene);
+                scene.EventManager.OnNewClient += NewClient;
+            }
+
+            if (m_scene == null)
+            {
+                m_scene = scene;
+                m_thread = new Thread(new ThreadStart(RunAssetQueue));
+                m_thread.Name = "AssetDownloadQueueThread";
+                m_thread.IsBackground = true;
+                m_thread.Start();
+                OpenSim.Framework.ThreadTracker.Add(m_thread);
+            }
         }
 
         public void PostInitialise()
@@ -67,6 +99,240 @@ namespace OpenSim.Region.Environment.Modules
 
         public void NewClient(IClientAPI client)
         {
+            client.OnRequestAsset += AddAssetRequest;
+        }
+
+        /// <summary>
+        /// Make an asset request the result of which will be packeted up and sent directly back to the client.
+        /// </summary>
+        /// <param name="userInfo"></param>
+        /// <param name="transferRequest"></param>
+        public void AddAssetRequest(IClientAPI userInfo, TransferRequestPacket transferRequest)
+        {
+            LLUUID requestID = null;
+            byte source = 2;
+            if (transferRequest.TransferInfo.SourceType == 2)
+            {
+                //direct asset request
+                requestID = new LLUUID(transferRequest.TransferInfo.Params, 0);
+            }
+            else if (transferRequest.TransferInfo.SourceType == 3)
+            {
+                //inventory asset request
+                requestID = new LLUUID(transferRequest.TransferInfo.Params, 80);
+                source = 3;
+                //Console.WriteLine("asset request " + requestID);
+            }
+
+            //not found asset
+            // so request from asset server
+            Dictionary<LLUUID, AssetRequest> userRequests = null;
+            if (RequestedAssets.TryGetValue(userInfo.AgentId, out userRequests))
+            {
+                if (!userRequests.ContainsKey(requestID))
+                {
+                   
+                    AssetRequest request = new AssetRequest();
+                    request.RequestUser = userInfo;
+                    request.RequestAssetID = requestID;
+                    request.TransferRequestID = transferRequest.TransferInfo.TransferID;
+                    request.AssetRequestSource = source;
+                    request.Params = transferRequest.TransferInfo.Params;
+                    userRequests[requestID] = request;
+                    m_scene.AssetCache.GetAsset(requestID, AssetCallback, false);
+                }
+            }
+            else
+            {
+                userRequests = new Dictionary<LLUUID, AssetRequest>();
+                AssetRequest request = new AssetRequest();
+                request.RequestUser = userInfo;
+                request.RequestAssetID = requestID;
+                request.TransferRequestID = transferRequest.TransferInfo.TransferID;
+                request.AssetRequestSource = source;
+                request.Params = transferRequest.TransferInfo.Params;
+                userRequests.Add(requestID, request);
+                RequestedAssets[userInfo.AgentId] = userRequests;
+                m_scene.AssetCache.GetAsset(requestID, AssetCallback, false);
+              
+            }
+            return;
+        }
+
+        public void AssetCallback(LLUUID assetID, AssetBase asset)
+        {
+            if (asset != null)
+            {
+                foreach (Dictionary<LLUUID, AssetRequest> userRequests in RequestedAssets.Values)
+                {
+                    if (userRequests.ContainsKey(assetID))
+                    {
+                        AssetRequest req = userRequests[assetID];
+                        if (req != null)
+                        {
+                            req.AssetInf = asset;
+                            req.NumPackets = CalculateNumPackets(asset.Data);
+
+                            userRequests.Remove(assetID);
+                            AssetRequests.Add(req);
+                        }
+                    }
+                }
+            }
+        }
+
+        private void RunAssetQueue()
+        {
+            while (true)
+            {
+                try
+                {
+                    ProcessAssetQueue();
+                    Thread.Sleep(500);
+                }
+                catch (Exception e)
+                {
+                  //  m_log.Error("[ASSET CACHE]: " + e.ToString());
+                }
+            }
+        }
+
+        /// <summary>
+        /// Process the asset queue which sends packets directly back to the client.
+        /// </summary>
+        private void ProcessAssetQueue()
+        {
+            //should move the asset downloading to a module, like has been done with texture downloading
+            if (AssetRequests.Count == 0)
+            {
+                //no requests waiting
+                return;
+            }
+            // if less than 5, do all of them
+            int num = Math.Min(5, AssetRequests.Count);
+
+            AssetRequest req;
+            for (int i = 0; i < num; i++)
+            {
+                req = (AssetRequest)AssetRequests[i];
+                //Console.WriteLine("sending asset " + req.RequestAssetID);
+                TransferInfoPacket Transfer = new TransferInfoPacket();
+                Transfer.TransferInfo.ChannelType = 2;
+                Transfer.TransferInfo.Status = 0;
+                Transfer.TransferInfo.TargetType = 0;
+                if (req.AssetRequestSource == 2)
+                {
+                    Transfer.TransferInfo.Params = new byte[20];
+                    Array.Copy(req.RequestAssetID.GetBytes(), 0, Transfer.TransferInfo.Params, 0, 16);
+                    int assType = (int)req.AssetInf.Type;
+                    Array.Copy(Helpers.IntToBytes(assType), 0, Transfer.TransferInfo.Params, 16, 4);
+                }
+                else if (req.AssetRequestSource == 3)
+                {
+                    Transfer.TransferInfo.Params = req.Params;
+                    // Transfer.TransferInfo.Params = new byte[100];
+                    //Array.Copy(req.RequestUser.AgentId.GetBytes(), 0, Transfer.TransferInfo.Params, 0, 16);
+                    //Array.Copy(req.RequestUser.SessionId.GetBytes(), 0, Transfer.TransferInfo.Params, 16, 16);
+                }
+                Transfer.TransferInfo.Size = (int)req.AssetInf.Data.Length;
+                Transfer.TransferInfo.TransferID = req.TransferRequestID;
+                req.RequestUser.OutPacket(Transfer, ThrottleOutPacketType.Asset);
+
+                if (req.NumPackets == 1)
+                {
+                    TransferPacketPacket TransferPacket = new TransferPacketPacket();
+                    TransferPacket.TransferData.Packet = 0;
+                    TransferPacket.TransferData.ChannelType = 2;
+                    TransferPacket.TransferData.TransferID = req.TransferRequestID;
+                    TransferPacket.TransferData.Data = req.AssetInf.Data;
+                    TransferPacket.TransferData.Status = 1;
+                    req.RequestUser.OutPacket(TransferPacket, ThrottleOutPacketType.Asset);
+                }
+                else
+                {
+                    int processedLength = 0;
+                    // libsecondlife hardcodes 1500 as the maximum data chunk size
+                    int maxChunkSize = 1250;
+                    int packetNumber = 0;
+
+                    while (processedLength < req.AssetInf.Data.Length)
+                    {
+                        TransferPacketPacket TransferPacket = new TransferPacketPacket();
+                        TransferPacket.TransferData.Packet = packetNumber;
+                        TransferPacket.TransferData.ChannelType = 2;
+                        TransferPacket.TransferData.TransferID = req.TransferRequestID;
+
+                        int chunkSize = Math.Min(req.AssetInf.Data.Length - processedLength, maxChunkSize);
+                        byte[] chunk = new byte[chunkSize];
+                        Array.Copy(req.AssetInf.Data, processedLength, chunk, 0, chunk.Length);
+
+                        TransferPacket.TransferData.Data = chunk;
+
+                        // 0 indicates more packets to come, 1 indicates last packet
+                        if (req.AssetInf.Data.Length - processedLength > maxChunkSize)
+                        {
+                            TransferPacket.TransferData.Status = 0;
+                        }
+                        else
+                        {
+                            TransferPacket.TransferData.Status = 1;
+                        }
+
+                        req.RequestUser.OutPacket(TransferPacket, ThrottleOutPacketType.Asset);
+
+                        processedLength += chunkSize;
+                        packetNumber++;
+                    }
+                }
+            }
+
+            //remove requests that have been completed
+            for (int i = 0; i < num; i++)
+            {
+                AssetRequests.RemoveAt(0);
+            }
+        }
+        /// <summary>
+        /// Calculate the number of packets required to send the asset to the client.
+        /// </summary>
+        /// <param name="data"></param>
+        /// <returns></returns>
+        private int CalculateNumPackets(byte[] data)
+        {
+            const uint m_maxPacketSize = 600;
+            int numPackets = 1;
+
+            if (data.LongLength > m_maxPacketSize)
+            {
+                // over max number of bytes so split up file
+                long restData = data.LongLength - m_maxPacketSize;
+                int restPackets = (int)((restData + m_maxPacketSize - 1) / m_maxPacketSize);
+                numPackets += restPackets;
+            }
+
+            return numPackets;
+        }
+
+        public class AssetRequest
+        {
+            public IClientAPI RequestUser;
+            public LLUUID RequestAssetID;
+            public AssetBase AssetInf;
+            public AssetBase ImageInfo;
+            public LLUUID TransferRequestID;
+            public long DataPointer = 0;
+            public int NumPackets = 0;
+            public int PacketCounter = 0;
+            public bool IsTextureRequest;
+            public byte AssetRequestSource = 2;
+            public byte[] Params = null;
+            //public bool AssetInCache;
+            //public int TimeRequested; 
+            public int DiscardLevel = -1;
+
+            public AssetRequest()
+            {
+            }
         }
     }
 }
\ No newline at end of file