416 lines
14 KiB
C#
416 lines
14 KiB
C#
/*
|
|
* 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 OpenSimulator 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.Reflection;
|
|
using log4net;
|
|
using Mono.Addins;
|
|
using Nini.Config;
|
|
using OpenSim.Framework;
|
|
using OpenSim.Region.Framework.Interfaces;
|
|
using OpenSim.Region.Framework.Scenes;
|
|
|
|
namespace OpenSim.Region.CoreModules.Asset
|
|
{
|
|
/// <summary>
|
|
/// Cenome memory asset cache.
|
|
/// </summary>
|
|
/// <remarks>
|
|
/// <para>
|
|
/// Cache is enabled by setting "AssetCaching" configuration to value "CenomeMemoryAssetCache".
|
|
/// When cache is successfully enable log should have message
|
|
/// "[ASSET CACHE]: Cenome asset cache enabled (MaxSize = XXX bytes, MaxCount = XXX, ExpirationTime = XXX)".
|
|
/// </para>
|
|
/// <para>
|
|
/// Cache's size is limited by two parameters:
|
|
/// maximal allowed size in bytes and maximal allowed asset count. When new asset
|
|
/// is added to cache that have achieved either size or count limitation, cache
|
|
/// will automatically remove less recently used assets from cache. Additionally
|
|
/// asset's lifetime is controlled by expiration time.
|
|
/// </para>
|
|
/// <para>
|
|
/// <list type="table">
|
|
/// <listheader>
|
|
/// <term>Configuration</term>
|
|
/// <description>Description</description>
|
|
/// </listheader>
|
|
/// <item>
|
|
/// <term>MaxSize</term>
|
|
/// <description>Maximal size of the cache in bytes. Default value: 128MB (134 217 728 bytes).</description>
|
|
/// </item>
|
|
/// <item>
|
|
/// <term>MaxCount</term>
|
|
/// <description>Maximal count of assets stored to cache. Default value: 4096 assets.</description>
|
|
/// </item>
|
|
/// <item>
|
|
/// <term>ExpirationTime</term>
|
|
/// <description>Asset's expiration time in minutes. Default value: 30 minutes.</description>
|
|
/// </item>
|
|
/// </list>
|
|
/// </para>
|
|
/// </remarks>
|
|
/// <example>
|
|
/// Enabling Cenome Asset Cache:
|
|
/// <code>
|
|
/// [Modules]
|
|
/// AssetCaching = "CenomeMemoryAssetCache"
|
|
/// </code>
|
|
/// Setting size and expiration time limitations:
|
|
/// <code>
|
|
/// [AssetCache]
|
|
/// ; 256 MB (default: 134217728)
|
|
/// MaxSize = 268435456
|
|
/// ; How many assets it is possible to store cache (default: 4096)
|
|
/// MaxCount = 16384
|
|
/// ; Expiration time - 1 hour (default: 30 minutes)
|
|
/// ExpirationTime = 60
|
|
/// </code>
|
|
/// </example>
|
|
[Extension(Path = "/OpenSim/RegionModules", NodeName = "RegionModule", Id = "CenomeMemoryAssetCache")]
|
|
public class CenomeMemoryAssetCache : IImprovedAssetCache, ISharedRegionModule
|
|
{
|
|
private static readonly ILog m_log = LogManager.GetLogger(MethodBase.GetCurrentMethod().DeclaringType);
|
|
|
|
/// <summary>
|
|
/// Cache's default maximal asset count.
|
|
/// </summary>
|
|
/// <remarks>
|
|
/// <para>
|
|
/// Assuming that average asset size is about 32768 bytes.
|
|
/// </para>
|
|
/// </remarks>
|
|
public const int DefaultMaxCount = 4096;
|
|
|
|
/// <summary>
|
|
/// Default maximal size of the cache in bytes
|
|
/// </summary>
|
|
/// <remarks>
|
|
/// <para>
|
|
/// 128MB = 128 * 1024^2 = 134 217 728 bytes.
|
|
/// </para>
|
|
/// </remarks>
|
|
public const long DefaultMaxSize = 134217728;
|
|
|
|
/// <summary>
|
|
/// Asset's default expiration time in the cache.
|
|
/// </summary>
|
|
public static readonly TimeSpan DefaultExpirationTime = TimeSpan.FromMinutes(30.0);
|
|
|
|
/// <summary>
|
|
/// Cache object.
|
|
/// </summary>
|
|
private ICnmCache<string, AssetBase> m_cache;
|
|
|
|
/// <summary>
|
|
/// Count of cache commands
|
|
/// </summary>
|
|
private int m_cachedCount;
|
|
|
|
/// <summary>
|
|
/// How many gets before dumping statistics
|
|
/// </summary>
|
|
/// <remarks>
|
|
/// If 0 or less, then disabled.
|
|
/// </remarks>
|
|
private int m_debugEpoch;
|
|
|
|
/// <summary>
|
|
/// Is Cenome asset cache enabled.
|
|
/// </summary>
|
|
private bool m_enabled;
|
|
|
|
/// <summary>
|
|
/// Count of get requests
|
|
/// </summary>
|
|
private int m_getCount;
|
|
|
|
/// <summary>
|
|
/// How many hits
|
|
/// </summary>
|
|
private int m_hitCount;
|
|
|
|
/// <summary>
|
|
/// Initialize asset cache module, with custom parameters.
|
|
/// </summary>
|
|
/// <param name="maximalSize">
|
|
/// Cache's maximal size in bytes.
|
|
/// </param>
|
|
/// <param name="maximalCount">
|
|
/// Cache's maximal count of assets.
|
|
/// </param>
|
|
/// <param name="expirationTime">
|
|
/// Asset's expiration time.
|
|
/// </param>
|
|
protected void Initialize(long maximalSize, int maximalCount, TimeSpan expirationTime)
|
|
{
|
|
if (maximalSize <= 0 || maximalCount <= 0)
|
|
{
|
|
//m_log.Debug("[ASSET CACHE]: Cenome asset cache is not enabled.");
|
|
m_enabled = false;
|
|
return;
|
|
}
|
|
|
|
if (expirationTime <= TimeSpan.Zero)
|
|
{
|
|
// Disable expiration time
|
|
expirationTime = TimeSpan.MaxValue;
|
|
}
|
|
|
|
// Create cache and add synchronization wrapper over it
|
|
m_cache =
|
|
CnmSynchronizedCache<string, AssetBase>.Synchronized(new CnmMemoryCache<string, AssetBase>(
|
|
maximalSize, maximalCount, expirationTime));
|
|
m_enabled = true;
|
|
m_log.DebugFormat(
|
|
"[ASSET CACHE]: Cenome asset cache enabled (MaxSize = {0} bytes, MaxCount = {1}, ExpirationTime = {2})",
|
|
maximalSize,
|
|
maximalCount,
|
|
expirationTime);
|
|
}
|
|
|
|
#region IImprovedAssetCache Members
|
|
|
|
public bool Check(string id)
|
|
{
|
|
AssetBase asset;
|
|
|
|
// XXX:This is probably not an efficient implementation.
|
|
return m_cache.TryGetValue(id, out asset);
|
|
}
|
|
|
|
/// <summary>
|
|
/// Cache asset.
|
|
/// </summary>
|
|
/// <param name="asset">
|
|
/// The asset that is being cached.
|
|
/// </param>
|
|
public void Cache(AssetBase asset)
|
|
{
|
|
if (asset != null)
|
|
{
|
|
// m_log.DebugFormat("[CENOME ASSET CACHE]: Caching asset {0}", asset.ID);
|
|
|
|
long size = asset.Data != null ? asset.Data.Length : 1;
|
|
m_cache.Set(asset.ID, asset, size);
|
|
m_cachedCount++;
|
|
}
|
|
|
|
}
|
|
|
|
/// <summary>
|
|
/// Clear asset cache.
|
|
/// </summary>
|
|
public void Clear()
|
|
{
|
|
m_cache.Clear();
|
|
}
|
|
|
|
/// <summary>
|
|
/// Expire (remove) asset stored to cache.
|
|
/// </summary>
|
|
/// <param name="id">
|
|
/// The expired asset's id.
|
|
/// </param>
|
|
public void Expire(string id)
|
|
{
|
|
m_cache.Remove(id);
|
|
}
|
|
|
|
/// <summary>
|
|
/// Get asset stored
|
|
/// </summary>
|
|
/// <param name="id">
|
|
/// The asset's id.
|
|
/// </param>
|
|
/// <returns>
|
|
/// Asset if it is found from cache; otherwise <see langword="null"/>.
|
|
/// </returns>
|
|
/// <remarks>
|
|
/// <para>
|
|
/// Caller should always check that is return value <see langword="null"/>.
|
|
/// Cache doesn't guarantee in any situation that asset is stored to it.
|
|
/// </para>
|
|
/// </remarks>
|
|
public AssetBase Get(string id)
|
|
{
|
|
m_getCount++;
|
|
AssetBase assetBase;
|
|
if (m_cache.TryGetValue(id, out assetBase))
|
|
m_hitCount++;
|
|
|
|
if (m_getCount == m_debugEpoch)
|
|
{
|
|
m_log.DebugFormat(
|
|
"[ASSET CACHE]: Cached = {0}, Get = {1}, Hits = {2}%, Size = {3} bytes, Avg. A. Size = {4} bytes",
|
|
m_cachedCount,
|
|
m_getCount,
|
|
((double) m_hitCount / m_getCount) * 100.0,
|
|
m_cache.Size,
|
|
m_cache.Size / m_cache.Count);
|
|
m_getCount = 0;
|
|
m_hitCount = 0;
|
|
m_cachedCount = 0;
|
|
}
|
|
|
|
// if (null == assetBase)
|
|
// m_log.DebugFormat("[CENOME ASSET CACHE]: Asset {0} not in cache", id);
|
|
|
|
return assetBase;
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region ISharedRegionModule Members
|
|
|
|
/// <summary>
|
|
/// Gets region module's name.
|
|
/// </summary>
|
|
public string Name
|
|
{
|
|
get { return "CenomeMemoryAssetCache"; }
|
|
}
|
|
|
|
public Type ReplaceableInterface
|
|
{
|
|
get { return null; }
|
|
}
|
|
|
|
/// <summary>
|
|
/// New region is being added to server.
|
|
/// </summary>
|
|
/// <param name="scene">
|
|
/// Region's scene.
|
|
/// </param>
|
|
public void AddRegion(Scene scene)
|
|
{
|
|
if (m_enabled)
|
|
scene.RegisterModuleInterface<IImprovedAssetCache>(this);
|
|
}
|
|
|
|
/// <summary>
|
|
/// Close region module.
|
|
/// </summary>
|
|
public void Close()
|
|
{
|
|
if (m_enabled)
|
|
{
|
|
m_enabled = false;
|
|
m_cache.Clear();
|
|
m_cache = null;
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Initialize region module.
|
|
/// </summary>
|
|
/// <param name="source">
|
|
/// Configuration source.
|
|
/// </param>
|
|
public void Initialise(IConfigSource source)
|
|
{
|
|
m_cache = null;
|
|
m_enabled = false;
|
|
|
|
IConfig moduleConfig = source.Configs[ "Modules" ];
|
|
if (moduleConfig == null)
|
|
return;
|
|
|
|
string name = moduleConfig.GetString("AssetCaching");
|
|
//m_log.DebugFormat("[XXX] name = {0} (this module's name: {1}", name, Name);
|
|
|
|
if (name != Name)
|
|
return;
|
|
|
|
long maxSize = DefaultMaxSize;
|
|
int maxCount = DefaultMaxCount;
|
|
TimeSpan expirationTime = DefaultExpirationTime;
|
|
|
|
IConfig assetConfig = source.Configs["AssetCache"];
|
|
if (assetConfig != null)
|
|
{
|
|
// Get optional configurations
|
|
maxSize = assetConfig.GetLong("MaxSize", DefaultMaxSize);
|
|
maxCount = assetConfig.GetInt("MaxCount", DefaultMaxCount);
|
|
expirationTime =
|
|
TimeSpan.FromMinutes(assetConfig.GetInt("ExpirationTime", (int)DefaultExpirationTime.TotalMinutes));
|
|
|
|
// Debugging purposes only
|
|
m_debugEpoch = assetConfig.GetInt("DebugEpoch", 0);
|
|
}
|
|
|
|
Initialize(maxSize, maxCount, expirationTime);
|
|
}
|
|
|
|
/// <summary>
|
|
/// Initialization post handling.
|
|
/// </summary>
|
|
/// <remarks>
|
|
/// <para>
|
|
/// Modules can use this to initialize connection with other modules.
|
|
/// </para>
|
|
/// </remarks>
|
|
public void PostInitialise()
|
|
{
|
|
}
|
|
|
|
/// <summary>
|
|
/// Region has been loaded.
|
|
/// </summary>
|
|
/// <param name="scene">
|
|
/// Region's scene.
|
|
/// </param>
|
|
/// <remarks>
|
|
/// <para>
|
|
/// This is needed for all module types. Modules will register
|
|
/// Interfaces with scene in AddScene, and will also need a means
|
|
/// to access interfaces registered by other modules. Without
|
|
/// this extra method, a module attempting to use another modules'
|
|
/// interface would be successful only depending on load order,
|
|
/// which can't be depended upon, or modules would need to resort
|
|
/// to ugly kludges to attempt to request interfaces when needed
|
|
/// and unnecessary caching logic repeated in all modules.
|
|
/// The extra function stub is just that much cleaner.
|
|
/// </para>
|
|
/// </remarks>
|
|
public void RegionLoaded(Scene scene)
|
|
{
|
|
}
|
|
|
|
/// <summary>
|
|
/// Region is being removed.
|
|
/// </summary>
|
|
/// <param name="scene">
|
|
/// Region scene that is being removed.
|
|
/// </param>
|
|
public void RemoveRegion(Scene scene)
|
|
{
|
|
}
|
|
|
|
#endregion
|
|
}
|
|
}
|