public void HandleXfer(IClientAPI client, ulong xferID, uint packetID, byte[] data)
{
AssetXferUploader foundUploader = null;
lock (XferUploaders)
{
foreach (AssetXferUploader uploader in XferUploaders.Values)
{
// MainConsole.Instance.DebugFormat(
// "[AGENT ASSETS TRANSACTIONS]: In HandleXfer, inspect xfer upload with xfer id {0}",
// uploader.XferID);
if (uploader.XferID == xferID)
{
foundUploader = uploader;
break;
}
}
}
if (foundUploader != null)
{
// MainConsole.Instance.DebugFormat(
// "[AGENT ASSETS TRANSACTIONS]: Found xfer uploader for xfer id {0}, packet id {1}, data length {2}",
// xferID, packetID, data.Length);
foundUploader.HandleXferPacket(xferID, packetID, data);
}
}
public void RequestUpdateInventoryItem(IClientAPI remoteClient,
UUID transactionID, InventoryItemBase item)
{
AssetXferUploader uploader = RequestXferUploader(transactionID);
uploader.RequestUpdateInventoryItem(remoteClient, item);
}
/// <summary>
/// Return the xfer uploader for the given transaction.
/// </summary>
/// <remarks>
/// If an uploader does not already exist for this transaction then it is created, otherwise the existing
/// uploader is returned.
/// </remarks>
/// <param name="transactionID"></param>
/// <returns>The asset xfer uploader</returns>
public AssetXferUploader RequestXferUploader(UUID transactionID)
{
AssetXferUploader uploader;
lock (XferUploaders)
{
if (!XferUploaders.ContainsKey(transactionID))
{
uploader = new AssetXferUploader(this, m_Scene, transactionID, m_dumpAssetsToFile);
// MainConsole.Instance.DebugFormat(
// "[AGENT ASSETS TRANSACTIONS]: Adding asset xfer uploader {0} since it didn't previously exist", transactionID);
XferUploaders.Add(transactionID, uploader);
}
else
{
uploader = XferUploaders[transactionID];
}
}
IMonitorModule monitorModule = m_Scene.RequestModuleInterface <IMonitorModule>();
if (monitorModule != null)
{
INetworkMonitor networkMonitor = monitorModule.GetMonitor <INetworkMonitor>(m_Scene);
networkMonitor.AddPendingUploads(1);
}
return(uploader);
}
/// <summary>
/// Return the xfer uploader for the given transaction.
/// </summary>
/// <remarks>
/// If an uploader does not already exist for this transaction then it is created, otherwise the existing
/// uploader is returned.
/// </remarks>
/// <param name="transactionID"></param>
/// <returns>The asset xfer uploader</returns>
public AssetXferUploader RequestXferUploader(UUID transactionID)
{
AssetXferUploader uploader;
lock (XferUploaders)
{
if (!XferUploaders.ContainsKey(transactionID))
{
uploader = new AssetXferUploader(this, m_Scene, transactionID, m_dumpAssetsToFile);
// MainConsole.Instance.DebugFormat(
// "[AGENT ASSETS TRANSACTIONS]: Adding asset xfer uploader {0} since it didn't previously exist", transactionID);
XferUploaders.Add(transactionID, uploader);
}
else
{
uploader = XferUploaders[transactionID];
}
}
IMonitorModule monitorModule = m_Scene.RequestModuleInterface<IMonitorModule>();
if (monitorModule != null)
{
INetworkMonitor networkMonitor = monitorModule.GetMonitor<INetworkMonitor>();
networkMonitor.AddPendingUploads(1);
}
return uploader;
}
/// <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 name="storeLocal"></param>
/// <param name="tempFile"></param>
public void HandleUDPUploadRequest(IClientAPI remoteClient, UUID assetID, UUID transaction, sbyte type,
byte[] data, bool storeLocal, bool tempFile)
{
// MainConsole.Instance.Debug("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)
{
IScene scene = remoteClient.Scene;
IMoneyModule mm = scene.RequestModuleInterface <IMoneyModule>();
if (mm != null)
{
if (!mm.Charge(remoteClient.AgentId, mm.UploadCharge, "", TransactionType.UploadCharge))
{
remoteClient.SendAgentAlertMessage("Unable to upload asset. Insufficient funds.", false);
return;
}
}
}
AgentAssetTransactions transactions = GetUserTransactions(remoteClient.AgentId);
AssetXferUploader uploader = transactions.RequestXferUploader(transaction);
if (uploader != null)
{
uploader.StartUpload(remoteClient, assetID, transaction, type, data, storeLocal, tempFile);
}
}
public void RequestUpdateTaskInventoryItem(IClientAPI remoteClient,
ISceneChildEntity part, UUID transactionID,
TaskInventoryItem item)
{
AssetXferUploader uploader = RequestXferUploader(transactionID);
uploader.RequestUpdateTaskInventoryItem(remoteClient, item);
}
public void RequestCreateInventoryItem(IClientAPI remoteClient,
UUID transactionID, UUID folderID, uint callbackID,
string description, string name, sbyte invType,
sbyte type, byte wearableType, uint nextOwnerMask)
{
AssetXferUploader uploader = RequestXferUploader(transactionID);
uploader.RequestCreateInventoryItem(
remoteClient, folderID, callbackID,
description, name, invType, type, wearableType, nextOwnerMask);
}
public AssetXferUploader RequestXferUploader(UUID transactionID)
{
if (!XferUploaders.ContainsKey(transactionID))
{
AssetXferUploader uploader = new AssetXferUploader(this);
lock (XferUploaders)
{
XferUploaders.Add(transactionID, uploader);
}
return(uploader);
}
return(null);
}
public AssetXferUploader RequestXferUploader(UUID transactionID)
{
if (!XferUploaders.ContainsKey(transactionID))
{
AssetXferUploader uploader = new AssetXferUploader(this);
lock (XferUploaders)
{
XferUploaders.Add(transactionID, uploader);
}
return uploader;
}
return null;
}
/// <summary>
/// Get an uploaded asset. If the data is successfully retrieved, the transaction will be removed.
/// </summary>
/// <param name = "transactionID"></param>
/// <returns>The asset if the upload has completed, null if it has not.</returns>
public AssetBase GetTransactionAsset(UUID transactionID)
{
if (XferUploaders.ContainsKey(transactionID))
{
AssetXferUploader uploader = XferUploaders[transactionID];
AssetBase asset = uploader.GetAssetData();
lock (XferUploaders)
{
XferUploaders.Remove(transactionID);
}
return(asset);
}
return(null);
}
public void RequestUpdateInventoryItem(IClientAPI remoteClient, UUID transactionID,
InventoryItemBase item)
{
if (XferUploaders.ContainsKey(transactionID))
{
UUID assetID = UUID.Combine(transactionID, remoteClient.SecureSessionId);
AssetXferUploader uploader = XferUploaders[transactionID];
if (!uploader.Finished)
{
uploader.FinishedEvent = () =>
UpdateInventoryItemWithAsset(item, assetID, transactionID);
return;
}
UpdateInventoryItemWithAsset(item, assetID, transactionID);
}
}
private void UpdateInventoryItemWithAsset(InventoryItemBase item, UUID assetID, UUID transactionID)
{
AssetXferUploader uploader = XferUploaders[transactionID];
AssetBase asset = uploader.GetAssetData();
if (asset != null && asset.ID == assetID)
{
// Assets never get updated, new ones get created
asset.ID = UUID.Random();
asset.Name = item.Name;
asset.Description = item.Description;
asset.Type = (sbyte)item.AssetType;
item.AssetID = asset.ID;
asset.ID = Manager.MyScene.AssetService.Store(asset);
item.AssetID = asset.ID;
XferUploaders.Remove(transactionID);
}
else
{
return;
}
IMonitorModule monitorModule = Manager.MyScene.RequestModuleInterface <IMonitorModule>();
if (monitorModule != null)
{
INetworkMonitor networkMonitor =
(INetworkMonitor)
monitorModule.GetMonitor(Manager.MyScene.RegionInfo.RegionID.ToString(),
MonitorModuleHelper.NetworkMonitor);
networkMonitor.AddPendingUploads(-1);
}
IInventoryService invService = Manager.MyScene.InventoryService;
invService.UpdateItem(item);
}
/// <summary>
/// Return the xfer uploader for the given transaction.
/// </summary>
/// <remarks>
/// If an uploader does not already exist for this transaction then it is created, otherwise the existing
/// uploader is returned.
/// </remarks>
/// <param name="transactionID"></param>
/// <returns>The asset xfer uploader</returns>
public AssetXferUploader RequestXferUploader(UUID transactionID)
{
AssetXferUploader uploader;
lock (XferUploaders)
{
if (!XferUploaders.ContainsKey(transactionID))
{
uploader = new AssetXferUploader(this, m_Scene, transactionID, m_dumpAssetsToFile);
// m_log.DebugFormat(
// "[AGENT ASSETS TRANSACTIONS]: Adding asset xfer uploader {0} since it didn't previously exist", transactionID);
XferUploaders.Add(transactionID, uploader);
}
else
{
uploader = XferUploaders[transactionID];
}
}
return uploader;
}
