/* * Copyright (c) Contributors, http://opensimulator.org/ * See CONTRIBUTORS.TXT for a full list of copyright holders. * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions are met: * * Redistributions of source code must retain the above copyright * notice, this list of conditions and the following disclaimer. * * Redistributions in binary form must reproduce the above copyright * notice, this list of conditions and the following disclaimer in the * documentation and/or other materials provided with the distribution. * * Neither the name of the OpenSim Project nor the * names of its contributors may be used to endorse or promote products * derived from this software without specific prior written permission. * * THIS SOFTWARE IS PROVIDED BY THE DEVELOPERS ``AS IS'' AND ANY * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE * DISCLAIMED. IN NO EVENT SHALL THE CONTRIBUTORS BE LIABLE FOR ANY * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. */ using System; using System.Collections.Generic; using System.Reflection; using System.Threading; using libsecondlife; using libsecondlife.Packets; using log4net; using OpenSim.Framework.Statistics; namespace OpenSim.Framework.Communications.Cache { public delegate void AssetRequestCallback(LLUUID assetID, AssetBase asset); /// /// Manages local cache of assets and their sending to viewers. /// /// This class actually encapsulates two largely separate mechanisms. One mechanism fetches assets either /// synchronously or async and passes the data back to the requester. The second mechanism fetches assets and /// sends packetised data directly back to the client. The only point where they meet is AssetReceived() and /// AssetNotFound(), which means they do share the same asset and texture caches. /// /// TODO Assets in this cache are effectively immortal (they are never disposed off through old age). /// This is not a huge problem at the moment since other memory use usually dwarfs that used by assets /// but it's something to bear in mind. /// public class AssetCache : IAssetReceiver { private static readonly ILog m_log = LogManager.GetLogger(MethodBase.GetCurrentMethod().DeclaringType); /// /// The cache of assets. This does not include textures. /// private Dictionary Assets; /// /// The cache of textures. /// private Dictionary Textures; /// /// Assets requests which are waiting for asset server data. This includes texture requests /// private Dictionary RequestedAssets; /// /// Asset requests with data which are ready to be sent back to requesters. This includes textures. /// private List AssetRequests; /// /// Until the asset request is fulfilled, each asset request is associated with a list of requesters /// private Dictionary RequestLists; private readonly IAssetServer m_assetServer; private readonly Thread m_assetCacheThread; /// /// Report statistical data. /// public void ShowState() { m_log.InfoFormat("Assets:{0} Textures:{1} RequestLists:{2}", Assets.Count, Textures.Count, // AssetRequests.Count, // RequestedAssets.Count, RequestLists.Count); int temporaryImages = 0; int temporaryAssets = 0; long imageBytes = 0; long assetBytes = 0; foreach (TextureImage texture in Textures.Values) { if (texture != null) { if (texture.Temporary) { temporaryImages++; } imageBytes += texture.Data.GetLongLength(0); } } foreach (AssetInfo asset in Assets.Values) { if (asset != null) { if (asset.Temporary) { temporaryAssets++; } assetBytes += asset.Data.GetLongLength(0); } } m_log.InfoFormat("Temporary Images: {0} Temporary Assets: {1}", temporaryImages, temporaryAssets); m_log.InfoFormat("Image data: {0}kb Asset data: {1}kb", imageBytes / 1024, assetBytes / 1024); } /// /// Clear the asset cache. /// public void Clear() { m_log.Info("[ASSET CACHE]: Clearing Asset cache"); if (StatsManager.SimExtraStats != null) StatsManager.SimExtraStats.ClearAssetCacheStatistics(); Initialize(); } /// /// Initialize the cache. /// private void Initialize() { Assets = new Dictionary(); Textures = new Dictionary(); AssetRequests = new List(); RequestedAssets = new Dictionary(); RequestLists = new Dictionary(); } /// /// Constructor. Initialize will need to be called separately. /// /// public AssetCache(IAssetServer assetServer) { m_log.Info("[ASSET CACHE]: Creating Asset cache"); Initialize(); m_assetServer = assetServer; m_assetServer.SetReceiver(this); m_assetCacheThread = new Thread(new ThreadStart(RunAssetManager)); m_assetCacheThread.Name = "AssetCacheThread"; m_assetCacheThread.IsBackground = true; m_assetCacheThread.Start(); ThreadTracker.Add(m_assetCacheThread); } /// /// Process the asset queue which holds data which is packeted up and sent /// directly back to the client. /// public void RunAssetManager() { while (true) { try { ProcessAssetQueue(); Thread.Sleep(500); } catch (Exception e) { m_log.Error("[ASSET CACHE]: " + e.ToString()); } } } /// /// Only get an asset if we already have it in the cache. /// /// /// //private AssetBase GetCachedAsset(LLUUID assetId) //{ // AssetBase asset = null; // if (Textures.ContainsKey(assetId)) // { // asset = Textures[assetId]; // } // else if (Assets.ContainsKey(assetId)) // { // asset = Assets[assetId]; // } // return asset; //} private bool TryGetCachedAsset(LLUUID assetId, out AssetBase asset) { if (Textures.ContainsKey(assetId)) { asset = Textures[assetId]; return true; } else if (Assets.ContainsKey(assetId)) { asset = Assets[assetId]; return true; } asset = null; return false; } /// /// Asynchronously retrieve an asset. /// /// /// /// A callback invoked when the asset has either been found or not found. /// If the asset was found this is called with the asset UUID and the asset data /// If the asset was not found this is still called with the asset UUID but with a null asset data reference public void GetAsset(LLUUID assetId, AssetRequestCallback callback, bool isTexture) { //m_log.DebugFormat("[ASSET CACHE]: Requesting {0} {1}", isTexture ? "texture" : "asset", assetId); // Xantor 20080526: // if a request is made for an asset which is not in the cache yet, but has already been requested by // something else, queue up the callbacks on that requestor instead of swamping the assetserver // with multiple requests for the same asset. AssetBase asset; if (TryGetCachedAsset(assetId, out asset)) { callback(assetId, asset); } else { #if DEBUG // m_log.DebugFormat("[ASSET CACHE]: Adding request for {0} {1}", isTexture ? "texture" : "asset", assetId); #endif NewAssetRequest req = new NewAssetRequest(assetId, callback); AssetRequestsList requestList; lock (RequestLists) { if (RequestLists.TryGetValue(assetId, out requestList)) // do we already have a request pending? { // m_log.DebugFormat("[ASSET CACHE]: Intercepted Duplicate request for {0} {1}", isTexture ? "texture" : "asset", assetId); // add to callbacks for this assetId RequestLists[assetId].Requests.Add(req); } else { // m_log.DebugFormat("[ASSET CACHE]: Adding request for {0} {1}", isTexture ? "texture" : "asset", assetId); requestList = new AssetRequestsList(assetId); RequestLists.Add(assetId, requestList); requestList.Requests.Add(req); m_assetServer.RequestAsset(assetId, isTexture); } } } } /// /// Synchronously retreive an asset. If the asset isn't in the cache, a request will be made to the persistent store to /// load it into the cache. /// /// XXX We'll keep polling the cache until we get the asset or we exceed /// the allowed number of polls. This isn't a very good way of doing things since a single thread /// is processing inbound packets, so if the asset server is slow, we could block this for up to /// the timeout period. What we might want to do is register asynchronous callbacks on asset /// receipt in the same manner as the TextureDownloadModule. Of course, /// a timeout before asset receipt usually isn't fatal, the operation will work on the retry when the /// asset is much more likely to have made it into the cache. /// /// /// /// null if the asset could not be retrieved public AssetBase GetAsset(LLUUID assetID, bool isTexture) { // I'm not going over 3 seconds since this will be blocking processing of all the other inbound // packets from the client. int pollPeriod = 200; int maxPolls = 15; AssetBase asset; if (TryGetCachedAsset(assetID, out asset)) { return asset; } else { m_assetServer.RequestAsset(assetID, isTexture); do { Thread.Sleep(pollPeriod); if (TryGetCachedAsset(assetID, out asset)) { return asset; } } while (--maxPolls > 0); m_log.WarnFormat("[ASSET CACHE]: {0} {1} was not received before the retrieval timeout was reached", isTexture ? "texture" : "asset", assetID.ToString()); return null; } } /// /// Add an asset to both the persistent store and the cache. /// /// public void AddAsset(AssetBase asset) { if (asset.Type == 0) { if (!Textures.ContainsKey(asset.FullID)) { TextureImage textur = new TextureImage(asset); Textures.Add(textur.FullID, textur); if (StatsManager.SimExtraStats != null) StatsManager.SimExtraStats.AddTexture(textur); if (!asset.Temporary) { m_assetServer.StoreAndCommitAsset(asset); } } } else { if (!Assets.ContainsKey(asset.FullID)) { AssetInfo assetInf = new AssetInfo(asset); Assets.Add(assetInf.FullID, assetInf); if (StatsManager.SimExtraStats != null) StatsManager.SimExtraStats.AddAsset(assetInf); if (!asset.Temporary) { m_assetServer.StoreAndCommitAsset(asset); } } } } /// /// Allows you to clear a specific asset by uuid out /// of the asset cache. This is needed because the osdynamic /// texture code grows the asset cache without bounds. The /// real solution here is a much better cache archicture, but /// this is a stop gap measure until we have such a thing. /// public void ExpireAsset(LLUUID uuid) { // uuid is unique, so no need to worry about it showing up // in the 2 caches differently. Also, locks are probably // needed in all of this, or move to synchronized non // generic forms for Dictionaries. if (Textures.ContainsKey(uuid)) { Textures.Remove(uuid); } else if (Assets.ContainsKey(uuid)) { Assets.Remove(uuid); } } // See IAssetReceiver public void AssetReceived(AssetBase asset, bool IsTexture) { //check if it is a texture or not //then add to the correct cache list //then check for waiting requests for this asset/texture (in the Requested lists) //and move those requests into the Requests list. if (IsTexture) { TextureImage image = new TextureImage(asset); if (!Textures.ContainsKey(image.FullID)) { Textures.Add(image.FullID, image); if (StatsManager.SimExtraStats != null) { StatsManager.SimExtraStats.AddTexture(image); } } } else { AssetInfo assetInf = new AssetInfo(asset); if (!Assets.ContainsKey(assetInf.FullID)) { Assets.Add(assetInf.FullID, assetInf); if (StatsManager.SimExtraStats != null) { StatsManager.SimExtraStats.AddAsset(assetInf); } if (RequestedAssets.ContainsKey(assetInf.FullID)) { AssetRequest req = RequestedAssets[assetInf.FullID]; req.AssetInf = assetInf; req.NumPackets = CalculateNumPackets(assetInf.Data); RequestedAssets.Remove(assetInf.FullID); AssetRequests.Add(req); } } } // Notify requesters for this asset if (RequestLists.ContainsKey(asset.FullID)) { AssetRequestsList reqList = null; lock (RequestLists) { //m_log.Info("AssetCache: Lock taken on requestLists (AssetReceived #1)"); reqList = RequestLists[asset.FullID]; } //m_log.Info("AssetCache: Lock released on requestLists (AssetReceived #1)"); if (reqList != null) { //making a copy of the list is not ideal //but the old method of locking around this whole block of code was causing a multi-thread lock //between this and the TextureDownloadModule //while the localAsset thread running this and trying to send a texture to the callback in the //texturedownloadmodule , and hitting a lock in there. While the texturedownload thread (which was holding // the lock in the texturedownload module) was trying to //request a new asset and hitting a lock in here on the RequestLists. List theseRequests = new List(reqList.Requests); reqList.Requests.Clear(); lock (RequestLists) { // m_log.Info("AssetCache: Lock taken on requestLists (AssetReceived #2)"); RequestLists.Remove(asset.FullID); } //m_log.Info("AssetCache: Lock released on requestLists (AssetReceived #2)"); foreach (NewAssetRequest req in theseRequests) { // Xantor 20080526 are we really calling all the callbacks if multiple queued for 1 request? -- Yes, checked // m_log.DebugFormat("[ASSET CACHE]: Callback for asset {0}", asset.FullID); req.Callback(asset.FullID, asset); } } } } // See IAssetReceiver public void AssetNotFound(LLUUID assetID, bool IsTexture) { //m_log.WarnFormat("[ASSET CACHE]: AssetNotFound for {0}", assetID); if (IsTexture) { Textures[assetID] = null; } else { Assets[assetID] = null; } // Notify requesters for this asset AssetRequestsList reqList = null; lock (RequestLists) { // m_log.Info("AssetCache: Lock taken on requestLists (AssetNotFound #1)"); if (RequestLists.ContainsKey(assetID)) { reqList = RequestLists[assetID]; } } // m_log.Info("AssetCache: Lock released on requestLists (AssetNotFound #1)"); if (reqList != null) { List theseRequests = new List(reqList.Requests); reqList.Requests.Clear(); lock (RequestLists) { // m_log.Info("AssetCache: Lock taken on requestLists (AssetNotFound #2)"); RequestLists.Remove(assetID); } // m_log.Info("AssetCache: Lock released on requestLists (AssetNotFound #2)"); foreach (NewAssetRequest req in theseRequests) { req.Callback(assetID, null); } } } /// /// Calculate the number of packets required to send the asset to the client. /// /// /// private static 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; } /// /// Handle an asset request from the client. The result will be sent back asynchronously. /// /// /// 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); } //check to see if asset is in local cache, if not we need to request it from asset server. //Console.WriteLine("asset request " + requestID); if (!Assets.ContainsKey(requestID)) { //not found asset // so request from asset server if (!RequestedAssets.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; RequestedAssets.Add(requestID, request); m_assetServer.RequestAsset(requestID, false); } return; } // It has an entry in our cache AssetInfo asset = Assets[requestID]; // FIXME: We never tell the client about assets which do not exist when requested by this transfer mechanism, which can't be right. if (null == asset) { //m_log.DebugFormat("[ASSET CACHE]: Asset transfer request for asset which is {0} already known to be missing. Dropping", requestID); return; } // The asset is knosn to exist and is in our cache, so add it to the AssetRequests list AssetRequest req = new AssetRequest(); req.RequestUser = userInfo; req.RequestAssetID = requestID; req.TransferRequestID = transferRequest.TransferInfo.TransferID; req.AssetRequestSource = source; req.Params = transferRequest.TransferInfo.Params; req.AssetInf = asset; req.NumPackets = CalculateNumPackets(asset.Data); AssetRequests.Add(req); } /// /// Process the asset queue which sends packets directly back to the client. /// 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; AssetRequestToClient req2 = null; for (int i = 0; i < num; i++) { req = (AssetRequest)AssetRequests[i]; if (req2 == null) { req2 = new AssetRequestToClient(); } // Trying to limit memory usage by only creating AssetRequestToClient if needed //req2 = new AssetRequestToClient(); req2.AssetInf = (AssetBase)req.AssetInf; req2.AssetRequestSource = req.AssetRequestSource; req2.DataPointer = req.DataPointer; req2.DiscardLevel = req.DiscardLevel; req2.ImageInfo = (AssetBase)req.ImageInfo; req2.IsTextureRequest = req.IsTextureRequest; req2.NumPackets = req.NumPackets; req2.PacketCounter = req.PacketCounter; req2.Params = req.Params; req2.RequestAssetID = req.RequestAssetID; req2.TransferRequestID = req.TransferRequestID; req.RequestUser.SendAsset(req2); } //remove requests that have been completed for (int i = 0; i < num; i++) { AssetRequests.RemoveAt(0); } } public class AssetRequest { public IClientAPI RequestUser; public LLUUID RequestAssetID; public AssetInfo AssetInf; public TextureImage 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() { } } public class AssetInfo : AssetBase { public AssetInfo() { } public AssetInfo(AssetBase aBase) { Data = aBase.Data; FullID = aBase.FullID; Type = aBase.Type; InvType = aBase.InvType; Name = aBase.Name; Description = aBase.Description; } } public class TextureImage : AssetBase { public TextureImage() { } public TextureImage(AssetBase aBase) { Data = aBase.Data; FullID = aBase.FullID; Type = aBase.Type; InvType = aBase.InvType; Name = aBase.Name; Description = aBase.Description; } } public class AssetRequestsList { public LLUUID AssetID; public List Requests = new List(); public AssetRequestsList(LLUUID assetID) { AssetID = assetID; } } public class NewAssetRequest { public LLUUID AssetID; public AssetRequestCallback Callback; public NewAssetRequest(LLUUID assetID, AssetRequestCallback callback) { AssetID = assetID; Callback = callback; } } } }