private void HandleAssetReceived(UUID assetId, AssetBase asset, AssetRequestInfo reqInfo)
{
// This must be done before the IsAssetRetrievalAllowed check which can turn it to null.
if (asset == null)
this.StampNegativeCache(reqInfo.AssetId);
else
this.RemoveFromNegativeCache(reqInfo.AssetId);
if (this.IsAssetRetrievalAllowed(asset, reqInfo))
{
reqInfo.Callback(assetId, asset);
}
else
{
reqInfo.Callback(assetId, null);
}
}
public virtual void AssetError(UUID assetId, Exception e, AssetRequestInfo reqInfo)
{
m_log.WarnFormat("[ASSET CACHE]: Error while retrieving asset {0}: {1}", assetId, e.Message);
this.StartAssetReceived(assetId, null, reqInfo);
}
private void StartAssetReceived(UUID uUID, AssetBase asset, AssetRequestInfo reqInfo)
{
_pool.QueueWorkItem(
new Action<UUID, AssetBase, AssetRequestInfo>(HandleAssetReceived),
uUID, asset, reqInfo);
}
// See IAssetReceiver
public virtual void AssetReceived(AssetBase asset, AssetRequestInfo rdata)
{
StatsManager.SimExtraStats.AddAssetRequestTime((long)rdata.RequestDuration);
this.RemoveFromNegativeCache(asset.FullID);
this.StartAssetReceived(asset.FullID, asset, rdata);
}
// See IAssetReceiver
public virtual void AssetNotFound(UUID assetId, AssetRequestInfo reqInfo)
{
// m_log.WarnFormat("[ASSET CACHE]: AssetNotFound or transfer otherwise blocked for {0}", assetId);
this.StampNegativeCache(assetId);
this.StartAssetReceived(assetId, null, reqInfo);
}
public void SendAsset(AssetBase asset, AssetRequestInfo req)
{
}
//see IAssetReceiver
public void AssetReceived(AssetBase asset, AssetRequestInfo data)
{
_assetReceiver.AssetReceived(asset, data);
}
private bool IsAssetRetrievalAllowed(AssetBase asset, AssetRequestInfo requestInfo)
{
if (asset == null)
{
return true;
}
//do not pass back object assets to the net
if (asset.Type == (sbyte)AssetType.Object &&
requestInfo.Origin == AssetRequestInfo.RequestOrigin.SRC_NET)
{
m_log.WarnFormat("Not allowing access to OBJECT asset {0} from SRC_NET", requestInfo.AssetId);
return false;
}
//dont pass back full script text via LLSTS_ASSET
if ((asset.Type == (sbyte)AssetType.LSLText || asset.Type == (sbyte)AssetType.Notecard) &&
requestInfo.Origin == AssetRequestInfo.RequestOrigin.SRC_NET &&
(requestInfo.NetSource != AssetRequestInfo.NetSourceType.LLTST_SIM_INV_ITEM &&
requestInfo.NetSource != AssetRequestInfo.NetSourceType.LLTST_SIM_ESTATE))
{
m_log.WarnFormat("Not allowing access to LSLText or asset {0} from SRC_NET and LLTST_ASSET", requestInfo.AssetId);
return false;
}
return true;
}
public AssetBase GetAsset(UUID assetID, AssetRequestInfo reqInfo)
{
// This function returns true if it's cached as a null and not expired.
if (IsNegativeCached(assetID))
return null;
// Else, we need to fetch the asset.
reqInfo.AssetId = assetID;
AssetBase asset = m_assetServer.RequestAssetSync(assetID);
if (asset == null)
StampNegativeCache(assetID);
if (this.IsAssetRetrievalAllowed(asset, reqInfo))
{
StatsManager.SimExtraStats.AddAssetRequestTime((long)reqInfo.RequestDuration);
return asset;
}
return null;
}
public void RequestAsset(OpenMetaverse.UUID assetID, AssetRequestInfo args)
{
try
{
_readWhipServer.GetAssetAsync(assetID.ToString(),
delegate(Asset asset, AssetServerError e)
{
if (e == null)
{
//no error, pass asset to caller
_receiver.AssetReceived(WhipAssetToOpensim(asset), args);
}
else
{
string errorString = e.ToString();
if (!errorString.Contains("not found"))
{
//there is an error, log it, and then tell the caller we have no asset to give
_log.ErrorFormat(
"[WHIP.AssetClient]: Failure fetching asset {0}" + Environment.NewLine + errorString
+ Environment.NewLine, assetID);
}
_receiver.AssetNotFound(assetID, args);
}
}
);
}
catch (AssetServerError e)
{
//there is an error, log it, and then tell the caller we have no asset to give
string errorString = e.ToString();
if (!errorString.Contains("not found"))
{
_log.ErrorFormat(
"[WHIP.AssetClient]: Failure fetching asset {0}" + Environment.NewLine + errorString
+ Environment.NewLine, assetID);
}
_receiver.AssetNotFound(assetID, args);
}
}
public void GetAsset(UUID assetId, AssetRequestCallback callback, AssetRequestInfo requestInfo)
{
requestInfo.AssetId = assetId;
requestInfo.Callback = callback;
if (IsNegativeCached(assetId))
callback(assetId, null);
else
m_assetServer.RequestAsset(assetId, requestInfo);
}
public void HandleAssetCallback(OpenMetaverse.UUID assetID, AssetRequestInfo data, Exception error)
{
//if not found and this is the first try, try the second server
if (_secondReadServer != null && data.ServerNumber == 0)
{
data.ServerNumber++;
_secondReadServer.RequestAsset(assetID, data);
}
else
{
if (error == null)
{
_assetReceiver.AssetNotFound(assetID, data);
}
else
{
_assetReceiver.AssetError(assetID, error, data);
}
}
}
public void AssetError(OpenMetaverse.UUID assetID, Exception error, AssetRequestInfo data)
{
m_log.ErrorFormat("[InWorldz.Stratus]: Error while requesting asset {0}: {1}", assetID, error);
this.HandleAssetCallback(assetID, data, error);
}
//see IAssetReceiver
public void AssetNotFound(OpenMetaverse.UUID assetID, AssetRequestInfo data)
{
this.HandleAssetCallback(assetID, data, null);
}
public void AddAssetRequest(IClientAPI userInfo, TransferRequestPacket transferRequest)
{
AssetRequestInfo reqInfo = new AssetRequestInfo(transferRequest, userInfo);
reqInfo.Callback =
delegate(UUID assetId, AssetBase asset)
{
this.ProcessDirectAssetRequest(userInfo, asset, reqInfo);
};
m_assetServer.RequestAsset(reqInfo.AssetId, reqInfo);
}
private bool IsAssetStorageAllowed(AssetBase asset, AssetRequestInfo requestInfo)
{
if (asset == null)
{
return false;
}
//do not accept object assets from the net
if (asset.Type == (sbyte)AssetType.Object &&
requestInfo.Origin == AssetRequestInfo.RequestOrigin.SRC_NET)
{
return false;
}
return true;
}
/// <summary>
/// Process the asset queue which sends packets directly back to the client.
/// </summary>
private void ProcessDirectAssetRequest(IClientAPI userInfo, AssetBase asset, AssetRequestInfo req)
{
userInfo.SendAsset(asset, req);
}
public void AddAsset(AssetBase asset, AssetRequestInfo requestInfo)
{
requestInfo.AssetId = asset.FullID;
if (this.IsAssetStorageAllowed(asset, requestInfo))
{
ulong startTime = Util.GetLongTickCount();
try
{
RemoveFromNegativeCache(asset.FullID);
m_assetServer.StoreAsset(asset);
}
catch (AssetAlreadyExistsException e)
{
//Don't rethrow this exception. AssetServerExceptions thrown from here
//will trigger a message on the client
m_log.WarnFormat("[ASSET CACHE] Not storing asset that already exists: {0}", e.Message);
}
StatsManager.SimExtraStats.AddAssetWriteTime((long)(Util.GetLongTickCount() - startTime));
}
else
{
throw new NotSupportedException(String.Format("Not allowing asset storage ID:{0} Type:{1} Source:{2}",
asset.ID, asset.Type, requestInfo.Origin));
}
//we will save the local asset issue for later as its confusing as hell and even LL isnt
//very clear on it. It looks like baked textures, possibly body parts, etc are all
//marked as local. from what I can gather this means that the asset is stored locally
//on this server, but, and this makes no sense, can be requested by other servers.
//on this case why not put it on the asset cluster since it's central anyways?
//i could see bakes getting stored locally and regenerated for every sim corssing (i guess)
//but this isnt even the case. so im leaving this for now and everything is going to
//the asset server
}
/// <summary>
/// Requests and asset and responds asynchronously
/// </summary>
/// <param name="assetID"></param>
/// <param name="args"></param>
public void RequestAsset(OpenMetaverse.UUID assetID, AssetRequestInfo args)
{
_threadPool.QueueWorkItem(() => {
try
{
AssetBase asset = GetAssetInternal(assetID);
if (asset != null)
{
_receiver.AssetReceived(asset, args);
}
else
{
_receiver.AssetNotFound(assetID, args);
}
}
catch (Exception e)
{
_receiver.AssetError(assetID, e, args);
}
});
}
public void RequestAsset(OpenMetaverse.UUID assetID, AssetRequestInfo args)
{
_firstReadServer.RequestAsset(assetID, args);
}