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

Some refactoring from about a week ago that I forgot to commit, of AssetTransactionModule to cut down on number of classes and to work towards having a base AssetXferUploader class than can be shared with EstateTerrainXferHandler

0.6.1-post-fixes
MW 2008-11-24 10:03:18 +00:00
parent d8bb20fc1c
commit 0be9ff1949
5 changed files with 301 additions and 128 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

6
OpenSim/Region/Environment/Modules/Agent/AssetTransaction/AgentAssetTransactionsManager.cs
View File

@ -35,6 +35,7 @@ using OpenSim.Region.Interfaces;
namespace OpenSim.Region.Environment.Modules.Agent.AssetTransaction namespace OpenSim.Region.Environment.Modules.Agent.AssetTransaction
{ {
/*
public class AgentAssetTransactionsManager public class AgentAssetTransactionsManager
{ {
//private static readonly ILog m_log //private static readonly ILog m_log
@ -71,8 +72,8 @@ namespace OpenSim.Region.Environment.Modules.Agent.AssetTransaction
{ {
if (!AgentTransactions.ContainsKey(userID)) if (!AgentTransactions.ContainsKey(userID))
{ {
AgentAssetTransactions transactions AgentAssetTransactions transactions = null;
= new AgentAssetTransactions(userID, this, m_dumpAssetsToFile); //= new AgentAssetTransactions(userID, this, m_dumpAssetsToFile);
AgentTransactions.Add(userID, transactions); AgentTransactions.Add(userID, transactions);
} }
@ -226,4 +227,5 @@ namespace OpenSim.Region.Environment.Modules.Agent.AssetTransaction
transactions.HandleXfer(xferID, packetID, data); transactions.HandleXfer(xferID, packetID, data);
} }
} }
*/
} }

132
OpenSim/Region/Environment/Modules/Agent/AssetTransaction/AgentAssetsTransactions.cs
View File

@ -30,6 +30,7 @@ using System.Collections.Generic;
using OpenMetaverse; using OpenMetaverse;
using OpenSim.Framework; using OpenSim.Framework;
using OpenSim.Region.Environment.Scenes; using OpenSim.Region.Environment.Scenes;
using OpenSim.Framework.Communications.Cache;
namespace OpenSim.Region.Environment.Modules.Agent.AssetTransaction namespace OpenSim.Region.Environment.Modules.Agent.AssetTransaction
{ {
@ -38,17 +39,16 @@ namespace OpenSim.Region.Environment.Modules.Agent.AssetTransaction
/// </summary> /// </summary>
public class AgentAssetTransactions public class AgentAssetTransactions
{ {
//private static readonly log4net.ILog m_log private static readonly log4net.ILog m_log = log4net.LogManager.GetLogger(System.Reflection.MethodBase.GetCurrentMethod().DeclaringType);
// = log4net.LogManager.GetLogger(System.Reflection.MethodBase.GetCurrentMethod().DeclaringType);
// Fields // Fields
private bool m_dumpAssetsToFile; private bool m_dumpAssetsToFile;
public AgentAssetTransactionsManager Manager; public AssetTransactionModule Manager;
public UUID UserID; public UUID UserID;
public Dictionary<UUID, AssetXferUploader> XferUploaders = new Dictionary<UUID, AssetXferUploader>(); public Dictionary<UUID, AssetXferUploader> XferUploaders = new Dictionary<UUID, AssetXferUploader>();
// Methods // Methods
public AgentAssetTransactions(UUID agentID, AgentAssetTransactionsManager manager, bool dumpAssetsToFile) public AgentAssetTransactions(UUID agentID, AssetTransactionModule manager, bool dumpAssetsToFile)
{ {
UserID = agentID; UserID = agentID;
Manager = manager; Manager = manager;
@ -97,24 +97,8 @@ namespace OpenSim.Region.Environment.Modules.Agent.AssetTransaction
wearableType, nextOwnerMask); wearableType, nextOwnerMask);
} }
} }
public void RequestUpdateInventoryItem(IClientAPI remoteClient, UUID transactionID,
InventoryItemBase item)
{
if (XferUploaders.ContainsKey(transactionID))
{
XferUploaders[transactionID].RequestUpdateInventoryItem(remoteClient, transactionID, item);
}
}
public void RequestUpdateTaskInventoryItem(
IClientAPI remoteClient, SceneObjectPart part, UUID transactionID, TaskInventoryItem item)
{
if (XferUploaders.ContainsKey(transactionID))
{
XferUploaders[transactionID].RequestUpdateTaskInventoryItem(remoteClient, part, transactionID, item);
}
}
/// <summary> /// <summary>
/// Get an uploaded asset. If the data is successfully retrieved, the transaction will be removed. /// Get an uploaded asset. If the data is successfully retrieved, the transaction will be removed.
@ -138,5 +122,111 @@ namespace OpenSim.Region.Environment.Modules.Agent.AssetTransaction
return null; return null;
} }
//private void CreateItemFromUpload(AssetBase asset, IClientAPI ourClient, UUID inventoryFolderID, uint nextPerms, uint wearableType)
//{
// Manager.MyScene.CommsManager.AssetCache.AddAsset(asset);
// CachedUserInfo userInfo = Manager.MyScene.CommsManager.UserProfileCacheService.GetUserDetails(
// ourClient.AgentId);
// if (userInfo != null)
// {
// InventoryItemBase item = new InventoryItemBase();
// item.Owner = ourClient.AgentId;
// item.Creator = ourClient.AgentId;
// item.ID = UUID.Random();
// item.AssetID = asset.FullID;
// item.Description = asset.Description;
// item.Name = asset.Name;
// item.AssetType = asset.Type;
// item.InvType = asset.Type;
// item.Folder = inventoryFolderID;
// item.BasePermissions = 0x7fffffff;
// item.CurrentPermissions = 0x7fffffff;
// item.EveryOnePermissions = 0;
// item.NextPermissions = nextPerms;
// item.Flags = wearableType;
// item.CreationDate = Util.UnixTimeSinceEpoch();
// userInfo.AddItem(item);
// ourClient.SendInventoryItemCreateUpdate(item);
// }
// else
// {
// m_log.ErrorFormat(
// "[ASSET TRANSACTIONS]: Could not find user {0} for inventory item creation",
// ourClient.AgentId);
// }
//}
public void RequestUpdateTaskInventoryItem(
IClientAPI remoteClient, SceneObjectPart part, UUID transactionID, TaskInventoryItem item)
{
if (XferUploaders.ContainsKey(transactionID))
{
AssetBase asset = XferUploaders[transactionID].GetAssetData();
if (asset != null)
{
m_log.DebugFormat(
"[ASSET TRANSACTIONS]: Updating task item {0} in {1} with asset in transaction {2}",
item.Name, part.Name, transactionID);
asset.Name = item.Name;
asset.Description = item.Description;
asset.Type = (sbyte)item.Type;
item.AssetID = asset.FullID;
Manager.MyScene.CommsManager.AssetCache.AddAsset(asset);
if (part.Inventory.UpdateInventoryItem(item))
part.GetProperties(remoteClient);
}
}
}
public void RequestUpdateInventoryItem(IClientAPI remoteClient, UUID transactionID,
InventoryItemBase item)
{
if (XferUploaders.ContainsKey(transactionID))
{
CachedUserInfo userInfo = Manager.MyScene.CommsManager.UserProfileCacheService.GetUserDetails(
remoteClient.AgentId);
if (userInfo != null)
{
UUID assetID = UUID.Combine(transactionID, remoteClient.SecureSessionId);
AssetBase asset
= Manager.MyScene.CommsManager.AssetCache.GetAsset(
assetID, (item.AssetType == (int)AssetType.Texture ? true : false));
if (asset == null)
{
asset = GetTransactionAsset(transactionID);
}
if (asset != null && asset.FullID == assetID)
{
// Assets never get updated, new ones get created
asset.FullID = UUID.Random();
asset.Name = item.Name;
asset.Description = item.Description;
asset.Type = (sbyte)item.AssetType;
item.AssetID = asset.FullID;
Manager.MyScene.CommsManager.AssetCache.AddAsset(asset);
}
userInfo.UpdateItem(item);
}
else
{
m_log.ErrorFormat(
"[ASSET TRANSACTIONS]: Could not find user {0} for inventory item update",
remoteClient.AgentId);
}
}
}
} }
} }

221
OpenSim/Region/Environment/Modules/Agent/AssetTransaction/AssetTransactionModule.cs
View File

@ -42,7 +42,16 @@ namespace OpenSim.Region.Environment.Modules.Agent.AssetTransaction
private bool m_dumpAssetsToFile = false; private bool m_dumpAssetsToFile = false;
private Scene m_scene = null; private Scene m_scene = null;
private AgentAssetTransactionsManager m_transactionManager; public Scene MyScene
{
get{ return m_scene;}
}
/// <summary>
/// Each agent has its own singleton collection of transactions
/// </summary>
private Dictionary<UUID, AgentAssetTransactions> AgentTransactions =
new Dictionary<UUID, AgentAssetTransactions>();
public AssetTransactionModule() public AssetTransactionModule()
@ -50,40 +59,6 @@ namespace OpenSim.Region.Environment.Modules.Agent.AssetTransaction
// System.Console.WriteLine("creating AgentAssetTransactionModule"); // System.Console.WriteLine("creating AgentAssetTransactionModule");
} }
#region IAgentAssetTransactions Members
public void HandleItemCreationFromTransaction(IClientAPI remoteClient, UUID transactionID, UUID folderID,
uint callbackID, string description, string name, sbyte invType,
sbyte type, byte wearableType, uint nextOwnerMask)
{
m_transactionManager.HandleItemCreationFromTransaction(remoteClient, transactionID, folderID, callbackID, description, name, invType, type,
wearableType, nextOwnerMask);
}
public void HandleItemUpdateFromTransaction(IClientAPI remoteClient, UUID transactionID, InventoryItemBase item)
{
m_transactionManager.HandleItemUpdateFromTransaction(remoteClient, transactionID, item);
}
public void HandleTaskItemUpdateFromTransaction(
IClientAPI remoteClient, SceneObjectPart part, UUID transactionID, TaskInventoryItem item)
{
m_transactionManager.HandleTaskItemUpdateFromTransaction(remoteClient, part, transactionID, item);
}
public void RequestXferFromClient(IClientAPI remoteClient, UUID assetID, UUID transaction, sbyte type,
byte[] data, bool storeLocal, bool tempFile)
{
m_transactionManager.HandleUDPUploadRequest(remoteClient, assetID, transaction, type, data, storeLocal, tempFile);
}
public void RemoveAgentAssetTransactions(UUID userID)
{
m_transactionManager.RemoveAgentAssetTransactions(userID);
}
#endregion
#region IRegionModule Members #region IRegionModule Members
public void Initialise(Scene scene, IConfigSource config) public void Initialise(Scene scene, IConfigSource config)
@ -105,16 +80,13 @@ namespace OpenSim.Region.Environment.Modules.Agent.AssetTransaction
try try
{ {
m_dumpAssetsToFile = config.Configs["StandAlone"].GetBoolean("dump_assets_to_file", false); m_dumpAssetsToFile = config.Configs["StandAlone"].GetBoolean("dump_assets_to_file", false);
m_transactionManager = new AgentAssetTransactionsManager(m_scene, m_dumpAssetsToFile);
} }
catch (Exception) catch (Exception)
{ {
m_transactionManager = new AgentAssetTransactionsManager(m_scene, false);
} }
} }
else else
{ {
m_transactionManager = new AgentAssetTransactionsManager(m_scene, false);
} }
} }
} }
@ -141,8 +113,177 @@ namespace OpenSim.Region.Environment.Modules.Agent.AssetTransaction
public void NewClient(IClientAPI client) public void NewClient(IClientAPI client)
{ {
client.OnAssetUploadRequest += m_transactionManager.HandleUDPUploadRequest; client.OnAssetUploadRequest += HandleUDPUploadRequest;
client.OnXferReceive += m_transactionManager.HandleXfer; client.OnXferReceive += HandleXfer;
} }
#region AgentAssetTransactions
/// <summary>
/// Get the collection of asset transactions for the given user. If one does not already exist, it
/// is created.
/// </summary>
/// <param name="userID"></param>
/// <returns></returns>
private AgentAssetTransactions GetUserTransactions(UUID userID)
{
lock (AgentTransactions)
{
if (!AgentTransactions.ContainsKey(userID))
{
AgentAssetTransactions transactions = new AgentAssetTransactions(userID, this, m_dumpAssetsToFile);
AgentTransactions.Add(userID, transactions);
}
return AgentTransactions[userID];
}
}
/// <summary>
/// Remove the given agent asset transactions. This should be called when a client is departing
/// from a scene (and hence won't be making any more transactions here).
/// </summary>
/// <param name="userID"></param>
public void RemoveAgentAssetTransactions(UUID userID)
{
// m_log.DebugFormat("Removing agent asset transactions structure for agent {0}", userID);
lock (AgentTransactions)
{
AgentTransactions.Remove(userID);
}
}
/// <summary>
/// Create an inventory item from data that has been received through a transaction.
///
/// This is called when new clothing or body parts are created. It may also be called in other
/// situations.
/// </summary>
/// <param name="remoteClient"></param>
/// <param name="transactionID"></param>
/// <param name="folderID"></param>
/// <param name="callbackID"></param>
/// <param name="description"></param>
/// <param name="name"></param>
/// <param name="invType"></param>
/// <param name="type"></param>
/// <param name="wearableType"></param>
/// <param name="nextOwnerMask"></param>
public void HandleItemCreationFromTransaction(IClientAPI remoteClient, UUID transactionID, UUID folderID,
uint callbackID, string description, string name, sbyte invType,
sbyte type, byte wearableType, uint nextOwnerMask)
{
// m_log.DebugFormat(
// "[TRANSACTIONS MANAGER] Called HandleItemCreationFromTransaction with item {0}", name);
AgentAssetTransactions transactions = GetUserTransactions(remoteClient.AgentId);
transactions.RequestCreateInventoryItem(
remoteClient, transactionID, folderID, callbackID, description,
name, invType, type, wearableType, nextOwnerMask);
}
/// <summary>
/// Update an inventory item with data that has been received through a transaction.
///
/// This is called when clothing or body parts are updated (for instance, with new textures or
/// colours). It may also be called in other situations.
/// </summary>
/// <param name="remoteClient"></param>
/// <param name="transactionID"></param>
/// <param name="item"></param>
public void HandleItemUpdateFromTransaction(IClientAPI remoteClient, UUID transactionID,
InventoryItemBase item)
{
// m_log.DebugFormat(
// "[TRANSACTIONS MANAGER] Called HandleItemUpdateFromTransaction with item {0}",
// item.Name);
AgentAssetTransactions transactions = GetUserTransactions(remoteClient.AgentId);
transactions.RequestUpdateInventoryItem(remoteClient, transactionID, item);
}
/// <summary>
/// Update a task inventory item with data that has been received through a transaction.
///
/// This is currently called when, for instance, a notecard in a prim is saved. The data is sent
/// up through a single AssetUploadRequest. A subsequent UpdateTaskInventory then references the transaction
/// and comes through this method.
/// </summary>
/// <param name="remoteClient"></param>
/// <param name="transactionID"></param>
/// <param name="item"></param>
public void HandleTaskItemUpdateFromTransaction(
IClientAPI remoteClient, SceneObjectPart part, UUID transactionID, TaskInventoryItem item)
{
// m_log.DebugFormat(
// "[TRANSACTIONS MANAGER] Called HandleTaskItemUpdateFromTransaction with item {0}",
// item.Name);
AgentAssetTransactions transactions = GetUserTransactions(remoteClient.AgentId);
transactions.RequestUpdateTaskInventoryItem(remoteClient, part, transactionID, item);
}
/// <summary>
/// Request that a client (agent) begin an asset transfer.
/// </summary>
/// <param name="remoteClient"></param>
/// <param name="assetID"></param>
/// <param name="transaction"></param>
/// <param name="type"></param>
/// <param name="data"></param></param>
/// <param name="tempFile"></param>
public void HandleUDPUploadRequest(IClientAPI remoteClient, UUID assetID, UUID transaction, sbyte type,
byte[] data, bool storeLocal, bool tempFile)
{
//System.Console.WriteLine("HandleUDPUploadRequest - assetID: " + assetID.ToString() + " transaction: " + transaction.ToString() + " type: " + type.ToString() + " storelocal: " + storeLocal + " tempFile: " + tempFile);
if (((AssetType)type == AssetType.Texture ||
(AssetType)type == AssetType.Sound ||
(AssetType)type == AssetType.TextureTGA ||
(AssetType)type == AssetType.Animation) &&
tempFile == false)
{
Scene scene = (Scene)remoteClient.Scene;
IMoneyModule mm = scene.RequestModuleInterface<IMoneyModule>();
if (mm != null)
{
if (!mm.UploadCovered(remoteClient))
{
remoteClient.SendAgentAlertMessage("Unable to upload asset. Insufficient funds.", false);
return;
}
}
}
//Console.WriteLine("asset upload of " + assetID);
AgentAssetTransactions transactions = GetUserTransactions(remoteClient.AgentId);
AssetXferUploader uploader = transactions.RequestXferUploader(transaction);
if (uploader != null)
{
uploader.Initialise(remoteClient, assetID, transaction, type, data, storeLocal, tempFile);
}
}
/// <summary>
/// Handle asset transfer data packets received in response to the asset upload request in
/// HandleUDPUploadRequest()
/// </summary>
/// <param name="remoteClient"></param>
/// <param name="xferID"></param>
/// <param name="packetID"></param>
/// <param name="data"></param>
public void HandleXfer(IClientAPI remoteClient, ulong xferID, uint packetID, byte[] data)
{
//System.Console.WriteLine("xferID: " + xferID + " packetID: " + packetID + " data!");
AgentAssetTransactions transactions = GetUserTransactions(remoteClient.AgentId);
transactions.HandleXfer(xferID, packetID, data);
}
#endregion
} }
} }

68
OpenSim/Region/Environment/Modules/Agent/AssetTransaction/AssetXferUploader.cs
View File

@ -199,81 +199,21 @@ namespace OpenSim.Region.Environment.Modules.Agent.AssetTransaction
m_asset.Name = name; m_asset.Name = name;
m_asset.Description = description; m_asset.Description = description;
m_asset.Type = type; m_asset.Type = type;
m_createItem = true;
if (m_finished) if (m_finished)
{ {
DoCreateItem(); DoCreateItem();
} }
}
}
public void RequestUpdateInventoryItem(IClientAPI remoteClient, UUID transactionID,
InventoryItemBase item)
{
if (TransactionID == transactionID)
{
CachedUserInfo userInfo =
m_userTransactions.Manager.MyScene.CommsManager.UserProfileCacheService.GetUserDetails(
remoteClient.AgentId);
if (userInfo != null)
{
UUID assetID = UUID.Combine(transactionID, remoteClient.SecureSessionId);
AssetBase asset
= m_userTransactions.Manager.MyScene.CommsManager.AssetCache.GetAsset(
assetID, (item.AssetType == (int) AssetType.Texture ? true : false));
if (asset == null)
{
asset = m_userTransactions.GetTransactionAsset(transactionID);
}
if (asset != null && asset.FullID == assetID)
{
// Assets never get updated, new ones get created
asset.FullID = UUID.Random();
asset.Name = item.Name;
asset.Description = item.Description;
asset.Type = (sbyte) item.AssetType;
item.AssetID = asset.FullID;
m_userTransactions.Manager.MyScene.CommsManager.AssetCache.AddAsset(m_asset);
}
userInfo.UpdateItem(item);
}
else else
{ {
m_log.ErrorFormat( m_createItem = true; //set flag so the inventory item is created when upload is complete
"[ASSET TRANSACTIONS]: Could not find user {0} for inventory item update", }
remoteClient.AgentId);
}
} }
} }
public void RequestUpdateTaskInventoryItem(
IClientAPI remoteClient, SceneObjectPart part, UUID transactionID, TaskInventoryItem item)
{
m_log.DebugFormat(
"[ASSET TRANSACTIONS]: Updating task item {0} in {1} with asset in transaction {2}",
item.Name, part.Name, transactionID);
m_asset.Name = item.Name;
m_asset.Description = item.Description;
m_asset.Type = (sbyte) item.Type;
item.AssetID = m_asset.FullID;
m_userTransactions.Manager.MyScene.CommsManager.AssetCache.AddAsset(m_asset);
if (part.Inventory.UpdateInventoryItem(item))
part.GetProperties(remoteClient);
}
private void DoCreateItem() private void DoCreateItem()
{ {
//really need to fix this call, if lbsa71 saw this he would die.
m_userTransactions.Manager.MyScene.CommsManager.AssetCache.AddAsset(m_asset); m_userTransactions.Manager.MyScene.CommsManager.AssetCache.AddAsset(m_asset);
CachedUserInfo userInfo = CachedUserInfo userInfo =
m_userTransactions.Manager.MyScene.CommsManager.UserProfileCacheService.GetUserDetails( m_userTransactions.Manager.MyScene.CommsManager.UserProfileCacheService.GetUserDetails(

2
OpenSim/Region/ScriptEngine/Shared/Api/Implementation/OSSL_Api.cs
View File

@ -763,7 +763,7 @@ namespace OpenSim.Region.ScriptEngine.Shared.Api
// This gets very high because I have no idea what it does. // This gets very high because I have no idea what it does.
// If someone knows, please adjust. If it;s no longer needed, // If someone knows, please adjust. If it;s no longer needed,
// please remove. // please remove.
// //This sets the current time on a video. IE, it can be used to skip to a set time in the video. [MW]
CheckThreatLevel(ThreatLevel.VeryHigh, "osSetParcelMediaTime"); CheckThreatLevel(ThreatLevel.VeryHigh, "osSetParcelMediaTime");
m_host.AddScriptLPS(1); m_host.AddScriptLPS(1);