public void StopHttpRequestsForScript(UUID id)
{
List <UUID> keysToRemove = new List <UUID>();
m_pendingRequests.ForEach(delegate(HttpRequestClass req)
{
if (req.ItemID == id)
{
req.Stop();
keysToRemove.Add(req.ReqID);
}
});
keysToRemove.ForEach(keyToRemove => m_pendingRequests.Remove(keyToRemove));
}
private void ClientClosed(UUID agentID, Scene scene)
{
//m_log.DebugFormat("[EVENTQUEUE]: Closed client {0} in region {1}", agentID, m_scene.RegionInfo.RegionName);
queues.Remove(agentID);
List <UUID> removeitems = new List <UUID>();
m_AvatarQueueUUIDMapping.Remove(agentID);
UUID searchval = UUID.Zero;
removeitems.Clear();
m_QueueUUIDAvatarMapping.ForEach(delegate(KeyValuePair <UUID, UUID> kvp)
{
searchval = m_QueueUUIDAvatarMapping[kvp.Key];
if (searchval == agentID)
{
removeitems.Add(kvp.Key);
}
});
foreach (UUID ky in removeitems)
{
m_QueueUUIDAvatarMapping.Remove(ky);
}
// m_log.DebugFormat("[EVENTQUEUE]: Deleted queues for {0} in region {1}", agentID, m_scene.RegionInfo.RegionName);
}
private void OnClientClosed(UUID agentID, Scene scene)
{
ScenePresence sp = scene.GetScenePresence(agentID);
if (sp != null && !sp.IsChildAgent)
{
// do this for root agents closing out
StatusChange(agentID, false);
}
/* check if there is still an agent somewhere in that case we keep the cache stored */
try
{
m_Scenes.ForEach(delegate(Scene s)
{
s.TryGetScenePresence(agentID, out sp);
if ((sp != null) && !sp.IsChildAgent && (s != scene))
{
throw new ThreadedClasses.ReturnValueException <bool>(true);
}
});
}
catch (ThreadedClasses.ReturnValueException <bool> )
{
/* still somewhere that agent */
return;
}
m_Friends.Remove(agentID);
}
/**********************************************
* Remote Data Reply
*
* Response to RPC message
*
*********************************************/
public void RemoteDataReply(string channel, string message_id, string sdata, int idata)
{
UUID message_key = new UUID(message_id);
UUID channel_key = new UUID(channel);
RPCRequestInfo rpcInfo = null;
if (message_key == UUID.Zero)
{
m_rpcPendingResponses.ForEach(delegate(RPCRequestInfo oneRpcInfo)
{
if (oneRpcInfo.GetChannelKey() == channel_key)
{
rpcInfo = oneRpcInfo;
}
});
}
else
{
m_rpcPendingResponses.TryGetValue(message_key, out rpcInfo);
}
if (rpcInfo != null)
{
rpcInfo.SetStrRetval(sdata);
rpcInfo.SetIntRetval(idata);
rpcInfo.SetProcessed(true);
m_rpcPendingResponses.Remove(message_key);
}
else
{
m_log.Warn("[XML RPC MODULE]: Channel or message_id not found");
}
}
public void RemoveRegion(Scene scene)
{
m_scenel.Remove(scene.RegionInfo.RegionHandle);
scene.EventManager.OnAvatarKilled -= KillAvatar;
scene.EventManager.OnAvatarEnteringNewParcel -= AvatarEnteringParcel;
}
public void UnSetTimerEvents(uint m_localID, UUID m_itemID)
{
// Remove from timer
string key = MakeTimerKey(m_localID, m_itemID);
Timers.Remove(key);
}
void OnClientClosed(UUID clientID, Scene scene)
{
try
{
m_Scenes.ForEach(delegate(Scene s)
{
ScenePresence sp;
s.TryGetScenePresence(clientID, out sp);
if ((sp != null) && !sp.IsChildAgent && (s != scene))
{
m_log.DebugFormat("[INVENTORY CACHE]: OnClientClosed in {0}, but user {1} still in sim. Keeping inventoryURL in cache",
scene.RegionInfo.RegionName, clientID);
throw new ThreadedClasses.ReturnValueException <bool>(true);
}
});
}
catch (ThreadedClasses.ReturnValueException <bool> )
{
/* still somewhere that agent */
return;
}
string url;
if (m_InventoryURLs.Remove(clientID, out url))
{
m_log.DebugFormat("[HG INVENTORY CONNECTOR]: Removed {0} from the cache of inventory URLs for agent {1}", url, clientID.ToString());
}
}
/// <summary>
///
/// </summary>
/// <param name="objectID"></param>
/// <param name="sender"></param>
/// <param name="subject"></param>
/// <returns></returns>
public Email GetNextEmail(UUID objectID, string sender, string subject)
{
EmailQueue queue = m_MailQueues.GetOrAddIfNotExists(objectID, delegate() { return(new EmailQueue()); });
queue.m_LastCall = DateTime.Now;
// Hopefully this isn't too time consuming. If it is, we can always push it into a worker thread.
DateTime now = DateTime.Now;
foreach (UUID uuid in m_MailQueues.Keys)
{
if (m_MailQueues.TryGetValue(uuid, out queue))
{
if ((now - queue.m_LastCall) > m_QueueTimeout)
{
m_MailQueues.Remove(uuid);
}
}
}
queue = m_MailQueues.GetOrAddIfNotExists(objectID, delegate() { return(new EmailQueue()); });
return(queue.m_Queue.RemoveMatch(delegate(Email m)
{
return ((sender == null || sender.Equals("") || sender.Equals(m.sender)) &&
(subject == null || subject.Equals("") || subject.Equals(m.subject)));
}));
}
private static bool RemoveThread(int threadID)
{
ThreadWatchdogInfo twi;
if (m_threads.Remove(threadID, out twi))
{
m_log.DebugFormat(
"[WATCHDOG]: Removing thread {0}, ID {1}", twi.Thread.Name, twi.Thread.ManagedThreadId);
twi.Cleanup();
return(true);
}
m_log.WarnFormat(
"[WATCHDOG]: Requested to remove thread with ID {0} but this is not being monitored", threadID);
return(false);
}
// Delete channels based on itemID
// for when a script is deleted
public void DeleteChannels(UUID itemID)
{
ArrayList tmp = new ArrayList();
m_openChannels.ForEach(delegate(RPCChannelInfo li)
{
if (li.GetItemID().Equals(itemID))
{
tmp.Add(itemID);
}
});
foreach (UUID uuid in tmp)
{
m_openChannels.Remove(uuid);
}
}
/// <summary>
/// Removes the http server listening on the given port.
/// </summary>
/// <remarks>
/// It is the responsibility of the caller to do clean up.
/// </remarks>
/// <param name='port'></param>
/// <returns></returns>
public static bool RemoveHttpServer(uint port)
{
if (instance != null && instance.Port == port)
{
instance = null;
}
return(m_Servers.Remove(port));
}
/// <summary>
/// Removes the given child subfolder.
/// </summary>
/// <param name="folderID"></param>
/// <returns>
/// The folder removed, or null if the folder was not present.
/// </returns>
public InventoryFolderImpl RemoveChildFolder(UUID folderID)
{
InventoryFolderImpl removedFolder = null;
m_childFolders.Remove(folderID, out removedFolder);
return(removedFolder);
}
void IRegionModuleBase.RemoveRegion(Scene scene)
{
if (!Enabled)
{
return;
}
regions.Remove(scene.RegionInfo.RegionID);
}
///<summary>
///
///</summary>
public void RemoveRegion(Scene scene)
{
if (!m_enabled)
{
return;
}
m_scenes.Remove(scene.RegionInfo.RegionID);
}
/// <summary>
/// Can be called from other modules.
/// </summary>
/// <param name="scene"></param>
public void RemoveScene(Scene scene)
{
if (!m_scenes.Remove(scene.RegionInfo.RegionID))
{
m_log.WarnFormat(
"[LOCAL SIMULATION CONNECTOR]: Tried to remove region {0} but it was not present",
scene.RegionInfo.RegionName);
}
}
public void RemoveCompletedRequest(UUID id)
{
RPCRequestInfo tmp;
if (m_rpcPending.Remove(id, out tmp))
{
m_rpcPendingResponses.Add(id, tmp);
}
}
// -----------------------------------------------------------------
/// <summary>
///
/// </summary>
// -----------------------------------------------------------------
public bool DestroyStore(UUID storeID)
{
if (!m_enabled)
{
return(false);
}
return(m_JsonValueStore.Remove(storeID));
}
/* TODO: Figure out how PollServiceHTTPHandler can access the request headers
* in order to use m_AllowedOrigin as a regular expression
* private Hashtable CheckOrigin(Hashtable headers, Hashtable result)
* {
* if (!string.IsNullOrEmpty(m_AllowedOrigin))
* {
* if (headers.ContainsKey("origin"))
* {
* string origin = headers["origin"].ToString();
* if (Regex.IsMatch(origin, m_AllowedOrigin))
* result["access_control_allow_origin"] = origin;
* }
* }
* return result;
* }
*/
private void DoExpire()
{
List <UUID> expired = new List <UUID>();
foreach (KeyValuePair <UUID, ConsoleConnection> kvp in m_Connections)
{
if (System.Environment.TickCount - kvp.Value.last > 500000)
{
expired.Add(kvp.Key);
}
}
foreach (UUID id in expired)
{
m_Connections.Remove(id);
CloseConnection(id);
}
}
public void RemoveRegion(Scene scene)
{
if (!m_Enabled)
{
return;
}
m_LocalCache[scene.RegionInfo.RegionID].Clear();
m_LocalCache.Remove(scene.RegionInfo.RegionID);
}
public bool RemoveAndRelease(string name)
{
BSActor beingRemoved;
if (m_actors.Remove(name, out beingRemoved))
{
beingRemoved.Dispose();
return(true);
}
return(false);
}
public void ReleaseURL(string url)
{
UrlData data;
if (!m_UrlMap.Remove(url, out data))
{
return;
}
foreach (UUID req in data.requests.Keys)
{
m_RequestMap.Remove(req);
}
m_log.DebugFormat(
"[URL MODULE]: Releasing url {0} for {1} in {2}",
url, data.itemID, data.hostID);
RemoveUrl(data);
m_UrlMap.Remove(url);
}
public bool Delete(UUID regionID)
{
if (m_useStaticInstance && Instance != this)
{
return(Instance.Delete(regionID));
}
// m_log.DebugFormat("[NULL REGION DATA]: Deleting region {0}", regionID);
m_regionData.Remove(regionID);
return(true);
}
public bool RemoveXferUploader(UUID transactionID)
{
bool removed = XferUploaders.Remove(transactionID);
if (!removed)
{
m_log.WarnFormat(
"[AGENT ASSET TRANSACTIONS]: Received request to remove xfer uploader with transaction ID {0} but none found",
transactionID);
}
return(removed);
}
public void Remove(UUID itemID, int handle)
{
/* standard foreach is implemented in RwLockedDictionary to make a copy first */
foreach (KeyValuePair <int, ThreadedClasses.RwLockedList <ListenerInfo> > lis
in m_listeners)
{
/* standard foreach is implemented in RwLockedDictionary to make a copy first */
foreach (ListenerInfo li in lis.Value)
{
if (li.GetItemID().Equals(itemID) &&
li.GetHandle().Equals(handle))
{
lis.Value.Remove(li);
if (lis.Value.Count == 0)
{
m_listeners.Remove(lis.Key);
Interlocked.Decrement(ref m_curlisteners);
}
// there should be only one, so we bail out early
return;
}
}
}
}
/// <summary>
/// Deletes an item if it exists in this folder or any children
/// </summary>
/// <param name="folderID"></param>
/// <returns></returns>
public bool DeleteItem(UUID itemID)
{
if (Items.Remove(itemID))
{
return(true);
}
try
{
m_childFolders.ForEach(delegate(InventoryFolderImpl folder)
{
if (folder.DeleteItem(itemID))
{
throw new ThreadedClasses.ReturnValueException <bool>(true);
}
});
}
catch (ThreadedClasses.ReturnValueException <bool> )
{
return(true);
}
return(false);
}
public void RemoveRegionEnvironmentSettings(UUID regionUUID)
{
EnvironmentSettings.Remove(regionUUID);
}
public bool Remove(string key)
{
return(m_map.Remove(key));
}
/// <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);
AgentTransactions.Remove(userID);
}
/// <summary>
/// Remove the cap handler for a capability.
/// </summary>
/// <param name="capsName">name of the capability of the cap
/// handler to be removed</param>
public void Remove(string capsName)
{
m_httpListener.RemoveStreamHandler("POST", m_capsHandlers[capsName].Path);
m_httpListener.RemoveStreamHandler("GET", m_capsHandlers[capsName].Path);
m_capsHandlers.Remove(capsName);
}
public bool DeleteGroup(UUID groupID)
{
return(m_groups.Remove(groupID));
}
