OpenSim
/
OpenSimMirror
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity

Remove the old asset cache and local services and the configurations for them

0.6.6-post-fixes
Melanie Thielker 2009-05-18 23:18:04 +00:00
parent df16532858
commit 23d902be42
14 changed files with 7 additions and 1194 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
OpenSim/ApplicationPlugins/CreateCommsManager/CreateCommsManagerPlugin.cs
View File

@ -169,7 +169,7 @@ namespace OpenSim.ApplicationPlugins.CreateCommsManager
m_commsManager
= new CommunicationsLocal(
m_openSim.ConfigurationSettings, m_openSim.NetServersInfo, m_httpServer, m_openSim.AssetCache,
libraryRootFolder, m_openSim.ConfigurationSettings.DumpAssetsToFile);
libraryRootFolder, false);
CreateGridInfoService();
}
@ -195,7 +195,7 @@ namespace OpenSim.ApplicationPlugins.CreateCommsManager
= new HGCommunicationsStandalone(
m_openSim.ConfigurationSettings, m_openSim.NetServersInfo, m_httpServer, m_openSim.AssetCache,
gridService,
libraryRootFolder, m_openSim.ConfigurationSettings.DumpAssetsToFile);
libraryRootFolder, false);
HGServices = gridService;

695
OpenSim/Framework/Communications/Cache/AssetCache.cs
View File

@ -1,695 +0,0 @@
/*
* 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.Text.RegularExpressions;
using System.Threading;
using GlynnTucker.Cache;
using log4net;
using OpenMetaverse;
using OpenMetaverse.Packets;
using OpenSim.Framework.Statistics;
using System.Text;
namespace OpenSim.Framework.Communications.Cache
{
/// <summary>
/// Manages local cache of assets and their sending to viewers.
/// </summary>
///
/// 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.
public class AssetCache : IAssetCache
{
private static readonly ILog m_log
= LogManager.GetLogger(MethodBase.GetCurrentMethod().DeclaringType);
protected ICache m_memcache = new SimpleMemoryCache();
/// <value>
/// Assets requests which are waiting for asset server data. This includes texture requests
/// </value>
private Dictionary<UUID, AssetRequest> RequestedAssets;
/// <value>
/// Asset requests with data which are ready to be sent back to requesters. This includes textures.
/// </value>
private List<AssetRequest> AssetRequests;
/// <value>
/// Until the asset request is fulfilled, each asset request is associated with a list of requesters
/// </value>
private Dictionary<UUID, AssetRequestsList> RequestLists;
#region IPlugin
/// <summary>
/// The methods and properties in this section are needed to
/// support the IPlugin interface. They cann all be overridden
/// as needed by a derived class.
/// </summary>
public virtual string Name
{
get { return "OpenSim.Framework.Communications.Cache.AssetCache"; }
}
public virtual string Version
{
get { return "1.0"; }
}
public virtual void Initialise()
{
m_log.Debug("[ASSET CACHE]: Asset cache null initialisation");
}
public virtual void Initialise(IAssetServer assetServer)
{
m_log.Debug("[ASSET CACHE]: Asset cache server-specified initialisation");
m_log.InfoFormat("[ASSET CACHE]: Asset cache initialisation [{0}/{1}]", Name, Version);
Reset();
m_assetServer = assetServer;
m_assetServer.SetReceiver(this);
Thread assetCacheThread = new Thread(RunAssetManager);
assetCacheThread.Name = "AssetCacheThread";
assetCacheThread.IsBackground = true;
assetCacheThread.Start();
ThreadTracker.Add(assetCacheThread);
}
public virtual void Initialise(ConfigSettings settings, IAssetServer assetServer)
{
m_log.Debug("[ASSET CACHE]: Asset cache configured initialisation");
Initialise(assetServer);
}
public void Dispose()
{
}
#endregion
public IAssetServer AssetServer
{
get { return m_assetServer; }
}
private IAssetServer m_assetServer;
public AssetCache()
{
m_log.Debug("[ASSET CACHE]: Asset cache (plugin constructor)");
}
/// <summary>
/// Constructor.
/// </summary>
/// <param name="assetServer"></param>
public AssetCache(IAssetServer assetServer)
{
Initialise(assetServer);
}
public void ShowState()
{
m_log.InfoFormat("Memcache:{0} RequestLists:{1}",
m_memcache.Count,
// AssetRequests.Count,
// RequestedAssets.Count,
RequestLists.Count);
}
public void Clear()
{
m_log.Info("[ASSET CACHE]: Clearing Asset cache");
if (StatsManager.SimExtraStats != null)
StatsManager.SimExtraStats.ClearAssetCacheStatistics();
Reset();
}
/// <summary>
/// Reset the cache.
/// </summary>
private void Reset()
{
AssetRequests = new List<AssetRequest>();
RequestedAssets = new Dictionary<UUID, AssetRequest>();
RequestLists = new Dictionary<UUID, AssetRequestsList>();
}
/// <summary>
/// Process the asset queue which holds data which is packeted up and sent
/// directly back to the client.
/// </summary>
private void RunAssetManager()
{
while (true)
{
try
{
ProcessAssetQueue();
Thread.Sleep(500);
}
catch (Exception e)
{
if (e != null)
{
m_log.ErrorFormat("[ASSET CACHE]: {0}", e);
}
else
{
// this looks weird, but we've seen this show up as an issue in unit tests, so leave it here until we know why
m_log.Error("[ASSET CACHE]: an exception was thrown in RunAssetManager, but is now null. Something is very wrong.");
}
}
}
}
public bool TryGetCachedAsset(UUID assetId, out AssetBase asset)
{
Object tmp;
if (m_memcache.TryGet(assetId, out tmp))
{
asset = (AssetBase)tmp;
//m_log.Info("Retrieved from cache " + assetId);
return true;
}
asset = null;
return false;
}
public void GetAsset(UUID 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
{
// m_log.DebugFormat("[ASSET CACHE]: Adding request for {0} {1}", isTexture ? "texture" : "asset", assetId);
NewAssetRequest req = new NewAssetRequest(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();
requestList.TimeRequested = DateTime.Now;
requestList.Requests.Add(req);
RequestLists.Add(assetId, requestList);
m_assetServer.RequestAsset(assetId, isTexture);
}
}
}
}
public AssetBase GetAsset(UUID 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.
const int pollPeriod = 200;
int maxPolls = 15;
AssetBase asset;
if (TryGetCachedAsset(assetID, out asset))
{
return asset;
}
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;
}
public void AddAsset(AssetBase asset)
{
if (!m_memcache.Contains(asset.FullID))
{
m_log.Info("[CACHE] Caching " + asset.FullID + " for 24 hours from last access");
// Use 24 hour rolling asset cache.
m_memcache.AddOrUpdate(asset.FullID, asset, TimeSpan.FromHours(24));
// According to http://wiki.secondlife.com/wiki/AssetUploadRequest, Local signifies that the
// information is stored locally. It could disappear, in which case we could send the
// ImageNotInDatabase packet to tell the client this.
//
// However, this doesn't quite appear to work with local textures that are part of an avatar's
// appearance texture set. Whilst sending an ImageNotInDatabase does trigger an automatic rebake
// and reupload by the client, if those assets aren't pushed to the asset server anyway, then
// on crossing onto another region server, other avatars can no longer get the required textures.
// There doesn't appear to be any signal from the sim to the newly region border crossed client
// asking it to reupload its local texture assets to that region server.
//
// One can think of other cunning ways around this. For instance, on a region crossing or teleport,
// the original sim could squirt local assets to the new sim. Or the new sim could have pointers
// to the original sim to fetch the 'local' assets (this is getting more complicated).
//
// But for now, we're going to take the easy way out and store local assets globally.
//
// TODO: Also, Temporary is now deprecated. We should start ignoring it and not passing it out from LLClientView.
if (!asset.Temporary || asset.Local)
{
m_assetServer.StoreAsset(asset);
}
if (StatsManager.SimExtraStats != null)
StatsManager.SimExtraStats.AddAsset(asset);
}
}
public void ExpireAsset(UUID uuid)
{
if (m_memcache.Contains(uuid))
{
m_memcache.Remove(uuid);
if (StatsManager.SimExtraStats != null)
StatsManager.SimExtraStats.RemoveAsset(uuid);
}
}
// See IAssetReceiver
public virtual void AssetReceived(AssetBase asset, bool IsTexture)
{
AssetInfo assetInf = new AssetInfo(asset);
ProcessReceivedAsset(IsTexture, assetInf, null);
if (!m_memcache.Contains(assetInf.FullID))
{
m_memcache.AddOrUpdate(assetInf.FullID, assetInf, TimeSpan.FromHours(24));
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);
if (req.AssetRequestSource == 2 && assetInf.Type == 10)
{
// If it's a direct request for a script, drop it
// because it's a hacked client
}
else
{
lock (AssetRequests)
{
AssetRequests.Add(req);
}
}
}
}
// Notify requesters for this asset
AssetRequestsList reqList;
lock (RequestLists)
{
if (RequestLists.TryGetValue(asset.FullID, out reqList))
RequestLists.Remove(asset.FullID);
}
if (reqList != null)
{
if (StatsManager.SimExtraStats != null)
StatsManager.SimExtraStats.AddAssetRequestTimeAfterCacheMiss(DateTime.Now - reqList.TimeRequested);
foreach (NewAssetRequest req in reqList.Requests)
{
// 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);
}
}
}
protected void ProcessReceivedAsset(bool IsTexture, AssetInfo assetInf, IUserService userService)
{
// if (!IsTexture && assetInf.ContainsReferences && false)
// {
// assetInf.Data = ProcessAssetData(assetInf.Data, userService);
// }
}
// See IAssetReceiver
public virtual void AssetNotFound(UUID assetId, bool isTexture)
{
// m_log.WarnFormat("[ASSET CACHE]: AssetNotFound for {0}", assetId);
// Remember the fact that this asset could not be found to prevent delays from repeated requests
m_memcache.Add(assetId, null, TimeSpan.FromHours(24));
// Notify requesters for this asset
AssetRequestsList reqList;
lock (RequestLists)
{
if (RequestLists.TryGetValue(assetId, out reqList))
RequestLists.Remove(assetId);
}
if (reqList != null)
{
if (StatsManager.SimExtraStats != null)
StatsManager.SimExtraStats.AddAssetRequestTimeAfterCacheMiss(DateTime.Now - reqList.TimeRequested);
foreach (NewAssetRequest req in reqList.Requests)
{
req.Callback(assetId, null);
}
}
}
/// <summary>
/// Calculate the number of packets required to send the asset to the client.
/// </summary>
/// <param name="data"></param>
/// <returns></returns>
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;
}
public void AddAssetRequest(IClientAPI userInfo, TransferRequestPacket transferRequest)
{
UUID requestID = UUID.Zero;
byte source = 2;
if (transferRequest.TransferInfo.SourceType == 2)
{
//direct asset request
requestID = new UUID(transferRequest.TransferInfo.Params, 0);
}
else if (transferRequest.TransferInfo.SourceType == 3)
{
//inventory asset request
requestID = new UUID(transferRequest.TransferInfo.Params, 80);
source = 3;
//m_log.Debug("asset request " + requestID);
}
//check to see if asset is in local cache, if not we need to request it from asset server.
//m_log.Debug("asset request " + requestID);
if (!m_memcache.Contains(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
AssetBase asset = (AssetBase)m_memcache[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;
}
// Scripts cannot be retrieved by direct request
if (transferRequest.TransferInfo.SourceType == 2 && asset.Type == 10)
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 = new AssetInfo(asset);
req.NumPackets = CalculateNumPackets(asset.Data);
lock (AssetRequests)
{
AssetRequests.Add(req);
}
}
/// <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;
AssetRequestToClient req2 = new AssetRequestToClient();
lock (AssetRequests)
{
for (int i = 0; i < num; i++)
{
req = AssetRequests[0];
AssetRequests.RemoveAt(0);
req2.AssetInf = req.AssetInf;
req2.AssetRequestSource = req.AssetRequestSource;
req2.DataPointer = req.DataPointer;
req2.DiscardLevel = req.DiscardLevel;
req2.ImageInfo = 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);
}
}
}
public byte[] ProcessAssetData(byte[] assetData, IUserService userService)
{
string data = Encoding.ASCII.GetString(assetData);
data = ProcessAssetDataString(data, userService);
return Encoding.ASCII.GetBytes(data);
}
public string ProcessAssetDataString(string data, IUserService userService)
{
Regex regex = new Regex("(creator_url|owner_url)\\s+(\\S+)");
data = regex.Replace(data, delegate(Match m)
{
string result = String.Empty;
string key = m.Groups[1].Captures[0].Value;
string value = m.Groups[2].Captures[0].Value;
Uri userUri;
switch (key)
{
case "creator_url":
userUri = new Uri(value);
result = "creator_id " + ResolveUserUri(userService, userUri);
break;
case "owner_url":
userUri = new Uri(value);
result = "owner_id " + ResolveUserUri(userService, userUri);
break;
}
return result;
});
return data;
}
private Guid ResolveUserUri(IUserService userService, Uri userUri)
{
Guid id;
UserProfileData userProfile = userService.GetUserProfile(userUri);
if (userProfile == null)
{
id = Guid.Empty;
}
else
{
id = userProfile.ID.Guid;
}
return id;
}
public class AssetRequest
{
public IClientAPI RequestUser;
public UUID RequestAssetID;
public AssetInfo AssetInf;
public TextureImage ImageInfo;
public UUID 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 class AssetInfo : AssetBase
{
public AssetInfo(AssetBase aBase)
{
Data = aBase.Data;
FullID = aBase.FullID;
Type = aBase.Type;
Name = aBase.Name;
Description = aBase.Description;
}
public const string Secret = "secret";
}
public class TextureImage : AssetBase
{
public TextureImage(AssetBase aBase)
{
Data = aBase.Data;
FullID = aBase.FullID;
Type = aBase.Type;
Name = aBase.Name;
Description = aBase.Description;
}
}
/// <summary>
/// A list of requests for a particular asset.
/// </summary>
public class AssetRequestsList
{
/// <summary>
/// A list of requests for assets
/// </summary>
public List<NewAssetRequest> Requests = new List<NewAssetRequest>();
/// <summary>
/// Record the time that this request was first made.
/// </summary>
public DateTime TimeRequested;
}
/// <summary>
/// Represent a request for an asset that has yet to be fulfilled.
/// </summary>
public class NewAssetRequest
{
public AssetRequestCallback Callback;
public NewAssetRequest(AssetRequestCallback callback)
{
Callback = callback;
}
}
}
}

113
OpenSim/Framework/Communications/Cache/SQLAssetServer.cs
View File

@ -1,113 +0,0 @@
/*
* Copyright (c) Contributors, http://www.openmetaverse.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.Reflection;
using log4net;
using OpenSim.Data;
namespace OpenSim.Framework.Communications.Cache
{
public class SQLAssetServer : AssetServerBase
{
private static readonly ILog m_log = LogManager.GetLogger(MethodBase.GetCurrentMethod().DeclaringType);
#region IPlugin
public override string Name
{
get { return "SQL"; }
}
public override string Version
{
get { return "1.0"; }
}
public override void Initialise(ConfigSettings p_set)
{
m_log.Debug("[SQLAssetServer]: Plugin configured initialisation");
Initialise(p_set.StandaloneAssetPlugin,p_set.StandaloneAssetSource);
}
#endregion
public SQLAssetServer() {}
public SQLAssetServer(string pluginName, string connect)
{
m_log.Debug("[SQLAssetServer]: Direct constructor");
Initialise(pluginName, connect);
}
public void Initialise(string pluginName, string connect)
{
AddPlugin(pluginName, connect);
}
public SQLAssetServer(IAssetDataPlugin assetProvider)
{
m_assetProvider = assetProvider;
}
public void AddPlugin(string FileName, string connect)
{
m_log.Info("[SQLAssetServer]: AssetStorage: Attempting to load " + FileName);
Assembly pluginAssembly = Assembly.LoadFrom(FileName);
foreach (Type pluginType in pluginAssembly.GetTypes())
{
if (!pluginType.IsAbstract)
{
Type typeInterface = pluginType.GetInterface("IAssetDataPlugin", true);
if (typeInterface != null)
{
IAssetDataPlugin plug =
(IAssetDataPlugin) Activator.CreateInstance(pluginAssembly.GetType(pluginType.ToString()));
m_assetProvider = plug;
m_assetProvider.Initialise(connect);
m_log.Info("[AssetStorage]: " +
"Added " + m_assetProvider.Name + " " +
m_assetProvider.Version);
}
}
}
}
protected override AssetBase GetAsset(AssetRequest req)
{
return m_assetProvider.FetchAsset(req.AssetID);
}
public override void StoreAsset(AssetBase asset)
{
m_assetProvider.CreateAsset(asset);
}
}
}

14
OpenSim/Framework/Communications/CommunicationsManager.cs
View File

@ -72,25 +72,12 @@ namespace OpenSim.Framework.Communications
}
protected UserProfileCacheService m_userProfileCacheService;
// protected AgentAssetTransactionsManager m_transactionsManager;
// public AgentAssetTransactionsManager TransactionsManager
// {
// get { return m_transactionsManager; }
// }
public IAvatarService AvatarService
{
get { return m_avatarService; }
}
protected IAvatarService m_avatarService;
public IAssetCache AssetCache
{
get { return m_assetCache; }
}
protected IAssetCache m_assetCache;
public IInterServiceInventoryServices InterServiceInventoryService
{
get { return m_interServiceInventoryService; }
@ -132,7 +119,6 @@ namespace OpenSim.Framework.Communications
bool dumpAssetsToFile, LibraryRootFolder libraryRootFolder)
{
m_networkServersInfo = serversInfo;
m_assetCache = assetCache;
m_userProfileCacheService = new UserProfileCacheService(this, libraryRootFolder);
m_httpServer = httpServer;
}

61
OpenSim/Framework/Communications/Tests/Cache/AssetCacheTests.cs
View File

@ -43,51 +43,6 @@ namespace OpenSim.Framework.Communications.Tests
[TestFixture]
public class AssetCacheTests
{
protected UUID m_assetIdReceived;
protected AssetBase m_assetReceived;
/// <summary>
/// Test the 'asynchronous' get asset mechanism (though this won't be done asynchronously within this test)
/// </summary>
[Test]
public void TestGetAsset()
{
UUID assetId = UUID.Parse("00000000-0000-0000-0000-000000000001");
byte[] assetData = new byte[] { 3, 2, 1 };
AssetBase asset = new AssetBase();
asset.FullID = assetId;
asset.Data = assetData;
TestAssetDataPlugin assetPlugin = new TestAssetDataPlugin();
assetPlugin.CreateAsset(asset);
SQLAssetServer assetServer = new SQLAssetServer(assetPlugin);
IAssetCache assetCache = new AssetCache(assetServer);
assetCache.GetAsset(assetId, AssetRequestCallback, false);
// Manually pump the asset server
while (assetServer.HasWaitingRequests())
assetServer.ProcessNextRequest();
Assert.That(
assetId, Is.EqualTo(m_assetIdReceived), "Asset id stored differs from asset id received");
Assert.That(
assetData, Is.EqualTo(m_assetReceived.Data), "Asset data stored differs from asset data received");
}
private void AssetRequestCallback(UUID assetId, AssetBase asset)
{
m_assetIdReceived = assetId;
m_assetReceived = asset;
lock (this)
{
Monitor.PulseAll(this);
}
}
private class FakeUserService : IUserService
{
public void AddTemporaryUserProfile(UserProfileData userProfile)
@ -109,7 +64,7 @@ namespace OpenSim.Framework.Communications.Tests
{
UserProfileData userProfile = new UserProfileData();
userProfile.ID = new UUID( Util.GetHashGuid( uri.ToString(), AssetCache.AssetInfo.Secret ));
// userProfile.ID = new UUID( Util.GetHashGuid( uri.ToString(), AssetCache.AssetInfo.Secret ));
return userProfile;
}
@ -189,19 +144,5 @@ namespace OpenSim.Framework.Communications.Tests
return true;
}
}
[Test]
public void TestProcessAssetData()
{
string url = "http://host/dir/";
string creatorData = " creator_url " + url + " ";
string ownerData = " owner_url " + url + " ";
AssetCache assetCache = new AssetCache();
FakeUserService fakeUserService = new FakeUserService();
Assert.AreEqual(" creator_id " + Util.GetHashGuid(url, AssetCache.AssetInfo.Secret) + " ", assetCache.ProcessAssetDataString(creatorData, fakeUserService));
Assert.AreEqual(" owner_id " + Util.GetHashGuid(url, AssetCache.AssetInfo.Secret) + " ", assetCache.ProcessAssetDataString(ownerData, fakeUserService));
}
}
}

52
OpenSim/Framework/ConfigSettings.cs
View File

@ -108,14 +108,6 @@ namespace OpenSim.Framework
set { m_standaloneInventoryPlugin = value; }
}
private string m_standaloneAssetPlugin;
public string StandaloneAssetPlugin
{
get { return m_standaloneAssetPlugin; }
set { m_standaloneAssetPlugin = value; }
}
private string m_standaloneUserPlugin;
public string StandaloneUserPlugin
@ -132,14 +124,6 @@ namespace OpenSim.Framework
set { m_standaloneInventorySource = value; }
}
private string m_standaloneAssetSource;
public string StandaloneAssetSource
{
get { return m_standaloneAssetSource; }
set { m_standaloneAssetSource = value; }
}
private string m_standaloneUserSource;
public string StandaloneUserSource
@ -148,22 +132,6 @@ namespace OpenSim.Framework
set { m_standaloneUserSource = value; }
}
private string m_assetStorage = "local";
public string AssetStorage
{
get { return m_assetStorage; }
set { m_assetStorage = value; }
}
private string m_assetCache;
public string AssetCache
{
get { return m_assetCache; }
set { m_assetCache = value; }
}
protected string m_storageConnectionString;
public string StorageConnectionString
@ -180,14 +148,6 @@ namespace OpenSim.Framework
set { m_estateConnectionString = value; }
}
protected bool m_dumpAssetsToFile;
public bool DumpAssetsToFile
{
get { return m_dumpAssetsToFile; }
set { m_dumpAssetsToFile = value; }
}
protected string m_librariesXMLFile;
public string LibrariesXMLFile
{
@ -200,18 +160,6 @@ namespace OpenSim.Framework
m_librariesXMLFile = value;
}
}
protected string m_assetSetsXMLFile;
public string AssetSetsXMLFile
{
get
{
return m_assetSetsXMLFile;
}
set
{
m_assetSetsXMLFile = value;
}
}
public const uint DefaultAssetServerHttpPort = 8003;
public const uint DefaultRegionHttpPort = 9000;

16
OpenSim/Region/Application/ConfigurationLoader.cs
View File

@ -219,7 +219,6 @@ namespace OpenSim
config.Set("startup_console_commands_file", String.Empty);
config.Set("shutdown_console_commands_file", String.Empty);
config.Set("DefaultScriptEngine", "XEngine");
config.Set("asset_database", "default");
config.Set("clientstack_plugin", "OpenSim.Region.ClientStack.LindenUDP.dll");
// life doesn't really work without this
config.Set("EventQueue", true);
@ -237,11 +236,7 @@ namespace OpenSim
config.Set("inventory_source", "");
config.Set("userDatabase_plugin", "OpenSim.Data.SQLite.dll");
config.Set("user_source", "");
config.Set("asset_plugin", "OpenSim.Data.SQLite.dll");
config.Set("asset_source", "URI=file:Asset.db,version=3");
config.Set("LibrariesXMLFile", string.Format(".{0}inventory{0}Libraries.xml", Path.DirectorySeparatorChar));
config.Set("AssetSetsXMLFile", string.Format(".{0}assets{0}AssetSets.xml", Path.DirectorySeparatorChar));
config.Set("dump_assets_to_file", false);
}
{
@ -292,10 +287,6 @@ namespace OpenSim
= startupConfig.GetString("storage_connection_string");
m_configSettings.EstateConnectionString
= startupConfig.GetString("estate_connection_string", m_configSettings.StorageConnectionString);
m_configSettings.AssetStorage
= startupConfig.GetString("asset_database");
m_configSettings.AssetCache
= startupConfig.GetString("AssetCache", "OpenSim.Framework.Communications.Cache.AssetCache");
m_configSettings.ClientstackDll
= startupConfig.GetString("clientstack_plugin", "OpenSim.Region.ClientStack.LindenUDP.dll");
}
@ -310,16 +301,11 @@ namespace OpenSim
m_configSettings.StandaloneInventorySource = standaloneConfig.GetString("inventory_source");
m_configSettings.StandaloneUserPlugin = standaloneConfig.GetString("userDatabase_plugin");
m_configSettings.StandaloneUserSource = standaloneConfig.GetString("user_source");
m_configSettings.StandaloneAssetPlugin = standaloneConfig.GetString("asset_plugin");
m_configSettings.StandaloneAssetSource = standaloneConfig.GetString("asset_source");
m_configSettings.LibrariesXMLFile = standaloneConfig.GetString("LibrariesXMLFile");
m_configSettings.AssetSetsXMLFile = standaloneConfig.GetString("AssetSetsXMLFile");
m_configSettings.DumpAssetsToFile = standaloneConfig.GetBoolean("dump_assets_to_file", false);
}
m_networkServersInfo.loadFromConfiguration(m_config.Source);
}
}
}
}

4
OpenSim/Region/Application/HGCommands.cs
View File

@ -57,7 +57,7 @@ namespace OpenSim
return
new HGScene(
regionInfo, circuitManager, m_commsManager, sceneGridService, storageManager,
m_moduleLoader, m_configSettings.DumpAssetsToFile, m_configSettings.PhysicalPrim,
m_moduleLoader, false, m_configSettings.PhysicalPrim,
m_configSettings.See_into_region_from_neighbor, m_config.Source, m_version);
}
@ -270,4 +270,4 @@ namespace OpenSim
}
}
}
}

164
OpenSim/Region/Application/OpenSimBase.cs
View File

@ -281,7 +281,6 @@ namespace OpenSim
// Called from base.StartUp()
m_httpServerPort = m_networkServersInfo.HttpListenerPort;
InitialiseAssetCache();
m_sceneManager.OnRestartSim += handleRestartRegion;
}
@ -296,167 +295,6 @@ namespace OpenSim
/// returns an IAssetCache implementation, if possible. This is a virtual
/// method.
/// </summary>
protected virtual void InitialiseAssetCache()
{
LegacyAssetClientPluginInitialiser linit = null;
CryptoAssetClientPluginInitialiser cinit = null;
AssetClientPluginInitialiser init = null;
IAssetServer assetServer = null;
string mode = m_configSettings.AssetStorage;
if (mode == null | mode == String.Empty)
mode = "default";
// If "default" is specified, then the value is adjusted
// according to whether or not the server is running in
// standalone mode.
if (mode.ToLower() == "default")
{
if (m_configSettings.Standalone == false)
mode = "grid";
else
mode = "local";
}
switch (mode.ToLower())
{
// If grid is specified then the grid server is chose regardless
// of whether the server is standalone.
case "grid":
linit = new LegacyAssetClientPluginInitialiser(m_configSettings, m_networkServersInfo.AssetURL);
assetServer = loadAssetServer("Grid", linit);
break;
// If cryptogrid is specified then the cryptogrid server is chose regardless
// of whether the server is standalone.
case "cryptogrid":
cinit = new CryptoAssetClientPluginInitialiser(m_configSettings, m_networkServersInfo.AssetURL,
Environment.CurrentDirectory, true);
assetServer = loadAssetServer("Crypto", cinit);
break;
// If cryptogrid_eou is specified then the cryptogrid_eou server is chose regardless
// of whether the server is standalone.
case "cryptogrid_eou":
cinit = new CryptoAssetClientPluginInitialiser(m_configSettings, m_networkServersInfo.AssetURL,
Environment.CurrentDirectory, false);
assetServer = loadAssetServer("Crypto", cinit);
break;
// If file is specified then the file server is chose regardless
// of whether the server is standalone.
case "file":
linit = new LegacyAssetClientPluginInitialiser(m_configSettings, m_networkServersInfo.AssetURL);
assetServer = loadAssetServer("File", linit);
break;
// If local is specified then we're going to use the local SQL server
// implementation. We drop through, because that will be the fallback
// for the following default clause too.
case "local":
break;
// If the asset_database value is none of the previously mentioned strings, then we
// try to load a turnkey plugin that matches this value. If not we drop through to
// a local default.
default:
try
{
init = new AssetClientPluginInitialiser(m_configSettings);
assetServer = loadAssetServer(m_configSettings.AssetStorage, init);
break;
}
catch
{
}
m_log.Info("[OPENSIMBASE]: Default assetserver will be used");
break;
}
// Open the local SQL-based database asset server
if (assetServer == null)
{
init = new AssetClientPluginInitialiser(m_configSettings);
SQLAssetServer sqlAssetServer = (SQLAssetServer) loadAssetServer("SQL", init);
sqlAssetServer.LoadDefaultAssets(m_configSettings.AssetSetsXMLFile);
assetServer = sqlAssetServer;
}
// Initialize the asset cache, passing a reference to the selected
// asset server interface.
m_assetCache = ResolveAssetCache(assetServer);
assetServer.Start();
}
// This method loads the identified asset server, passing an approrpiately
// initialized Initialise wrapper. There should to be exactly one match,
// if not, then the first match is used.
private IAssetServer loadAssetServer(string id, PluginInitialiserBase pi)
{
if (id != null && id != String.Empty)
{
m_log.DebugFormat("[OPENSIMBASE] Attempting to load asset server id={0}", id);
try
{
PluginLoader<IAssetServer> loader = new PluginLoader<IAssetServer>(pi);
loader.AddFilter(PLUGIN_ASSET_SERVER_CLIENT, new PluginProviderFilter(id));
loader.Load(PLUGIN_ASSET_SERVER_CLIENT);
if (loader.Plugins.Count > 0)
{
m_log.DebugFormat("[OPENSIMBASE] Asset server {0} loaded", id);
return (IAssetServer) loader.Plugins[0];
}
}
catch (Exception e)
{
m_log.DebugFormat("[OPENSIMBASE] Asset server {0} not loaded ({1})", id, e.Message);
}
}
return null;
}
/// <summary>
/// Attempt to instantiate an IAssetCache implementation, using the
/// provided IAssetServer reference.
/// An asset cache implementation must provide a constructor that
/// accepts two parameters;
/// [1] A ConfigSettings reference.
/// [2] An IAssetServer reference.
/// The AssetCache value is obtained from the
/// [StartUp]/AssetCache value in the configuration file.
/// </summary>
protected virtual IAssetCache ResolveAssetCache(IAssetServer assetServer)
{
IAssetCache assetCache = null;
if (m_configSettings.AssetCache != null && m_configSettings.AssetCache != String.Empty)
{
m_log.DebugFormat("[OPENSIMBASE]: Attempting to load asset cache id = {0}", m_configSettings.AssetCache);
try
{
PluginInitialiserBase init = new AssetCachePluginInitialiser(m_configSettings, assetServer);
PluginLoader<IAssetCache> loader = new PluginLoader<IAssetCache>(init);
loader.AddFilter(PLUGIN_ASSET_CACHE, new PluginProviderFilter(m_configSettings.AssetCache));
loader.Load(PLUGIN_ASSET_CACHE);
if (loader.Plugins.Count > 0)
assetCache = (IAssetCache) loader.Plugins[0];
}
catch (Exception e)
{
m_log.Error("[OPENSIMBASE]: ResolveAssetCache failed");
m_log.Error(e);
}
}
// If everything else fails, we force load the built-in asset cache
return (IAssetCache) ((assetCache != null) ? assetCache : new AssetCache(assetServer));
}
public void ProcessLogin(bool LoginEnabled)
{
if (LoginEnabled)
@ -755,7 +593,7 @@ namespace OpenSim
return new Scene(
regionInfo, circuitManager, m_commsManager, sceneGridService,
storageManager, m_moduleLoader, m_configSettings.DumpAssetsToFile, m_configSettings.PhysicalPrim,
storageManager, m_moduleLoader, false, m_configSettings.PhysicalPrim,
m_configSettings.See_into_region_from_neighbor, m_config.Source, m_version);
}

1
OpenSim/Region/Communications/Hypergrid/HGCommunicationsStandalone.cs
View File

@ -73,7 +73,6 @@ namespace OpenSim.Region.Communications.Hypergrid
m_interServiceInventoryService = inventoryService;
inventoryService.UserProfileCache = UserProfileCacheService;
m_assetCache = assetCache;
// Let's swap to always be secure access to inventory
AddSecureInventoryService((ISecureInventoryService)inventoryService);
m_inventoryServices = null;

18
OpenSim/Region/CoreModules/Agent/AssetTransaction/AssetTransactionModule.cs
View File

@ -70,24 +70,6 @@ namespace OpenSim.Region.CoreModules.Agent.AssetTransaction
scene.EventManager.OnNewClient += NewClient;
}
if (m_scene == null)
{
m_scene = scene;
if (config.Configs["StandAlone"] != null)
{
try
{
m_dumpAssetsToFile = config.Configs["StandAlone"].GetBoolean("dump_assets_to_file", false);
}
catch (Exception)
{
}
}
else
{
}
}
}
public void PostInitialise()

11
OpenSim/Tests/Common/Mock/TestCommunicationsManager.cs
View File

@ -57,9 +57,6 @@ namespace OpenSim.Tests.Common.Mock
public TestCommunicationsManager(NetworkServersInfo serversInfo)
: base(serversInfo, new BaseHttpServer(666), null, false, null)
{
SQLAssetServer assetService = new SQLAssetServer(new TestAssetDataPlugin());
m_assetCache = new AssetCache(assetService);
LocalInventoryService lis = new LocalInventoryService();
m_inventoryDataPlugin = new TestInventoryDataPlugin();
lis.AddPlugin(m_inventoryDataPlugin);
@ -76,13 +73,5 @@ namespace OpenSim.Tests.Common.Mock
LocalBackEndServices gs = new LocalBackEndServices();
m_gridService = gs;
}
/// <summary>
/// Start services that take care of business using their own threads.
/// </summary>
public void StartServices()
{
m_assetCache.AssetServer.Start();
}
}
}

3
OpenSim/Tests/Common/Setup/SceneSetupHelpers.cs
View File

@ -147,9 +147,6 @@ namespace OpenSim.Tests.Common.Setup
testScene.PhysicsScene
= physicsPluginManager.GetPhysicsScene("basicphysics", "ZeroMesher", configSource, "test");
if (startServices)
cm.StartServices();
return testScene;
}

45
bin/OpenSim.ini.example
View File

@ -110,19 +110,6 @@
; grid asset server. If you select local in grid mode, then you will use a database as specified in asset_plugin to store assets
; locally. This will mean you won't be able to take items using your assets to other people's regions.
; asset_database can be default, local or grid. This controls where assets (textures, scripts, etc.) are stored for your region
;
; If set to default, then
; In standalone mode the local database based asset service will be used
; In grid mode the grid asset service will be used for asset storage
; This is probably the setting that you want.
;
; If set to local then the local database based asset service will be used in standalone and grid modes
; If set to grid then the grid based asset service will be used in standalone and grid modes
; All other values will cause a search for a matching assembly that contains an asset server client.
; See also: AssetCache
asset_database = "default"
; Persistence of changed objects happens during regular sweeps. The following control that behaviour to
; prevent frequently changing objects from heavily loading the region data store.
; If both of these values are set to zero then persistence of all changed objects will happen on every sweep.
@ -219,18 +206,6 @@
;XmlRpcRouterModule = "XmlRpcRouterModule"
; ##
; ## Customized Cache Implementation
; ##
;
; The AssetCache value allows the name of an alternative caching
; implementation to be specified. This can normally be omitted.
; This value corresponds to the provider value associated with the
; intended cache implementation plugin.
; See also: asset_database
; AssetCache = "OpenSim.Framework.Communications.Cache.AssetCache"
; ##
; ## EMAIL MODULE
; ##
@ -281,19 +256,6 @@
accounts_authenticate = true
welcome_message = "Welcome to OpenSimulator"
; Asset database provider
asset_plugin = "OpenSim.Data.SQLite.dll"
; asset_plugin = "OpenSim.Data.MySQL.dll" ; for mysql
; asset_plugin = "OpenSim.Data.NHibernate.dll" ; for nhibernate
; the Asset DB source. This only works for sqlite, mysql, and nhibernate for now
; Asset source SQLite example
asset_source = "URI=file:Asset.db,version=3"
; Asset Source NHibernate example (DIALECT;DRIVER;CONNECTSTRING)
; asset_source = "SQLiteDialect;SqliteClientDriver;URI=file:Asset.db,version=3"
; Asset Source MySQL example
;asset_source = "Data Source=localhost;Database=opensim;User ID=opensim;Password=****;"
; Inventory database provider
inventory_plugin = "OpenSim.Data.SQLite.dll"
; inventory_plugin = "OpenSim.Data.MySQL.dll"
@ -329,13 +291,6 @@
; Default is ./inventory/Libraries.xml
LibrariesXMLFile="./inventory/Libraries.xml"
; Specifies the location and filename of the inventory library assets control file. The path can be relative or absolute
; Setting is optional. Default is ./assets/AssetSets.xml
AssetSetsXMLFile="./assets/AssetSets.xml"
dump_assets_to_file = false
[Network]
http_listener_port = 9000
default_location_x = 1000