/*
* 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.IO;
using System.Threading;
using libsecondlife;
using libsecondlife.Packets;
using OpenSim.Framework.Console;
namespace OpenSim.Framework.Communications.Cache
{
public delegate void DownloadComplete(AssetCache.TextureSender sender);
public delegate void AssetRequestCallback(LLUUID assetID, AssetBase asset);
///
/// Manages local cache of assets and their sending to viewers.
///
public class AssetCache : IAssetReceiver
{
public Dictionary Assets;
public Dictionary Textures;
public List AssetRequests = new List(); //assets ready to be sent to viewers
public List TextureRequests = new List(); //textures ready to be sent
public Dictionary RequestedAssets = new Dictionary();
//Assets requested from the asset server
public Dictionary RequestedTextures = new Dictionary();
//Textures requested from the asset server
public Dictionary SendingTextures = new Dictionary();
private BlockingQueue QueueTextures = new BlockingQueue();
private Dictionary> AvatarRecievedTextures = new Dictionary>();
private Dictionary> TimesTextureSent =
new Dictionary>();
public Dictionary RequestLists = new Dictionary();
private IAssetServer _assetServer;
private Thread _assetCacheThread;
private Thread TextureSenderThread;
///
///
///
public AssetCache(IAssetServer assetServer)
{
MainLog.Instance.Verbose("ASSETSTORAGE", "Creating Asset cache");
_assetServer = assetServer;
_assetServer.SetReceiver(this);
Assets = new Dictionary();
Textures = new Dictionary();
_assetCacheThread = new Thread(new ThreadStart(RunAssetManager));
_assetCacheThread.IsBackground = true;
_assetCacheThread.Start();
TextureSenderThread = new Thread(new ThreadStart(ProcessTextureSenders));
TextureSenderThread.IsBackground = true;
TextureSenderThread.Start();
}
///
///
///
public void RunAssetManager()
{
while (true)
{
try
{
ProcessAssetQueue();
ProcessTextureQueue();
Thread.Sleep(500);
}
catch (Exception e)
{
System.Console.WriteLine(e.Message + " : " + e.StackTrace);
}
}
}
public AssetBase GetAsset(LLUUID assetID)
{
AssetBase asset = null;
if (Textures.ContainsKey(assetID))
{
asset = Textures[assetID];
}
else if (Assets.ContainsKey(assetID))
{
asset = Assets[assetID];
}
return asset;
}
public void GetAsset(LLUUID assetID, AssetRequestCallback callback)
{
AssetBase asset = null;
if (Textures.ContainsKey(assetID))
{
asset = Textures[assetID];
}
else if (Assets.ContainsKey(assetID))
{
asset = Assets[assetID];
}
if (asset != null)
{
callback(assetID, asset);
}
else
{
NewAssetRequest req = new NewAssetRequest(assetID, callback);
if (RequestLists.ContainsKey(assetID))
{
lock (RequestLists)
{
RequestLists[assetID].Requests.Add(req);
}
}
else
{
AssetRequestsList reqList = new AssetRequestsList(assetID);
reqList.Requests.Add(req);
lock (RequestLists)
{
RequestLists.Add(assetID, reqList);
}
}
_assetServer.RequestAsset(assetID, false);
}
}
public AssetBase GetAsset(LLUUID assetID, bool isTexture)
{
AssetBase asset = GetAsset(assetID);
if (asset == null)
{
_assetServer.RequestAsset(assetID, isTexture);
}
return asset;
}
public void AddAsset(AssetBase asset)
{
//System.Console.WriteLine("adding asset " + asset.FullID.ToStringHyphenated());
if (asset.Type == 0)
{
//Console.WriteLine("which is a texture");
if (!Textures.ContainsKey(asset.FullID))
{
//texture
TextureImage textur = new TextureImage(asset);
Textures.Add(textur.FullID, textur);
if (!asset.Temporary)
_assetServer.StoreAndCommitAsset(asset);
}
else
{
TextureImage textur = new TextureImage(asset);
Textures[asset.FullID] = textur;
}
}
else
{
if (!Assets.ContainsKey(asset.FullID))
{
AssetInfo assetInf = new AssetInfo(asset);
Assets.Add(assetInf.FullID, assetInf);
if (!asset.Temporary)
_assetServer.StoreAndCommitAsset(asset);
}
}
}
public void DeleteAsset(LLUUID assetID)
{
// this._assetServer.DeleteAsset(assetID);
//Todo should delete it from memory too
}
///
///
///
private void ProcessTextureQueue()
{
if (TextureRequests.Count == 0)
{
//no requests waiting
return;
}
int num;
num = TextureRequests.Count;
AssetRequest req;
for (int i = 0; i < num; i++)
{
req = (AssetRequest) TextureRequests[i];
if (!SendingTextures.ContainsKey(req.ImageInfo.FullID))
{
//Console.WriteLine("new texture to send");
TextureSender sender = new TextureSender(req);
//sender.OnComplete += this.TextureSent;
SendingTextures.Add(req.ImageInfo.FullID, sender);
QueueTextures.Enqueue(sender);
}
}
TextureRequests.Clear();
}
public void ProcessTextureSenders()
{
while (true)
{
TextureSender sender = QueueTextures.Dequeue();
bool finished = sender.SendTexture();
if (finished)
{
TextureSent(sender);
}
else
{
// Console.WriteLine("readding texture");
QueueTextures.Enqueue(sender);
}
}
}
///
/// Event handler, called by a TextureSender object to say that texture has been sent
///
///
public void TextureSent(TextureSender sender)
{
if (SendingTextures.ContainsKey(sender.request.ImageInfo.FullID))
{
SendingTextures.Remove(sender.request.ImageInfo.FullID);
// this.AvatarRecievedTextures[sender.request.RequestUser.AgentId].Add(sender.request.ImageInfo.FullID);
}
}
public void AssetReceived(AssetBase asset, bool IsTexture)
{
if (asset.FullID != LLUUID.Zero) // if it is set to zero then the asset wasn't found by the server
{
//check if it is a texture or not
//then add to the correct cache list
//then check for waiting requests for this asset/texture (in the Requested lists)
//and move those requests into the Requests list.
if (IsTexture)
{
//Console.WriteLine("asset recieved from asset server");
TextureImage image = new TextureImage(asset);
if (!Textures.ContainsKey(image.FullID))
{
Textures.Add(image.FullID, image);
if (RequestedTextures.ContainsKey(image.FullID))
{
AssetRequest req = RequestedTextures[image.FullID];
req.ImageInfo = image;
if (image.Data.LongLength > 600)
{
//over 600 bytes so split up file
req.NumPackets = 1 + (int) (image.Data.Length - 600)/1000;
}
else
{
req.NumPackets = 1;
}
RequestedTextures.Remove(image.FullID);
TextureRequests.Add(req);
}
}
}
else
{
AssetInfo assetInf = new AssetInfo(asset);
if (!Assets.ContainsKey(assetInf.FullID))
{
Assets.Add(assetInf.FullID, assetInf);
if (RequestedAssets.ContainsKey(assetInf.FullID))
{
AssetRequest req = RequestedAssets[assetInf.FullID];
req.AssetInf = assetInf;
if (assetInf.Data.LongLength > 600)
{
//over 600 bytes so split up file
req.NumPackets = 1 + (int) (assetInf.Data.Length - 600 + 999)/1000;
}
else
{
req.NumPackets = 1;
}
RequestedAssets.Remove(assetInf.FullID);
AssetRequests.Add(req);
}
}
}
if (RequestLists.ContainsKey(asset.FullID))
{
AssetRequestsList reqList = RequestLists[asset.FullID];
foreach (NewAssetRequest req in reqList.Requests)
{
req.Callback(asset.FullID, asset);
}
lock (RequestLists)
{
RequestLists.Remove(asset.FullID);
reqList.Requests.Clear();
}
}
}
}
public void AssetNotFound(LLUUID assetID)
{
//if (this.RequestedTextures.ContainsKey(assetID))
//{
// MainLog.Instance.Warn("ASSET CACHE", "sending image not found for {0}", assetID);
// AssetRequest req = this.RequestedTextures[assetID];
// ImageNotInDatabasePacket notFound = new ImageNotInDatabasePacket();
// notFound.ImageID.ID = assetID;
// req.RequestUser.OutPacket(notFound);
// this.RequestedTextures.Remove(assetID);
//}
//else
//{
// MainLog.Instance.Error("ASSET CACHE", "Cound not send image not found for {0}", assetID);
//}
}
#region Assets
///
///
///
///
///
public void AddAssetRequest(IClientAPI userInfo, TransferRequestPacket transferRequest)
{
LLUUID requestID = null;
byte source = 2;
if (transferRequest.TransferInfo.SourceType == 2)
{
//direct asset request
requestID = new LLUUID(transferRequest.TransferInfo.Params, 0);
}
else if (transferRequest.TransferInfo.SourceType == 3)
{
//inventory asset request
requestID = new LLUUID(transferRequest.TransferInfo.Params, 80);
source = 3;
//Console.WriteLine("asset request " + requestID);
}
//check to see if asset is in local cache, if not we need to request it from asset server.
//Console.WriteLine("asset request " + requestID);
if (!Assets.ContainsKey(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);
_assetServer.RequestAsset(requestID, false);
}
return;
}
//it is in our cache
AssetInfo asset = Assets[requestID];
//work out how many packets it should be sent in
// and add 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 = asset;
if (asset.Data.LongLength > 600)
{
//over 600 bytes so split up file
req.NumPackets = 1 + (int) (asset.Data.Length - 600 + 999)/1000;
}
else
{
req.NumPackets = 1;
}
AssetRequests.Add(req);
}
///
///
///
private void ProcessAssetQueue()
{
if (AssetRequests.Count == 0)
{
//no requests waiting
return;
}
int num;
if (AssetRequests.Count < 5)
{
//lower than 5 so do all of them
num = AssetRequests.Count;
}
else
{
num = 5;
}
AssetRequest req;
for (int i = 0; i < num; i++)
{
req = (AssetRequest) AssetRequests[i];
//Console.WriteLine("sending asset " + req.RequestAssetID);
TransferInfoPacket Transfer = new TransferInfoPacket();
Transfer.TransferInfo.ChannelType = 2;
Transfer.TransferInfo.Status = 0;
Transfer.TransferInfo.TargetType = 0;
if (req.AssetRequestSource == 2)
{
Transfer.TransferInfo.Params = new byte[20];
Array.Copy(req.RequestAssetID.GetBytes(), 0, Transfer.TransferInfo.Params, 0, 16);
int assType = (int) req.AssetInf.Type;
Array.Copy(Helpers.IntToBytes(assType), 0, Transfer.TransferInfo.Params, 16, 4);
}
else if (req.AssetRequestSource == 3)
{
Transfer.TransferInfo.Params = req.Params;
// Transfer.TransferInfo.Params = new byte[100];
//Array.Copy(req.RequestUser.AgentId.GetBytes(), 0, Transfer.TransferInfo.Params, 0, 16);
//Array.Copy(req.RequestUser.SessionId.GetBytes(), 0, Transfer.TransferInfo.Params, 16, 16);
}
Transfer.TransferInfo.Size = (int) req.AssetInf.Data.Length;
Transfer.TransferInfo.TransferID = req.TransferRequestID;
req.RequestUser.OutPacket(Transfer);
if (req.NumPackets == 1)
{
TransferPacketPacket TransferPacket = new TransferPacketPacket();
TransferPacket.TransferData.Packet = 0;
TransferPacket.TransferData.ChannelType = 2;
TransferPacket.TransferData.TransferID = req.TransferRequestID;
TransferPacket.TransferData.Data = req.AssetInf.Data;
TransferPacket.TransferData.Status = 1;
req.RequestUser.OutPacket(TransferPacket);
}
else
{
//more than one packet so split file up , for now it can't be bigger than 2000 bytes
TransferPacketPacket TransferPacket = new TransferPacketPacket();
TransferPacket.TransferData.Packet = 0;
TransferPacket.TransferData.ChannelType = 2;
TransferPacket.TransferData.TransferID = req.TransferRequestID;
byte[] chunk = null;
if (req.AssetInf.Data.Length <= 1000)
{
chunk = new byte[req.AssetInf.Data.Length];
Array.Copy(req.AssetInf.Data, chunk, req.AssetInf.Data.Length);
TransferPacket.TransferData.Data = chunk;
TransferPacket.TransferData.Status = 1;
req.RequestUser.OutPacket(TransferPacket);
}
else
{
chunk = new byte[1000];
Array.Copy(req.AssetInf.Data, chunk, 1000);
TransferPacket.TransferData.Data = chunk;
TransferPacket.TransferData.Status = 0;
req.RequestUser.OutPacket(TransferPacket);
TransferPacket = new TransferPacketPacket();
TransferPacket.TransferData.Packet = 1;
TransferPacket.TransferData.ChannelType = 2;
TransferPacket.TransferData.TransferID = req.TransferRequestID;
byte[] chunk1 = new byte[(req.AssetInf.Data.Length - 1000)];
Array.Copy(req.AssetInf.Data, 1000, chunk1, 0, chunk1.Length);
TransferPacket.TransferData.Data = chunk1;
TransferPacket.TransferData.Status = 1;
req.RequestUser.OutPacket(TransferPacket);
}
}
}
//remove requests that have been completed
for (int i = 0; i < num; i++)
{
AssetRequests.RemoveAt(0);
}
}
#endregion
#region Textures
///
///
///
///
///
public void AddTextureRequest(IClientAPI userInfo, LLUUID imageID, uint packetNumber, int discard)
{
// System.Console.WriteLine("texture request for " + imageID.ToStringHyphenated() + " packetnumber= " + packetNumber);
//check to see if texture is in local cache, if not request from asset server
if (!AvatarRecievedTextures.ContainsKey(userInfo.AgentId))
{
AvatarRecievedTextures.Add(userInfo.AgentId, new List());
}
/* if(this.AvatarRecievedTextures[userInfo.AgentId].Contains(imageID))
{
//Console.WriteLine(userInfo.AgentId +" is requesting a image( "+ imageID+" that has already been sent to them");
return;
}*/
if (!Textures.ContainsKey(imageID))
{
if (!RequestedTextures.ContainsKey(imageID))
{
//not is cache so request from asset server
AssetRequest request = new AssetRequest();
request.RequestUser = userInfo;
request.RequestAssetID = imageID;
request.IsTextureRequest = true;
request.DiscardLevel = discard;
RequestedTextures.Add(imageID, request);
_assetServer.RequestAsset(imageID, true);
}
return;
}
// System.Console.WriteLine("texture already in cache");
TextureImage imag = Textures[imageID];
AssetRequest req = new AssetRequest();
req.RequestUser = userInfo;
req.RequestAssetID = imageID;
req.IsTextureRequest = true;
req.ImageInfo = imag;
req.DiscardLevel = discard;
if (imag.Data.LongLength > 600)
{
//Console.WriteLine("{0}", imag.Data.LongLength);
//over 600 bytes so split up file
req.NumPackets = 2 + (int) (imag.Data.Length - 601)/1000;
//Console.WriteLine("texture is " + imag.Data.Length + " which we will send in " +req.NumPackets +" packets");
}
else
{
req.NumPackets = 1;
}
if (packetNumber != 0)
{
req.PacketCounter = (int) packetNumber;
}
TextureRequests.Add(req);
}
#endregion
public class AssetRequest
{
public IClientAPI RequestUser;
public LLUUID RequestAssetID;
public AssetInfo AssetInf;
public TextureImage ImageInfo;
public LLUUID 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 AssetRequest()
{
}
}
public class AssetInfo : AssetBase
{
public AssetInfo()
{
}
public AssetInfo(AssetBase aBase)
{
Data = aBase.Data;
FullID = aBase.FullID;
Type = aBase.Type;
InvType = aBase.InvType;
Name = aBase.Name;
Description = aBase.Description;
}
}
public class TextureImage : AssetBase
{
public TextureImage()
{
}
public TextureImage(AssetBase aBase)
{
Data = aBase.Data;
FullID = aBase.FullID;
Type = aBase.Type;
InvType = aBase.InvType;
Name = aBase.Name;
Description = aBase.Description;
}
}
public class TextureSender
{
public AssetRequest request;
private int counter = 0;
public TextureSender(AssetRequest req)
{
request = req;
}
public bool SendTexture()
{
SendPacket();
counter++;
if ((request.PacketCounter >= request.NumPackets) || counter > 100 || (request.NumPackets == 1) ||
(request.DiscardLevel == -1))
{
return true;
}
return false;
}
public void SendPacket()
{
AssetRequest req = request;
//Console.WriteLine("sending " + req.ImageInfo.FullID);
if (req.PacketCounter == 0)
{
//first time for this request so send imagedata packet
if (req.NumPackets == 1)
{
//Console.WriteLine("only one packet so send whole file");
ImageDataPacket im = new ImageDataPacket();
im.Header.Reliable = false;
im.ImageID.Packets = 1;
im.ImageID.ID = req.ImageInfo.FullID;
im.ImageID.Size = (uint) req.ImageInfo.Data.Length;
im.ImageData.Data = req.ImageInfo.Data;
im.ImageID.Codec = 2;
req.RequestUser.OutPacket(im);
req.PacketCounter++;
//req.ImageInfo.l= time;
//System.Console.WriteLine("sent texture: " + req.ImageInfo.FullID);
//Console.WriteLine("sending single packet for " + req.ImageInfo.FullID.ToStringHyphenated());
}
else
{
//more than one packet so split file up
ImageDataPacket im = new ImageDataPacket();
im.Header.Reliable = false;
im.ImageID.Packets = (ushort) (req.NumPackets);
im.ImageID.ID = req.ImageInfo.FullID;
im.ImageID.Size = (uint) req.ImageInfo.Data.Length;
im.ImageData.Data = new byte[600];
Array.Copy(req.ImageInfo.Data, 0, im.ImageData.Data, 0, 600);
im.ImageID.Codec = 2;
req.RequestUser.OutPacket(im);
req.PacketCounter++;
//req.ImageInfo.last_used = time;
//System.Console.WriteLine("sent first packet of texture: " + req.ImageInfo.FullID);
//Console.WriteLine("sending packet 1 for " + req.ImageInfo.FullID.ToStringHyphenated());
}
}
else
{
//Console.WriteLine("sending packet " + req.PacketCounter + " for " + req.ImageInfo.FullID.ToStringHyphenated());
//send imagepacket
//more than one packet so split file up
ImagePacketPacket im = new ImagePacketPacket();
im.Header.Reliable = false;
im.ImageID.Packet = (ushort) (req.PacketCounter);
im.ImageID.ID = req.ImageInfo.FullID;
int size = req.ImageInfo.Data.Length - 600 - (1000*(req.PacketCounter - 1));
if (size > 1000) size = 1000;
//Console.WriteLine("length= {0} counter= {1} size= {2}",req.ImageInfo.Data.Length, req.PacketCounter, size);
im.ImageData.Data = new byte[size];
Array.Copy(req.ImageInfo.Data, 600 + (1000*(req.PacketCounter - 1)), im.ImageData.Data, 0, size);
req.RequestUser.OutPacket(im);
req.PacketCounter++;
//req.ImageInfo.last_used = time;
//System.Console.WriteLine("sent a packet of texture: "+req.ImageInfo.FullID);
}
}
private void SaveAssetToFile(string filename, byte[] data)
{
FileStream fs = File.Create(filename);
BinaryWriter bw = new BinaryWriter(fs);
bw.Write(data);
bw.Close();
fs.Close();
}
}
}
public class AssetRequestsList
{
public LLUUID AssetID;
public List Requests = new List();
public AssetRequestsList(LLUUID assetID)
{
AssetID = assetID;
}
}
public class NewAssetRequest
{
public LLUUID AssetID;
public AssetRequestCallback Callback;
public NewAssetRequest(LLUUID assetID, AssetRequestCallback callback)
{
AssetID = assetID;
Callback = callback;
}
}
}