845 lines
28 KiB
C#
845 lines
28 KiB
C#
/*
|
|
* 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.IO;
|
|
using System.Threading;
|
|
using System.Collections;
|
|
using System.Collections.Generic;
|
|
using System.Security.Policy;
|
|
using System.Reflection;
|
|
using System.Globalization;
|
|
using System.Xml;
|
|
using libsecondlife;
|
|
using log4net;
|
|
using Nini.Config;
|
|
using Amib.Threading;
|
|
using OpenSim.Framework;
|
|
using OpenSim.Region.Environment;
|
|
using OpenSim.Region.Environment.Scenes;
|
|
using OpenSim.Region.Environment.Interfaces;
|
|
using OpenSim.Region.ScriptEngine.Shared;
|
|
using OpenSim.Region.ScriptEngine.Shared.Api;
|
|
using OpenSim.Region.ScriptEngine.Shared.ScriptBase;
|
|
using OpenSim.Region.ScriptEngine.Shared.CodeTools;
|
|
using OpenSim.Region.ScriptEngine.Shared.Instance;
|
|
using OpenSim.Region.ScriptEngine.Interfaces;
|
|
|
|
namespace OpenSim.Region.ScriptEngine.XEngine
|
|
{
|
|
public class XEngine : IScriptModule, IScriptEngine
|
|
{
|
|
private static readonly ILog m_log = LogManager.GetLogger(MethodBase.GetCurrentMethod().DeclaringType);
|
|
|
|
private SmartThreadPool m_ThreadPool;
|
|
private int m_MaxScriptQueue;
|
|
private Scene m_Scene;
|
|
private IConfig m_ScriptConfig;
|
|
private Compiler m_Compiler;
|
|
|
|
// disable warning: need to keep a reference to XEngine.EventManager
|
|
// alive to avoid it being garbage collected
|
|
#pragma warning disable 414
|
|
private EventManager m_EventManager;
|
|
#pragma warning restore 414
|
|
private int m_EventLimit;
|
|
private bool m_KillTimedOutScripts;
|
|
private AsyncCommandManager m_AsyncCommands;
|
|
bool m_firstStart = true;
|
|
|
|
private static List<XEngine> m_ScriptEngines =
|
|
new List<XEngine>();
|
|
|
|
// Maps the local id to the script inventory items in it
|
|
|
|
private Dictionary<uint, List<LLUUID> > m_PrimObjects =
|
|
new Dictionary<uint, List<LLUUID> >();
|
|
|
|
// Maps the LLUUID above to the script instance
|
|
|
|
private Dictionary<LLUUID, IScriptInstance> m_Scripts =
|
|
new Dictionary<LLUUID, IScriptInstance>();
|
|
|
|
// Maps the asset ID to the assembly
|
|
|
|
private Dictionary<LLUUID, string> m_Assemblies =
|
|
new Dictionary<LLUUID, string>();
|
|
|
|
// This will list AppDomains by script asset
|
|
|
|
private Dictionary<LLUUID, AppDomain> m_AppDomains =
|
|
new Dictionary<LLUUID, AppDomain>();
|
|
|
|
// List the scripts running in each appdomain
|
|
|
|
private Dictionary<LLUUID, List<LLUUID> > m_DomainScripts =
|
|
new Dictionary<LLUUID, List<LLUUID> >();
|
|
|
|
private Queue m_CompileQueue = new Queue(100);
|
|
IWorkItemResult m_CurrentCompile = null;
|
|
|
|
public string ScriptEngineName
|
|
{
|
|
get { return "XEngine"; }
|
|
}
|
|
|
|
public Scene World
|
|
{
|
|
get { return m_Scene; }
|
|
}
|
|
|
|
public ILog Log
|
|
{
|
|
get { return m_log; }
|
|
}
|
|
|
|
public static List<XEngine> ScriptEngines
|
|
{
|
|
get { return m_ScriptEngines; }
|
|
}
|
|
|
|
// private struct RezScriptParms
|
|
// {
|
|
// uint LocalID;
|
|
// LLUUID ItemID;
|
|
// string Script;
|
|
// }
|
|
|
|
public IConfig Config
|
|
{
|
|
get { return m_ScriptConfig; }
|
|
}
|
|
|
|
public Object AsyncCommands
|
|
{
|
|
get { return (Object)m_AsyncCommands; }
|
|
}
|
|
|
|
//
|
|
// IRegionModule functions
|
|
//
|
|
public void Initialise(Scene scene, IConfigSource configSource)
|
|
{
|
|
AppDomain.CurrentDomain.AssemblyResolve +=
|
|
OnAssemblyResolve;
|
|
|
|
m_log.InfoFormat("[XEngine] Initializing scripts in region {0}",
|
|
scene.RegionInfo.RegionName);
|
|
m_Scene = scene;
|
|
|
|
m_ScriptConfig = configSource.Configs["XEngine"];
|
|
|
|
if (m_ScriptConfig == null)
|
|
{
|
|
m_log.ErrorFormat("[XEngine] No script configuration found. Scripts disabled");
|
|
return;
|
|
}
|
|
|
|
int minThreads = m_ScriptConfig.GetInt("MinThreads", 2);
|
|
int maxThreads = m_ScriptConfig.GetInt("MaxThreads", 2);
|
|
int idleTimeout = m_ScriptConfig.GetInt("IdleTimeout", 60);
|
|
string priority = m_ScriptConfig.GetString("Priority", "BelowNormal");
|
|
int maxScriptQueue = m_ScriptConfig.GetInt("MaxScriptEventQueue",300);
|
|
int stackSize = m_ScriptConfig.GetInt("ThreadStackSize", 262144);
|
|
int sleepTime = m_ScriptConfig.GetInt("MaintenanceInterval", 10)*1000;
|
|
m_EventLimit = m_ScriptConfig.GetInt("EventLimit", 30);
|
|
m_KillTimedOutScripts = m_ScriptConfig.GetBoolean("KillTimedOutScripts", false);
|
|
int saveTime = m_ScriptConfig.GetInt("SaveInterval", 300)*1000;
|
|
|
|
ThreadPriority prio = ThreadPriority.BelowNormal;
|
|
switch (priority)
|
|
{
|
|
case "Lowest":
|
|
prio = ThreadPriority.Lowest;
|
|
break;
|
|
case "BelowNormal":
|
|
prio = ThreadPriority.BelowNormal;
|
|
break;
|
|
case "Normal":
|
|
prio = ThreadPriority.Normal;
|
|
break;
|
|
case "AboveNormal":
|
|
prio = ThreadPriority.AboveNormal;
|
|
break;
|
|
case "Highest":
|
|
prio = ThreadPriority.Highest;
|
|
break;
|
|
default:
|
|
m_log.ErrorFormat("[XEngine] Invalid thread priority: '{0}'. Assuming BelowNormal", priority);
|
|
break;
|
|
}
|
|
|
|
lock (m_ScriptEngines)
|
|
{
|
|
m_ScriptEngines.Add(this);
|
|
}
|
|
|
|
m_EventManager = new EventManager(this);
|
|
|
|
StartEngine(minThreads, maxThreads, idleTimeout, prio,
|
|
maxScriptQueue, stackSize);
|
|
|
|
m_Compiler = new Compiler(this);
|
|
|
|
m_Scene.EventManager.OnRezScript += OnRezScript;
|
|
m_Scene.EventManager.OnRemoveScript += OnRemoveScript;
|
|
m_Scene.EventManager.OnScriptReset += OnScriptReset;
|
|
m_Scene.EventManager.OnStartScript += OnStartScript;
|
|
m_Scene.EventManager.OnStopScript += OnStopScript;
|
|
|
|
m_AsyncCommands = new AsyncCommandManager(this);
|
|
|
|
if (sleepTime > 0)
|
|
{
|
|
m_ThreadPool.QueueWorkItem(new WorkItemCallback(this.DoMaintenance),
|
|
new Object[]{ sleepTime });
|
|
}
|
|
|
|
if (saveTime > 0)
|
|
{
|
|
m_ThreadPool.QueueWorkItem(new WorkItemCallback(this.DoBackup),
|
|
new Object[] { saveTime });
|
|
}
|
|
|
|
scene.RegisterModuleInterface<IScriptModule>(this);
|
|
}
|
|
|
|
public void PostInitialise()
|
|
{
|
|
m_ThreadPool.Start();
|
|
}
|
|
|
|
public void Close()
|
|
{
|
|
lock (m_ScriptEngines)
|
|
{
|
|
if (m_ScriptEngines.Contains(this))
|
|
m_ScriptEngines.Remove(this);
|
|
}
|
|
}
|
|
|
|
public object DoBackup(object o)
|
|
{
|
|
Object[] p = (Object[])o;
|
|
int saveTime = (int)p[0];
|
|
|
|
System.Threading.Thread.Sleep(saveTime);
|
|
|
|
// m_log.Debug("[XEngine] Backing up script states");
|
|
|
|
List<IScriptInstance> instances = new List<IScriptInstance>();
|
|
|
|
lock (m_Scripts)
|
|
{
|
|
foreach (IScriptInstance instance in m_Scripts.Values)
|
|
instances.Add(instance);
|
|
}
|
|
|
|
foreach (IScriptInstance i in instances)
|
|
{
|
|
string assembly = String.Empty;
|
|
|
|
lock (m_Scripts)
|
|
{
|
|
if (!m_Assemblies.ContainsKey(i.AssetID))
|
|
continue;
|
|
assembly = m_Assemblies[i.AssetID];
|
|
}
|
|
|
|
i.SaveState(assembly);
|
|
}
|
|
|
|
instances.Clear();
|
|
|
|
m_ThreadPool.QueueWorkItem(new WorkItemCallback(this.DoBackup),
|
|
new Object[] { saveTime });
|
|
|
|
return 0;
|
|
}
|
|
|
|
public object DoMaintenance(object p)
|
|
{
|
|
object[] parms = (object[])p;
|
|
int sleepTime = (int)parms[0];
|
|
|
|
foreach (IScriptInstance inst in m_Scripts.Values)
|
|
{
|
|
if (inst.EventTime() > m_EventLimit)
|
|
{
|
|
inst.Stop(100);
|
|
if (!m_KillTimedOutScripts)
|
|
inst.Start();
|
|
}
|
|
}
|
|
|
|
System.Threading.Thread.Sleep(sleepTime);
|
|
|
|
m_ThreadPool.QueueWorkItem(new WorkItemCallback(this.DoMaintenance),
|
|
new Object[]{ sleepTime });
|
|
|
|
return 0;
|
|
}
|
|
|
|
public string Name
|
|
{
|
|
get { return "XEngine"; }
|
|
}
|
|
|
|
public bool IsSharedModule
|
|
{
|
|
get { return false; }
|
|
}
|
|
|
|
public void OnRezScript(uint localID, LLUUID itemID, string script, int startParam, bool postOnRez)
|
|
{
|
|
Object[] parms = new Object[]{localID, itemID, script, startParam, postOnRez};
|
|
|
|
lock (m_CompileQueue)
|
|
{
|
|
m_CompileQueue.Enqueue(parms);
|
|
|
|
if (m_CurrentCompile == null)
|
|
{
|
|
if (m_firstStart)
|
|
{
|
|
m_firstStart = false;
|
|
m_CurrentCompile = m_ThreadPool.QueueWorkItem(
|
|
new WorkItemCallback(this.DoScriptWait),
|
|
new Object[0]);
|
|
return;
|
|
}
|
|
|
|
m_CurrentCompile = m_ThreadPool.QueueWorkItem(
|
|
new WorkItemCallback(this.DoOnRezScriptQueue),
|
|
new Object[0]);
|
|
}
|
|
}
|
|
}
|
|
|
|
public Object DoScriptWait(Object dummy)
|
|
{
|
|
Thread.Sleep(30000);
|
|
|
|
lock (m_CompileQueue)
|
|
{
|
|
if (m_CompileQueue.Count > 0)
|
|
{
|
|
m_CurrentCompile = m_ThreadPool.QueueWorkItem(
|
|
new WorkItemCallback(this.DoOnRezScriptQueue),
|
|
new Object[0]);
|
|
}
|
|
else
|
|
{
|
|
m_CurrentCompile = null;
|
|
}
|
|
}
|
|
return null;
|
|
}
|
|
|
|
public Object DoOnRezScriptQueue(Object dummy)
|
|
{
|
|
Object o;
|
|
lock (m_CompileQueue)
|
|
{
|
|
o = m_CompileQueue.Dequeue();
|
|
if (o == null)
|
|
{
|
|
m_CurrentCompile = null;
|
|
return null;
|
|
}
|
|
}
|
|
|
|
DoOnRezScript(o);
|
|
|
|
lock (m_CompileQueue)
|
|
{
|
|
if (m_CompileQueue.Count > 0)
|
|
{
|
|
m_CurrentCompile = m_ThreadPool.QueueWorkItem(
|
|
new WorkItemCallback(this.DoOnRezScriptQueue),
|
|
new Object[0]);
|
|
}
|
|
else
|
|
{
|
|
m_CurrentCompile = null;
|
|
}
|
|
}
|
|
return null;
|
|
}
|
|
|
|
private bool DoOnRezScript(object parm)
|
|
{
|
|
Object[] p = (Object[])parm;
|
|
uint localID = (uint)p[0];
|
|
LLUUID itemID = (LLUUID)p[1];
|
|
string script =(string)p[2];
|
|
int startParam = (int)p[3];
|
|
bool postOnRez = (bool)p[4];
|
|
|
|
// Get the asset ID of the script, so we can check if we
|
|
// already have it.
|
|
|
|
SceneObjectPart part = m_Scene.GetSceneObjectPart(localID);
|
|
if (part == null)
|
|
return false;
|
|
|
|
TaskInventoryItem item = part.GetInventoryItem(itemID);
|
|
if (item == null)
|
|
return false;
|
|
|
|
LLUUID assetID = item.AssetID;
|
|
|
|
// m_log.DebugFormat("[XEngine] Compiling script {0} ({1})",
|
|
// item.Name, itemID.ToString());
|
|
|
|
string assembly = "";
|
|
try
|
|
{
|
|
assembly = m_Compiler.PerformScriptCompile(script,
|
|
assetID.ToString());
|
|
}
|
|
catch (Exception e)
|
|
{
|
|
try
|
|
{
|
|
// DISPLAY ERROR INWORLD
|
|
string text = "Error compiling script:\r\n" + e.Message.ToString();
|
|
if (text.Length > 1000)
|
|
text = text.Substring(0, 1000);
|
|
World.SimChat(Helpers.StringToField(text),
|
|
ChatTypeEnum.DebugChannel, 2147483647,
|
|
part.AbsolutePosition,
|
|
part.Name, part.UUID, false);
|
|
}
|
|
catch (Exception e2) // LEGIT: User Scripting
|
|
{
|
|
m_log.Error("[XEngine]: "+
|
|
"Error displaying error in-world: " +
|
|
e2.ToString());
|
|
m_log.Error("[XEngine]: " +
|
|
"Errormessage: Error compiling script:\r\n" +
|
|
e.Message.ToString());
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
lock (m_Scripts)
|
|
{
|
|
// Create the object record
|
|
|
|
if ((!m_Scripts.ContainsKey(itemID)) ||
|
|
(m_Scripts[itemID].AssetID != assetID))
|
|
{
|
|
LLUUID appDomain = assetID;
|
|
|
|
if (part.ParentGroup.RootPart.IsAttachment)
|
|
appDomain = part.ParentGroup.RootPart.UUID;
|
|
|
|
if (!m_AppDomains.ContainsKey(appDomain))
|
|
{
|
|
try
|
|
{
|
|
AppDomainSetup appSetup = new AppDomainSetup();
|
|
// appSetup.ApplicationBase = Path.Combine(
|
|
// "ScriptEngines",
|
|
// m_Scene.RegionInfo.RegionID.ToString());
|
|
|
|
Evidence baseEvidence = AppDomain.CurrentDomain.Evidence;
|
|
Evidence evidence = new Evidence(baseEvidence);
|
|
|
|
m_AppDomains[appDomain] =
|
|
AppDomain.CreateDomain(
|
|
m_Scene.RegionInfo.RegionID.ToString(),
|
|
evidence, appSetup);
|
|
|
|
m_AppDomains[appDomain].AssemblyResolve +=
|
|
new ResolveEventHandler(
|
|
AssemblyResolver.OnAssemblyResolve);
|
|
m_DomainScripts[appDomain] = new List<LLUUID>();
|
|
}
|
|
catch (Exception e)
|
|
{
|
|
m_log.ErrorFormat("[XEngine] Exception creating app domain:\n {0}", e.ToString());
|
|
return false;
|
|
}
|
|
}
|
|
m_DomainScripts[appDomain].Add(itemID);
|
|
|
|
ScriptInstance instance =
|
|
new ScriptInstance(this,localID,
|
|
part.UUID, itemID, assetID, assembly,
|
|
m_AppDomains[appDomain],
|
|
part.ParentGroup.RootPart.Name,
|
|
item.Name, startParam, postOnRez,
|
|
StateSource.NewRez, m_MaxScriptQueue);
|
|
|
|
m_log.DebugFormat("[XEngine] Loaded script {0}.{1}",
|
|
part.ParentGroup.RootPart.Name, item.Name);
|
|
|
|
instance.AppDomain = appDomain;
|
|
|
|
m_Scripts[itemID] = instance;
|
|
}
|
|
|
|
if (!m_PrimObjects.ContainsKey(localID))
|
|
m_PrimObjects[localID] = new List<LLUUID>();
|
|
|
|
if (!m_PrimObjects[localID].Contains(itemID))
|
|
m_PrimObjects[localID].Add(itemID);
|
|
|
|
if (!m_Assemblies.ContainsKey(assetID))
|
|
m_Assemblies[assetID] = assembly;
|
|
}
|
|
return true;
|
|
}
|
|
|
|
public void OnRemoveScript(uint localID, LLUUID itemID)
|
|
{
|
|
lock (m_Scripts)
|
|
{
|
|
// Do we even have it?
|
|
if (!m_Scripts.ContainsKey(itemID))
|
|
return;
|
|
|
|
m_AsyncCommands.RemoveScript(localID, itemID);
|
|
|
|
IScriptInstance instance=m_Scripts[itemID];
|
|
m_Scripts.Remove(itemID);
|
|
|
|
instance.ClearQueue();
|
|
instance.Stop(0);
|
|
|
|
SceneObjectPart part =
|
|
m_Scene.GetSceneObjectPart(localID);
|
|
|
|
if (part != null)
|
|
part.RemoveScriptEvents(itemID);
|
|
|
|
// Remove the script from it's prim
|
|
if (m_PrimObjects.ContainsKey(localID))
|
|
{
|
|
// Remove inventory item record
|
|
if (m_PrimObjects[localID].Contains(itemID))
|
|
m_PrimObjects[localID].Remove(itemID);
|
|
|
|
// If there are no more scripts, remove prim
|
|
if (m_PrimObjects[localID].Count == 0)
|
|
{
|
|
m_PrimObjects.Remove(localID);
|
|
}
|
|
}
|
|
|
|
m_DomainScripts[instance.AppDomain].Remove(instance.ItemID);
|
|
if (m_DomainScripts[instance.AppDomain].Count == 0)
|
|
{
|
|
m_DomainScripts.Remove(instance.AppDomain);
|
|
UnloadAppDomain(instance.AppDomain);
|
|
}
|
|
|
|
instance.RemoveState();
|
|
|
|
instance = null;
|
|
|
|
CleanAssemblies();
|
|
}
|
|
}
|
|
|
|
public void OnScriptReset(uint localID, LLUUID itemID)
|
|
{
|
|
ResetScript(itemID);
|
|
}
|
|
|
|
public void OnStartScript(uint localID, LLUUID itemID)
|
|
{
|
|
StartScript(itemID);
|
|
}
|
|
|
|
public void OnStopScript(uint localID, LLUUID itemID)
|
|
{
|
|
StopScript(itemID);
|
|
}
|
|
|
|
private void CleanAssemblies()
|
|
{
|
|
List<LLUUID> assetIDList = new List<LLUUID>(m_Assemblies.Keys);
|
|
|
|
foreach (IScriptInstance i in m_Scripts.Values)
|
|
{
|
|
if (assetIDList.Contains(i.AssetID))
|
|
assetIDList.Remove(i.AssetID);
|
|
}
|
|
|
|
foreach (LLUUID assetID in assetIDList)
|
|
{
|
|
// m_log.DebugFormat("[XEngine] Removing unreferenced assembly {0}", m_Assemblies[assetID]);
|
|
try
|
|
{
|
|
if (File.Exists(m_Assemblies[assetID]))
|
|
File.Delete(m_Assemblies[assetID]);
|
|
|
|
if (File.Exists(m_Assemblies[assetID]+".state"))
|
|
File.Delete(m_Assemblies[assetID]+".state");
|
|
|
|
if (File.Exists(m_Assemblies[assetID]+".mdb"))
|
|
File.Delete(m_Assemblies[assetID]+".mdb");
|
|
}
|
|
catch (Exception)
|
|
{
|
|
}
|
|
m_Assemblies.Remove(assetID);
|
|
}
|
|
}
|
|
|
|
private void UnloadAppDomain(LLUUID id)
|
|
{
|
|
if (m_AppDomains.ContainsKey(id))
|
|
{
|
|
AppDomain domain = m_AppDomains[id];
|
|
m_AppDomains.Remove(id);
|
|
|
|
AppDomain.Unload(domain);
|
|
domain = null;
|
|
// m_log.DebugFormat("[XEngine] Unloaded app domain {0}", id.ToString());
|
|
}
|
|
}
|
|
|
|
//
|
|
// Start processing
|
|
//
|
|
private void StartEngine(int minThreads, int maxThreads,
|
|
int idleTimeout, ThreadPriority threadPriority,
|
|
int maxScriptQueue, int stackSize)
|
|
{
|
|
m_MaxScriptQueue = maxScriptQueue;
|
|
|
|
STPStartInfo startInfo = new STPStartInfo();
|
|
startInfo.IdleTimeout = idleTimeout;
|
|
startInfo.MaxWorkerThreads = maxThreads;
|
|
startInfo.MinWorkerThreads = minThreads;
|
|
startInfo.ThreadPriority = threadPriority;
|
|
startInfo.StackSize = stackSize;
|
|
startInfo.StartSuspended = true;
|
|
|
|
m_ThreadPool = new SmartThreadPool(startInfo);
|
|
}
|
|
|
|
//
|
|
// Used by script instances to queue event handler jobs
|
|
//
|
|
public IScriptWorkItem QueueEventHandler(object parms)
|
|
{
|
|
return new XWorkItem(m_ThreadPool.QueueWorkItem(
|
|
new WorkItemCallback(this.ProcessEventHandler),
|
|
parms));
|
|
}
|
|
|
|
//
|
|
// The main script engine worker
|
|
//
|
|
private object ProcessEventHandler(object parms)
|
|
{
|
|
CultureInfo USCulture = new CultureInfo("en-US");
|
|
Thread.CurrentThread.CurrentCulture = USCulture;
|
|
|
|
IScriptInstance instance = (ScriptInstance) parms;
|
|
|
|
return instance.EventProcessor();
|
|
}
|
|
|
|
//
|
|
// Post event to an entire prim
|
|
//
|
|
public bool PostObjectEvent(uint localID, EventParams p)
|
|
{
|
|
bool result = false;
|
|
|
|
if (!m_PrimObjects.ContainsKey(localID))
|
|
return false;
|
|
|
|
foreach (LLUUID itemID in m_PrimObjects[localID])
|
|
{
|
|
if (m_Scripts.ContainsKey(itemID))
|
|
{
|
|
IScriptInstance instance = m_Scripts[itemID];
|
|
if (instance != null)
|
|
{
|
|
instance.PostEvent(p);
|
|
result = true;
|
|
}
|
|
}
|
|
}
|
|
return result;
|
|
}
|
|
|
|
//
|
|
// Post an event to a single script
|
|
//
|
|
public bool PostScriptEvent(LLUUID itemID, EventParams p)
|
|
{
|
|
if (m_Scripts.ContainsKey(itemID))
|
|
{
|
|
IScriptInstance instance = m_Scripts[itemID];
|
|
if (instance != null)
|
|
instance.PostEvent(p);
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
public Assembly OnAssemblyResolve(object sender,
|
|
ResolveEventArgs args)
|
|
{
|
|
if (!(sender is System.AppDomain))
|
|
return null;
|
|
|
|
string[] pathList = new string[] {"bin", "ScriptEngines",
|
|
Path.Combine("ScriptEngines",
|
|
m_Scene.RegionInfo.RegionID.ToString())};
|
|
|
|
string assemblyName = args.Name;
|
|
if (assemblyName.IndexOf(",") != -1)
|
|
assemblyName = args.Name.Substring(0, args.Name.IndexOf(","));
|
|
|
|
foreach (string s in pathList)
|
|
{
|
|
string path = Path.Combine(Directory.GetCurrentDirectory(),
|
|
Path.Combine(s, assemblyName))+".dll";
|
|
|
|
if (File.Exists(path))
|
|
return Assembly.LoadFrom(path);
|
|
}
|
|
|
|
return null;
|
|
}
|
|
|
|
private IScriptInstance GetInstance(LLUUID itemID)
|
|
{
|
|
IScriptInstance instance;
|
|
lock (m_Scripts)
|
|
{
|
|
if (!m_Scripts.ContainsKey(itemID))
|
|
return null;
|
|
instance = m_Scripts[itemID];
|
|
}
|
|
return instance;
|
|
}
|
|
|
|
public void SetScriptState(LLUUID itemID, bool running)
|
|
{
|
|
IScriptInstance instance = GetInstance(itemID);
|
|
if (instance != null)
|
|
{
|
|
if (running)
|
|
instance.Start();
|
|
else
|
|
instance.Stop(100);
|
|
}
|
|
}
|
|
|
|
public bool GetScriptState(LLUUID itemID)
|
|
{
|
|
IScriptInstance instance = GetInstance(itemID);
|
|
if (instance != null)
|
|
return instance.Running;
|
|
return false;
|
|
}
|
|
|
|
public void ApiResetScript(LLUUID itemID)
|
|
{
|
|
IScriptInstance instance = GetInstance(itemID);
|
|
if (instance != null)
|
|
instance.ApiResetScript();
|
|
}
|
|
|
|
public void ResetScript(LLUUID itemID)
|
|
{
|
|
IScriptInstance instance = GetInstance(itemID);
|
|
if (instance != null)
|
|
instance.ResetScript();
|
|
}
|
|
|
|
public void StartScript(LLUUID itemID)
|
|
{
|
|
IScriptInstance instance = GetInstance(itemID);
|
|
if (instance != null)
|
|
instance.Start();
|
|
}
|
|
|
|
public void StopScript(LLUUID itemID)
|
|
{
|
|
IScriptInstance instance = GetInstance(itemID);
|
|
if (instance != null)
|
|
instance.Stop(0);
|
|
}
|
|
|
|
public DetectParams GetDetectParams(LLUUID itemID, int idx)
|
|
{
|
|
IScriptInstance instance = GetInstance(itemID);
|
|
if (instance != null)
|
|
return instance.GetDetectParams(idx);
|
|
return null;
|
|
}
|
|
|
|
public LLUUID GetDetectID(LLUUID itemID, int idx)
|
|
{
|
|
IScriptInstance instance = GetInstance(itemID);
|
|
if (instance != null)
|
|
return instance.GetDetectID(idx);
|
|
return LLUUID.Zero;
|
|
}
|
|
|
|
public void SetState(LLUUID itemID, string newState)
|
|
{
|
|
IScriptInstance instance = GetInstance(itemID);
|
|
if (instance == null)
|
|
return;
|
|
instance.SetState(newState);
|
|
}
|
|
public string GetState(LLUUID itemID)
|
|
{
|
|
IScriptInstance instance = GetInstance(itemID);
|
|
if (instance == null)
|
|
return "default";
|
|
return instance.State;
|
|
}
|
|
|
|
public int GetStartParameter(LLUUID itemID)
|
|
{
|
|
IScriptInstance instance = GetInstance(itemID);
|
|
if (instance == null)
|
|
return 0;
|
|
return instance.StartParam;
|
|
}
|
|
|
|
public bool GetScriptRunning(LLUUID objectID, LLUUID itemID)
|
|
{
|
|
return GetScriptState(itemID);
|
|
}
|
|
}
|
|
}
|