477 lines
17 KiB
C#
Executable File
477 lines
17 KiB
C#
Executable File
/*
|
|
* 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 OpenSimulator 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;
|
|
using System.Collections.Generic;
|
|
using System.Threading;
|
|
using OpenMetaverse;
|
|
using OpenSim.Framework;
|
|
using OpenSim.Framework.Monitoring;
|
|
using OpenSim.Region.Framework.Interfaces;
|
|
using OpenSim.Region.ScriptEngine.Interfaces;
|
|
using OpenSim.Region.ScriptEngine.Shared;
|
|
using OpenSim.Region.ScriptEngine.Shared.Api.Plugins;
|
|
using Timer=OpenSim.Region.ScriptEngine.Shared.Api.Plugins.Timer;
|
|
using System.Reflection;
|
|
using log4net;
|
|
|
|
namespace OpenSim.Region.ScriptEngine.Shared.Api
|
|
{
|
|
/// <summary>
|
|
/// Handles LSL commands that takes long time and returns an event, for example timers, HTTP requests, etc.
|
|
/// </summary>
|
|
public class AsyncCommandManager
|
|
{
|
|
private static readonly ILog m_log = LogManager.GetLogger(MethodBase.GetCurrentMethod().DeclaringType);
|
|
|
|
private static Thread cmdHandlerThread;
|
|
private static int cmdHandlerThreadCycleSleepms;
|
|
private static int numInstances;
|
|
/// <summary>
|
|
/// Lock for reading/writing static components of AsyncCommandManager.
|
|
/// </summary>
|
|
/// <remarks>
|
|
/// This lock exists so that multiple threads from different engines and/or different copies of the same engine
|
|
/// are prevented from running non-thread safe code (e.g. read/write of lists) concurrently.
|
|
/// </remarks>
|
|
private static object staticLock = new object();
|
|
|
|
private static List<IScriptEngine> m_ScriptEngines =
|
|
new List<IScriptEngine>();
|
|
|
|
public IScriptEngine m_ScriptEngine;
|
|
|
|
private static Dictionary<IScriptEngine, Dataserver> m_Dataserver =
|
|
new Dictionary<IScriptEngine, Dataserver>();
|
|
private static Dictionary<IScriptEngine, Timer> m_Timer =
|
|
new Dictionary<IScriptEngine, Timer>();
|
|
private static Dictionary<IScriptEngine, Listener> m_Listener =
|
|
new Dictionary<IScriptEngine, Listener>();
|
|
private static Dictionary<IScriptEngine, HttpRequest> m_HttpRequest =
|
|
new Dictionary<IScriptEngine, HttpRequest>();
|
|
private static Dictionary<IScriptEngine, SensorRepeat> m_SensorRepeat =
|
|
new Dictionary<IScriptEngine, SensorRepeat>();
|
|
private static Dictionary<IScriptEngine, XmlRequest> m_XmlRequest =
|
|
new Dictionary<IScriptEngine, XmlRequest>();
|
|
|
|
public Dataserver DataserverPlugin
|
|
{
|
|
get
|
|
{
|
|
lock (staticLock)
|
|
return m_Dataserver[m_ScriptEngine];
|
|
}
|
|
}
|
|
|
|
public Timer TimerPlugin
|
|
{
|
|
get
|
|
{
|
|
lock (staticLock)
|
|
return m_Timer[m_ScriptEngine];
|
|
}
|
|
}
|
|
|
|
public HttpRequest HttpRequestPlugin
|
|
{
|
|
get
|
|
{
|
|
lock (staticLock)
|
|
return m_HttpRequest[m_ScriptEngine];
|
|
}
|
|
}
|
|
|
|
public Listener ListenerPlugin
|
|
{
|
|
get
|
|
{
|
|
lock (staticLock)
|
|
return m_Listener[m_ScriptEngine];
|
|
}
|
|
}
|
|
|
|
public SensorRepeat SensorRepeatPlugin
|
|
{
|
|
get
|
|
{
|
|
lock (staticLock)
|
|
return m_SensorRepeat[m_ScriptEngine];
|
|
}
|
|
}
|
|
|
|
public XmlRequest XmlRequestPlugin
|
|
{
|
|
get
|
|
{
|
|
lock (staticLock)
|
|
return m_XmlRequest[m_ScriptEngine];
|
|
}
|
|
}
|
|
|
|
public IScriptEngine[] ScriptEngines
|
|
{
|
|
get
|
|
{
|
|
lock (staticLock)
|
|
return m_ScriptEngines.ToArray();
|
|
}
|
|
}
|
|
|
|
public AsyncCommandManager(IScriptEngine _ScriptEngine)
|
|
{
|
|
m_ScriptEngine = _ScriptEngine;
|
|
|
|
// If there is more than one scene in the simulator or multiple script engines are used on the same region
|
|
// then more than one thread could arrive at this block of code simultaneously. However, it cannot be
|
|
// executed concurrently both because concurrent list operations are not thread-safe and because of other
|
|
// race conditions such as the later check of cmdHandlerThread == null.
|
|
lock (staticLock)
|
|
{
|
|
if (m_ScriptEngines.Count == 0)
|
|
ReadConfig();
|
|
|
|
if (!m_ScriptEngines.Contains(m_ScriptEngine))
|
|
m_ScriptEngines.Add(m_ScriptEngine);
|
|
|
|
// Create instances of all plugins
|
|
if (!m_Dataserver.ContainsKey(m_ScriptEngine))
|
|
m_Dataserver[m_ScriptEngine] = new Dataserver(this);
|
|
if (!m_Timer.ContainsKey(m_ScriptEngine))
|
|
m_Timer[m_ScriptEngine] = new Timer(this);
|
|
if (!m_HttpRequest.ContainsKey(m_ScriptEngine))
|
|
m_HttpRequest[m_ScriptEngine] = new HttpRequest(this);
|
|
if (!m_Listener.ContainsKey(m_ScriptEngine))
|
|
m_Listener[m_ScriptEngine] = new Listener(this);
|
|
if (!m_SensorRepeat.ContainsKey(m_ScriptEngine))
|
|
m_SensorRepeat[m_ScriptEngine] = new SensorRepeat(this);
|
|
if (!m_XmlRequest.ContainsKey(m_ScriptEngine))
|
|
m_XmlRequest[m_ScriptEngine] = new XmlRequest(this);
|
|
|
|
numInstances++;
|
|
if (cmdHandlerThread == null)
|
|
{
|
|
cmdHandlerThread = WorkManager.StartThread(
|
|
CmdHandlerThreadLoop, "AsyncLSLCmdHandlerThread");
|
|
}
|
|
}
|
|
}
|
|
|
|
private void ReadConfig()
|
|
{
|
|
// cmdHandlerThreadCycleSleepms = m_ScriptEngine.Config.GetInt("AsyncLLCommandLoopms", 100);
|
|
// TODO: Make this sane again
|
|
cmdHandlerThreadCycleSleepms = 100;
|
|
}
|
|
|
|
/*
|
|
~AsyncCommandManager()
|
|
{
|
|
// Shut down thread
|
|
|
|
try
|
|
{
|
|
lock (staticLock)
|
|
{
|
|
numInstances--;
|
|
if(numInstances > 0)
|
|
return;
|
|
if (cmdHandlerThread != null)
|
|
{
|
|
if (cmdHandlerThread.IsAlive == true)
|
|
{
|
|
cmdHandlerThread.Abort();
|
|
//cmdHandlerThread.Join();
|
|
cmdHandlerThread = null;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
catch
|
|
{
|
|
}
|
|
}
|
|
*/
|
|
/// <summary>
|
|
/// Main loop for the manager thread
|
|
/// </summary>
|
|
private static void CmdHandlerThreadLoop()
|
|
{
|
|
bool running = true;
|
|
while (running)
|
|
{
|
|
try
|
|
{
|
|
Thread.Sleep(cmdHandlerThreadCycleSleepms);
|
|
Watchdog.UpdateThread();
|
|
DoOneCmdHandlerPass();
|
|
Watchdog.UpdateThread();
|
|
}
|
|
catch ( System.Threading.ThreadAbortException)
|
|
{
|
|
Thread.ResetAbort();
|
|
running = false;
|
|
}
|
|
catch (Exception e)
|
|
{
|
|
m_log.Error("[ASYNC COMMAND MANAGER]: Exception in command handler pass: ", e);
|
|
}
|
|
}
|
|
}
|
|
|
|
private static void DoOneCmdHandlerPass()
|
|
{
|
|
lock (staticLock)
|
|
{
|
|
// Check HttpRequests
|
|
try { m_HttpRequest[m_ScriptEngines[0]].CheckHttpRequests(); } catch {}
|
|
|
|
// Check XMLRPCRequests
|
|
try { m_XmlRequest[m_ScriptEngines[0]].CheckXMLRPCRequests(); } catch {}
|
|
|
|
foreach (IScriptEngine s in m_ScriptEngines)
|
|
{
|
|
// Check Listeners
|
|
try { m_Listener[s].CheckListeners(); } catch {}
|
|
|
|
|
|
// Check timers
|
|
try { m_Timer[s].CheckTimerEvents(); } catch {}
|
|
|
|
// Check Sensors
|
|
try { m_SensorRepeat[s].CheckSenseRepeaterEvents(); } catch {}
|
|
|
|
// Check dataserver
|
|
try { m_Dataserver[s].ExpireRequests(); } catch {}
|
|
}
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Remove a specific script (and all its pending commands)
|
|
/// </summary>
|
|
/// <param name="localID"></param>
|
|
/// <param name="itemID"></param>
|
|
public static void RemoveScript(IScriptEngine engine, uint localID, UUID itemID)
|
|
{
|
|
// Remove a specific script
|
|
// m_log.DebugFormat("[ASYNC COMMAND MANAGER]: Removing facilities for script {0}", itemID);
|
|
|
|
lock (staticLock)
|
|
{
|
|
// Remove dataserver events
|
|
m_Dataserver[engine].RemoveEvents(localID, itemID);
|
|
|
|
// Remove from: Timers
|
|
m_Timer[engine].UnSetTimerEvents(localID, itemID);
|
|
|
|
if(engine.World != null)
|
|
{
|
|
// Remove from: HttpRequest
|
|
IHttpRequestModule iHttpReq = engine.World.RequestModuleInterface<IHttpRequestModule>();
|
|
if (iHttpReq != null)
|
|
iHttpReq.StopHttpRequest(localID, itemID);
|
|
|
|
IWorldComm comms = engine.World.RequestModuleInterface<IWorldComm>();
|
|
if (comms != null)
|
|
comms.DeleteListener(itemID);
|
|
|
|
IXMLRPC xmlrpc = engine.World.RequestModuleInterface<IXMLRPC>();
|
|
if (xmlrpc != null)
|
|
{
|
|
xmlrpc.DeleteChannels(itemID);
|
|
xmlrpc.CancelSRDRequests(itemID);
|
|
}
|
|
}
|
|
// Remove Sensors
|
|
m_SensorRepeat[engine].UnSetSenseRepeaterEvents(localID, itemID);
|
|
}
|
|
}
|
|
|
|
public static void StateChange(IScriptEngine engine, uint localID, UUID itemID)
|
|
{
|
|
// Remove a specific script
|
|
|
|
// Remove dataserver events
|
|
m_Dataserver[engine].RemoveEvents(localID, itemID);
|
|
|
|
IWorldComm comms = engine.World.RequestModuleInterface<IWorldComm>();
|
|
if (comms != null)
|
|
comms.DeleteListener(itemID);
|
|
|
|
IXMLRPC xmlrpc = engine.World.RequestModuleInterface<IXMLRPC>();
|
|
if (xmlrpc != null)
|
|
{
|
|
xmlrpc.DeleteChannels(itemID);
|
|
xmlrpc.CancelSRDRequests(itemID);
|
|
}
|
|
// Remove Sensors
|
|
m_SensorRepeat[engine].UnSetSenseRepeaterEvents(localID, itemID);
|
|
|
|
}
|
|
|
|
/// <summary>
|
|
/// Get the sensor repeat plugin for this script engine.
|
|
/// </summary>
|
|
/// <param name="engine"></param>
|
|
/// <returns></returns>
|
|
public static SensorRepeat GetSensorRepeatPlugin(IScriptEngine engine)
|
|
{
|
|
lock (staticLock)
|
|
{
|
|
if (m_SensorRepeat.ContainsKey(engine))
|
|
return m_SensorRepeat[engine];
|
|
else
|
|
return null;
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Get the dataserver plugin for this script engine.
|
|
/// </summary>
|
|
/// <param name="engine"></param>
|
|
/// <returns></returns>
|
|
public static Dataserver GetDataserverPlugin(IScriptEngine engine)
|
|
{
|
|
lock (staticLock)
|
|
{
|
|
if (m_Dataserver.ContainsKey(engine))
|
|
return m_Dataserver[engine];
|
|
else
|
|
return null;
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Get the timer plugin for this script engine.
|
|
/// </summary>
|
|
/// <param name="engine"></param>
|
|
/// <returns></returns>
|
|
public static Timer GetTimerPlugin(IScriptEngine engine)
|
|
{
|
|
lock (staticLock)
|
|
{
|
|
if (m_Timer.ContainsKey(engine))
|
|
return m_Timer[engine];
|
|
else
|
|
return null;
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Get the listener plugin for this script engine.
|
|
/// </summary>
|
|
/// <param name="engine"></param>
|
|
/// <returns></returns>
|
|
public static Listener GetListenerPlugin(IScriptEngine engine)
|
|
{
|
|
lock (staticLock)
|
|
{
|
|
if (m_Listener.ContainsKey(engine))
|
|
return m_Listener[engine];
|
|
else
|
|
return null;
|
|
}
|
|
}
|
|
|
|
public static Object[] GetSerializationData(IScriptEngine engine, UUID itemID)
|
|
{
|
|
List<Object> data = new List<Object>();
|
|
|
|
lock (staticLock)
|
|
{
|
|
Object[] listeners = m_Listener[engine].GetSerializationData(itemID);
|
|
if (listeners.Length > 0)
|
|
{
|
|
data.Add("listener");
|
|
data.Add(listeners.Length);
|
|
data.AddRange(listeners);
|
|
}
|
|
|
|
Object[] timers=m_Timer[engine].GetSerializationData(itemID);
|
|
if (timers.Length > 0)
|
|
{
|
|
data.Add("timer");
|
|
data.Add(timers.Length);
|
|
data.AddRange(timers);
|
|
}
|
|
|
|
Object[] sensors = m_SensorRepeat[engine].GetSerializationData(itemID);
|
|
if (sensors.Length > 0)
|
|
{
|
|
data.Add("sensor");
|
|
data.Add(sensors.Length);
|
|
data.AddRange(sensors);
|
|
}
|
|
}
|
|
|
|
return data.ToArray();
|
|
}
|
|
|
|
public static void CreateFromData(IScriptEngine engine, uint localID,
|
|
UUID itemID, UUID hostID, Object[] data)
|
|
{
|
|
int idx = 0;
|
|
int len;
|
|
|
|
while (idx < data.Length)
|
|
{
|
|
string type = data[idx].ToString();
|
|
len = (int)data[idx+1];
|
|
idx+=2;
|
|
|
|
if (len > 0)
|
|
{
|
|
Object[] item = new Object[len];
|
|
Array.Copy(data, idx, item, 0, len);
|
|
|
|
idx+=len;
|
|
|
|
lock (staticLock)
|
|
{
|
|
switch (type)
|
|
{
|
|
case "listener":
|
|
m_Listener[engine].CreateFromData(localID, itemID,
|
|
hostID, item);
|
|
break;
|
|
case "timer":
|
|
m_Timer[engine].CreateFromData(localID, itemID,
|
|
hostID, item);
|
|
break;
|
|
case "sensor":
|
|
m_SensorRepeat[engine].CreateFromData(localID,
|
|
itemID, hostID, item);
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|