From 8c0955321a5f0d4de21ceb9b98b4e329e1b56200 Mon Sep 17 00:00:00 2001 From: Justin Clarke Casey Date: Mon, 24 Mar 2008 18:21:06 +0000 Subject: * Refactor: Genericise request limit strategies and move to OpenSim.Framework.Communications.Limit --- .../Communications/Limit/IRequestLimitStrategy.cs | 68 +++++++++++++ .../Communications/Limit/RepeatLimitStrategy.cs | 113 +++++++++++++++++++++ .../Modules/UserTextureDownloadService.cs | 90 ++++++---------- 3 files changed, 211 insertions(+), 60 deletions(-) create mode 100644 OpenSim/Framework/Communications/Limit/IRequestLimitStrategy.cs create mode 100644 OpenSim/Framework/Communications/Limit/RepeatLimitStrategy.cs diff --git a/OpenSim/Framework/Communications/Limit/IRequestLimitStrategy.cs b/OpenSim/Framework/Communications/Limit/IRequestLimitStrategy.cs new file mode 100644 index 0000000..ded9ffc --- /dev/null +++ b/OpenSim/Framework/Communications/Limit/IRequestLimitStrategy.cs @@ -0,0 +1,68 @@ +/* + * 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; + +namespace OpenSim.Framework.Communications.Limit +{ + /// + /// Interface for strategies that can limit requests from the client. Currently only used in the + /// texture modules to deal with repeated requests for certain textures. However, limiting strategies + /// could be used with other requests. + /// + public interface IRequestLimitStrategy + { + /// + /// Should the request be allowed? If the id is not monitored, then the request is always allowed. + /// Otherwise, the strategy criteria will be applied. + /// + /// + /// + bool AllowRequest(TId id); + + /// + /// Has the request been refused just once? + /// + /// False if the request has not yet been refused, or if the request has been refused more + /// than once. + bool IsFirstRefusal(TId id); + + /// + /// Start monitoring for future AllowRequest calls. If the id is already monitored, then monitoring + /// continues. + /// + /// + void MonitorRequests(TId id); + + /// + /// Is the id being monitored? + /// + /// + /// + bool IsMonitoringRequests(TId id); + } +} diff --git a/OpenSim/Framework/Communications/Limit/RepeatLimitStrategy.cs b/OpenSim/Framework/Communications/Limit/RepeatLimitStrategy.cs new file mode 100644 index 0000000..6dd0fa1 --- /dev/null +++ b/OpenSim/Framework/Communications/Limit/RepeatLimitStrategy.cs @@ -0,0 +1,113 @@ +/* + * 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; + +namespace OpenSim.Framework.Communications.Limit +{ + /// + /// Limit requests by discarding them after they've been repeated a certain number of times. + /// + public class RepeatLimitStrategy : IRequestLimitStrategy + { + private static readonly log4net.ILog m_log + = log4net.LogManager.GetLogger(System.Reflection.MethodBase.GetCurrentMethod().DeclaringType); + + /// + /// Record each asset request that we're notified about. + /// + private readonly Dictionary requestCounts = new Dictionary(); + + /// + /// The maximum number of requests that can be made before we drop subsequent requests. + /// + private readonly int m_maxRequests; + public int MaxRequests + { + get { return m_maxRequests; } + } + + /// + /// The maximum number of requests that may be served before all further + /// requests are dropped. + public RepeatLimitStrategy(int maxRequests) + { + m_maxRequests = maxRequests; + } + + /// + /// + /// + public bool AllowRequest(TId id) + { + if (requestCounts.ContainsKey(id)) + { + requestCounts[id] += 1; + + if (requestCounts[id] > m_maxRequests) + { + return false; + } + } + + return true; + } + + /// + /// + /// + public bool IsFirstRefusal(TId id) + { + if (m_maxRequests + 1 == requestCounts[id]) + { + return true; + } + + return false; + } + + /// + /// + /// + public void MonitorRequests(TId id) + { + if (!IsMonitoringRequests(id)) + { + requestCounts.Add(id, 1); + } + } + + /// + /// + /// + public bool IsMonitoringRequests(TId id) + { + return requestCounts.ContainsKey(id); + } + } +} diff --git a/OpenSim/Region/Environment/Modules/UserTextureDownloadService.cs b/OpenSim/Region/Environment/Modules/UserTextureDownloadService.cs index 4fdec65..a688cc8 100644 --- a/OpenSim/Region/Environment/Modules/UserTextureDownloadService.cs +++ b/OpenSim/Region/Environment/Modules/UserTextureDownloadService.cs @@ -32,6 +32,7 @@ using libsecondlife; using libsecondlife.Packets; using OpenSim.Framework; +using OpenSim.Framework.Communications.Limit; using OpenSim.Framework.Console; using OpenSim.Region.Environment.Interfaces; using OpenSim.Region.Environment.Scenes; @@ -54,27 +55,29 @@ namespace OpenSim.Region.Environment.Modules private static readonly int MAX_ALLOWED_TEXTURE_REQUESTS = 5; /// - /// Holds texture senders before they have received the appropriate texture from the asset cache. - /// - private readonly Dictionary m_textureSenders = new Dictionary(); + /// We're going to limit repeated requests for the same missing texture. + /// XXX This is really a temporary solution to deal with the situation where a client continually requests + /// the same missing textures + /// + private readonly IRequestLimitStrategy missingTextureLimitStrategy + = new RepeatLimitStrategy(MAX_ALLOWED_TEXTURE_REQUESTS); /// - /// Texture Senders are placed in this queue once they have received their texture from the asset - /// cache. Another module actually invokes the send. + /// XXX Also going to limit repeated requests for found textures. /// - private readonly BlockingQueue m_sharedSendersQueue; + private readonly IRequestLimitStrategy foundTextureLimitStrategy + = new RepeatLimitStrategy(MAX_ALLOWED_TEXTURE_REQUESTS); /// - /// We're going to record when we get a request for a particular missing texture for each client - /// XXX This is really a temporary solution to deal with the situation where a client continually requests - /// the same missing textures + /// Holds texture senders before they have received the appropriate texture from the asset cache. /// - private readonly Dictionary missingTextureRequestCounts = new Dictionary(); + private readonly Dictionary m_textureSenders = new Dictionary(); /// - /// XXX Also going to record all the textures found and dispatched + /// Texture Senders are placed in this queue once they have received their texture from the asset + /// cache. Another module actually invokes the send. /// - private readonly Dictionary dispatchedTextureRequestCounts = new Dictionary(); + private readonly BlockingQueue m_sharedSendersQueue; private readonly Scene m_scene; @@ -109,50 +112,21 @@ namespace OpenSim.Region.Environment.Modules textureSender.UpdateRequest(e.DiscardLevel, e.PacketNumber); } else - { - // If we've already told the client we're missing the texture, then don't ask the - // asset server for it again - record the fact that it's missing instead. - // XXX This is to reduce (but not resolve) a current problem where some clients keep - // requesting the same textures - if (missingTextureRequestCounts.ContainsKey(e.RequestedAssetID)) + { + if (!foundTextureLimitStrategy.AllowRequest(e.RequestedAssetID)) { - missingTextureRequestCounts[e.RequestedAssetID] += 1; - - if (missingTextureRequestCounts[e.RequestedAssetID] > MAX_ALLOWED_TEXTURE_REQUESTS) - { - if (MAX_ALLOWED_TEXTURE_REQUESTS + 1 == missingTextureRequestCounts[e.RequestedAssetID]) - { - m_log.DebugFormat( - "[USER TEXTURE DOWNLOAD SERVICE]: Dropping requests for notified missing texture {0} for {1} since we have received more than {2} requests", - e.RequestedAssetID, m_client.AgentId, MAX_ALLOWED_TEXTURE_REQUESTS); - } - - return; - } + return; } - else - { - // If we keep receiving requests for textures we've already served to the client, - // then stop sending them. This is a short term approach approach to the problem - // of clients which keep requesting the same texture - the long term approach - // will be to treat the cause (and possibly more generally cap the request - // queues as well/instead) - if (dispatchedTextureRequestCounts.ContainsKey(e.RequestedAssetID)) + else if (!missingTextureLimitStrategy.AllowRequest(e.RequestedAssetID)) + { + if (missingTextureLimitStrategy.IsFirstRefusal(e.RequestedAssetID)) { - dispatchedTextureRequestCounts[e.RequestedAssetID] += 1; - - if (dispatchedTextureRequestCounts[e.RequestedAssetID] > MAX_ALLOWED_TEXTURE_REQUESTS) - { -// if (MAX_ALLOWED_TEXTURE_REQUESTS + 1 == dispatchedTextureRequestCounts[e.RequestedAssetID]) -// { -// m_log.DebugFormat( -// "[USER TEXTURE DOWNLOAD SERVICE]: Dropping further requests for dispatched/queued texture {0} for {1} since we have received more than {2} requests", -// e.RequestedAssetID, m_client.AgentId, MAX_ALLOWED_TEXTURE_REQUESTS); -// } - - return; - } - } + m_log.DebugFormat( + "[USER TEXTURE DOWNLOAD SERVICE]: Dropping requests for notified missing texture {0} for client {1} since we have received more than {1} requests", + e.RequestedAssetID, m_client.AgentId, MAX_ALLOWED_TEXTURE_REQUESTS); + } + + return; } m_scene.AddPendingDownloads(1); @@ -197,9 +171,9 @@ namespace OpenSim.Region.Environment.Modules // Needs investigation. if (texture == null || texture.Data == null) { - if (!missingTextureRequestCounts.ContainsKey(textureID)) + if (!missingTextureLimitStrategy.IsMonitoringRequests(textureID)) { - missingTextureRequestCounts.Add(textureID, 1); + missingTextureLimitStrategy.MonitorRequests(textureID); m_log.DebugFormat( "[USER TEXTURE DOWNLOAD SERVICE]: Queueing first TextureNotFoundSender for {0}, client {1}", @@ -216,11 +190,7 @@ namespace OpenSim.Region.Environment.Modules textureSender.TextureReceived(texture); EnqueueTextureSender(textureSender); - // Record the fact that we've put this texture in for dispatch - if (!dispatchedTextureRequestCounts.ContainsKey(textureID)) - { - dispatchedTextureRequestCounts.Add(textureID, 1); - } + foundTextureLimitStrategy.MonitorRequests(textureID); } } -- cgit v1.1