Remove all the subclassing complexity and script server interfaces from

DNE and move all of DNE into the DotNetEngine directory. Remove references
that would cause the script runtime to load the entire engine + scene into
each script appdomain. This might help DNE memory consumption.

8 files changed, 721 insertions, 24 deletions

diff --git a/OpenSim/Region/ScriptEngine/Common/ScriptEngineBase/AppDomainManager.cs b/OpenSim/Region/ScriptEngine/DotNetEngine/AppDomainManager.cs
index 262d75f..969a05e 100644
--- a/OpenSim/Region/ScriptEngine/Common/ScriptEngineBase/AppDomainManager.cs
+++ b/OpenSim/Region/ScriptEngine/DotNetEngine/AppDomainManager.cs
@@ -29,8 +29,9 @@ using System;
 using System.Collections;
 using System.Collections.Generic;
 using System.Reflection;
+using OpenSim.Region.ScriptEngine.Common;
 
-namespace OpenSim.Region.ScriptEngine.Common.ScriptEngineBase
+namespace OpenSim.Region.ScriptEngine.DotNetEngine
 {
     public class AppDomainManager : iScriptEngineFunctionModule
     {
diff --git a/OpenSim/Region/ScriptEngine/Common/ScriptEngineBase/Common.cs b/OpenSim/Region/ScriptEngine/DotNetEngine/Common.cs
index d5ec9b4..3d9e19b 100644
--- a/OpenSim/Region/ScriptEngine/Common/ScriptEngineBase/Common.cs
+++ b/OpenSim/Region/ScriptEngine/DotNetEngine/Common.cs
@@ -25,7 +25,7 @@
  * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 
-namespace OpenSim.Region.ScriptEngine.Common.ScriptEngineBase
+namespace OpenSim.Region.ScriptEngine.DotNetEngine
 {
     public static class Common
     {
diff --git a/OpenSim/Region/ScriptEngine/DotNetEngine/Compiler/LSL/Compiler.cs b/OpenSim/Region/ScriptEngine/DotNetEngine/Compiler/LSL/Compiler.cs
index b50e823..4cb74fa 100644
--- a/OpenSim/Region/ScriptEngine/DotNetEngine/Compiler/LSL/Compiler.cs
+++ b/OpenSim/Region/ScriptEngine/DotNetEngine/Compiler/LSL/Compiler.cs
@@ -83,8 +83,8 @@ namespace OpenSim.Region.ScriptEngine.DotNetEngine.Compiler.LSL
         private static int instanceID = new Random().Next(0, int.MaxValue);                 // Unique number to use on our compiled files
         private static UInt64 scriptCompileCounter = 0;                                     // And a counter
 
-        public Common.ScriptEngineBase.ScriptEngine m_scriptEngine;
-        public Compiler(Common.ScriptEngineBase.ScriptEngine scriptEngine)
+        public ScriptEngine m_scriptEngine;
+        public Compiler(ScriptEngine scriptEngine)
         {
             m_scriptEngine = scriptEngine;
             ReadConfig();
diff --git a/OpenSim/Region/ScriptEngine/Common/ScriptEngineBase/EventQueueManager.cs b/OpenSim/Region/ScriptEngine/DotNetEngine/EventQueueManager.cs
index b13ab21..7805d67 100644
--- a/OpenSim/Region/ScriptEngine/Common/ScriptEngineBase/EventQueueManager.cs
+++ b/OpenSim/Region/ScriptEngine/DotNetEngine/EventQueueManager.cs
@@ -31,7 +31,7 @@ using System.Collections.Generic;
 using OpenMetaverse;
 using OpenSim.Region.ScriptEngine.Shared;
 
-namespace OpenSim.Region.ScriptEngine.Common.ScriptEngineBase
+namespace OpenSim.Region.ScriptEngine.DotNetEngine
 {
     /// <summary>
     /// EventQueueManager handles event queues
diff --git a/OpenSim/Region/ScriptEngine/Common/ScriptEngineBase/EventQueueThreadClass.cs b/OpenSim/Region/ScriptEngine/DotNetEngine/EventQueueThreadClass.cs
index 7f52793..db3f89f 100644
--- a/OpenSim/Region/ScriptEngine/Common/ScriptEngineBase/EventQueueThreadClass.cs
+++ b/OpenSim/Region/ScriptEngine/DotNetEngine/EventQueueThreadClass.cs
@@ -36,7 +36,7 @@ using log4net;
 using OpenSim.Framework;
 using OpenSim.Region.Environment.Scenes.Scripting;
 
-namespace OpenSim.Region.ScriptEngine.Common.ScriptEngineBase
+namespace OpenSim.Region.ScriptEngine.DotNetEngine
 {
     /// <summary>
     /// Because every thread needs some data set for it (time started to execute current function), it will do its work within a class
@@ -103,7 +103,7 @@ namespace OpenSim.Region.ScriptEngine.Common.ScriptEngineBase
                             break;
                         default:
                             MyThreadPriority = ThreadPriority.BelowNormal; // Default
-                            m_ScriptEngine.Log.Error("[ScriptEngineBase]: Unknown priority type \"" + pri +
+                            m_ScriptEngine.Log.Error("[ScriptEngine.DotNetEngine]: Unknown priority type \"" + pri +
                                                      "\" in config file. Defaulting to \"BelowNormal\".");
                             break;
                     }
diff --git a/OpenSim/Region/ScriptEngine/Common/ScriptEngineBase/MaintenanceThread.cs b/OpenSim/Region/ScriptEngine/DotNetEngine/MaintenanceThread.cs
index ef87b2f..6c1528f 100644
--- a/OpenSim/Region/ScriptEngine/Common/ScriptEngineBase/MaintenanceThread.cs
+++ b/OpenSim/Region/ScriptEngine/DotNetEngine/MaintenanceThread.cs
@@ -32,7 +32,7 @@ using System.Threading;
 using log4net;
 using OpenSim.Framework;
 
-namespace OpenSim.Region.ScriptEngine.Common.ScriptEngineBase
+namespace OpenSim.Region.ScriptEngine.DotNetEngine
 {
     /// <summary>
     /// This class does maintenance on script engine.
diff --git a/OpenSim/Region/ScriptEngine/DotNetEngine/ScriptEngine.cs b/OpenSim/Region/ScriptEngine/DotNetEngine/ScriptEngine.cs
index e785cc0..7ec71c2 100644
--- a/OpenSim/Region/ScriptEngine/DotNetEngine/ScriptEngine.cs
+++ b/OpenSim/Region/ScriptEngine/DotNetEngine/ScriptEngine.cs
@@ -26,29 +26,281 @@
  */
 
 using System;
+using System.Collections.Generic;
+using System.Reflection;
+using log4net;
 using Nini.Config;
+using OpenSim.Region.Interfaces;
+using OpenSim.Region.Environment.Interfaces;
 using OpenSim.Region.Environment.Scenes;
+using OpenSim.Region.ScriptEngine.Interfaces;
+using OpenMetaverse;
+using OpenSim.Region.ScriptEngine.Shared;
+using OpenSim.Region.ScriptEngine.Common;
 
 namespace OpenSim.Region.ScriptEngine.DotNetEngine
 {
     [Serializable]
-    public class ScriptEngine : Common.ScriptEngineBase.ScriptEngine
+    public class ScriptEngine : IRegionModule, IEventReceiver, IScriptModule
     {
-        // We need to override a few things for our DotNetEngine
-        public override void Initialise(Scene scene, IConfigSource config)
+        private static readonly ILog m_log = LogManager.GetLogger(MethodBase.GetCurrentMethod().DeclaringType);
+
+        public static List<ScriptEngine> ScriptEngines = new List<ScriptEngine>();
+        private Scene m_Scene;
+        public Scene World
         {
-            ConfigSource = config;
-            InitializeEngine(scene, config, true, GetScriptManager());
+            get { return m_Scene; }
         }
+        public EventManager m_EventManager;                         // Handles and queues incoming events from OpenSim
+        public EventQueueManager m_EventQueueManager;               // Executes events, handles script threads
+        public ScriptManager m_ScriptManager;                       // Load, unload and execute scripts
+        public AppDomainManager m_AppDomainManager;                 // Handles loading/unloading of scripts into AppDomains
+        public static MaintenanceThread m_MaintenanceThread;        // Thread that does different kinds of maintenance, for example refreshing config and killing scripts that has been running too long
+
+        public IConfigSource ConfigSource;
+        public IConfig ScriptConfigSource;
+        private bool m_enabled = false;
 
-        public override Common.ScriptEngineBase.ScriptManager _GetScriptManager()
+        public IConfig Config
         {
-            return new ScriptManager(this);
+            get { return ScriptConfigSource; }
         }
 
-        public override string ScriptEngineName
+        /// <summary>
+        /// How many seconds between re-reading config-file. 0 = never. ScriptEngine will try to adjust to new config changes.
+        /// </summary>
+        public int RefreshConfigFileSeconds {
+            get { return (int)(RefreshConfigFilens / 10000000); }
+            set { RefreshConfigFilens = value * 10000000; }
+        }
+        public long RefreshConfigFilens;
+
+        public string ScriptEngineName
         {
             get { return "ScriptEngine.DotNetEngine"; }
         }
+        
+        public ILog Log
+        {
+            get { return m_log; }
+        }
+
+        public ScriptEngine()
+        {
+            Common.mySE = this;                 // For logging, just need any instance, doesn't matter
+            lock (ScriptEngines)
+            {
+                ScriptEngines.Add(this); // Keep a list of ScriptEngines for shared threads to process all instances
+            }
+        }
+
+        public void Initialise(Scene Sceneworld, IConfigSource config)
+        {
+            m_log.Info("[" + ScriptEngineName + "]: ScriptEngine initializing");
+
+            ConfigSource = config;
+            m_Scene = Sceneworld;
+
+            // Make sure we have config
+            if (ConfigSource.Configs[ScriptEngineName] == null)
+                ConfigSource.AddConfig(ScriptEngineName);
+            ScriptConfigSource = ConfigSource.Configs[ScriptEngineName];
+
+            m_enabled = ScriptConfigSource.GetBoolean("Enabled", true);
+            if (!m_enabled)
+                return;
+
+            //m_log.Info("[" + ScriptEngineName + "]: InitializeEngine");
+
+            // Create all objects we'll be using
+            m_EventQueueManager = new EventQueueManager(this);
+            m_EventManager = new EventManager(this, true);
+            // We need to start it
+            m_ScriptManager = new ScriptManager(this);
+            m_ScriptManager.Setup();
+            m_AppDomainManager = new AppDomainManager(this);
+            if (m_MaintenanceThread == null)
+                m_MaintenanceThread = new MaintenanceThread();
+
+            m_log.Info("[" + ScriptEngineName + "]: Reading configuration from config section \"" + ScriptEngineName + "\"");
+            ReadConfig();
+
+            m_Scene.StackModuleInterface<IScriptModule>(this);
+        }
+
+        public void PostInitialise()
+        {
+            if (!m_enabled)
+                return;
+
+            m_EventManager.HookUpEvents();
+
+            m_ScriptManager.Start();
+        }
+
+        public void Shutdown()
+        {
+            // We are shutting down
+            lock (ScriptEngines)
+            {
+                ScriptEngines.Remove(this);
+            }
+        }
+
+        public void ReadConfig()
+        {
+#if DEBUG
+            //m_log.Debug("[" + ScriptEngineName + "]: Refreshing configuration for all modules");
+#endif
+            RefreshConfigFileSeconds = ScriptConfigSource.GetInt("RefreshConfig", 30);
+
+
+        // Create a new object (probably not necessary?)
+//            ScriptConfigSource = ConfigSource.Configs[ScriptEngineName];
+
+            if (m_EventQueueManager != null) m_EventQueueManager.ReadConfig();
+            if (m_EventManager != null) m_EventManager.ReadConfig();
+            if (m_ScriptManager != null) m_ScriptManager.ReadConfig();
+            if (m_AppDomainManager != null) m_AppDomainManager.ReadConfig();
+            if (m_MaintenanceThread != null) m_MaintenanceThread.ReadConfig();
+        }
+
+        #region IRegionModule
+
+        public void Close()
+        {
+        }
+
+        public string Name
+        {
+            get { return "Common." + ScriptEngineName; }
+        }
+
+        public bool IsSharedModule
+        {
+            get { return false; }
+        }
+
+        public bool PostObjectEvent(uint localID, EventParams p)
+        {
+            return m_EventQueueManager.AddToObjectQueue(localID, p.EventName, p.DetectParams, p.Params);
+        }
+
+        public bool PostScriptEvent(UUID itemID, EventParams p)
+        {
+            uint localID = m_ScriptManager.GetLocalID(itemID);
+            return m_EventQueueManager.AddToScriptQueue(localID, itemID, p.EventName, p.DetectParams, p.Params);
+        }
+
+        public DetectParams GetDetectParams(UUID itemID, int number)
+        {
+            uint localID = m_ScriptManager.GetLocalID(itemID);
+            if (localID == 0)
+                return null;
+
+            IScript Script = m_ScriptManager.GetScript(localID, itemID);
+
+            if (Script == null)
+                return null;
+
+            DetectParams[] det = m_ScriptManager.GetDetectParams(Script);
+
+            if (number < 0 || number >= det.Length)
+                return null;
+
+            return det[number];
+        }
+
+        public int GetStartParameter(UUID itemID)
+        {
+            return 0;
+        }
+        #endregion
+
+        public void SetState(UUID itemID, string state)
+        {
+            uint localID = m_ScriptManager.GetLocalID(itemID);
+            if (localID == 0)
+                return;
+
+            IScript Script = m_ScriptManager.GetScript(localID, itemID);
+
+            if (Script == null)
+                return;
+
+            string currentState = Script.State;
+
+            if (currentState != state)
+            {
+                try
+                {
+                    m_EventManager.state_exit(localID);
+
+                }
+                catch (AppDomainUnloadedException)
+                {
+                    Console.WriteLine("[SCRIPT]: state change called when script was unloaded.  Nothing to worry about, but noting the occurance");
+                }
+
+                Script.State = state;
+
+                try
+                {
+                    int eventFlags = m_ScriptManager.GetStateEventFlags(localID, itemID);
+                    SceneObjectPart part = m_Scene.GetSceneObjectPart(itemID);
+                    if (part != null)
+                        part.SetScriptEvents(itemID, eventFlags);
+                    m_EventManager.state_entry(localID);
+                }
+                catch (AppDomainUnloadedException)
+                {
+                    Console.WriteLine("[SCRIPT]: state change called when script was unloaded.  Nothing to worry about, but noting the occurance");
+                }
+            }
+        }
+
+        public bool GetScriptState(UUID itemID)
+        {
+            uint localID = m_ScriptManager.GetLocalID(itemID);
+            if (localID == 0)
+                return false;
+
+            IScript script = m_ScriptManager.GetScript(localID, itemID);
+            if (script == null)
+                return false;
+
+            return script.Exec.Running?true:false;
+        }
+
+        public void SetScriptState(UUID itemID, bool state)
+        {
+            uint localID = m_ScriptManager.GetLocalID(itemID);
+            if (localID == 0)
+                return;
+
+            IScript script = m_ScriptManager.GetScript(localID, itemID);
+            if (script == null)
+                return;
+
+            script.Exec.Running = state;
+        }
+
+        public void ApiResetScript(UUID itemID)
+        {
+            uint localID = m_ScriptManager.GetLocalID(itemID);
+            if (localID == 0)
+                return;
+
+            m_ScriptManager.ResetScript(localID, itemID);
+        }
+
+        public void ResetScript(UUID itemID)
+        {
+            uint localID = m_ScriptManager.GetLocalID(itemID);
+            if (localID == 0)
+                return;
+
+            m_ScriptManager.ResetScript(localID, itemID);
+        }
     }
 }
diff --git a/OpenSim/Region/ScriptEngine/DotNetEngine/ScriptManager.cs b/OpenSim/Region/ScriptEngine/DotNetEngine/ScriptManager.cs
index 8ff3bfd..12a8fe4 100644
--- a/OpenSim/Region/ScriptEngine/DotNetEngine/ScriptManager.cs
+++ b/OpenSim/Region/ScriptEngine/DotNetEngine/ScriptManager.cs
@@ -34,22 +34,66 @@ using OpenSim.Region.Environment.Scenes;
 using OpenSim.Region.ScriptEngine.Common;
 using OpenSim.Region.ScriptEngine.Shared;
 using OpenSim.Region.ScriptEngine.Shared.Api;
-using OpenSim.Region.ScriptEngine.Common.ScriptEngineBase;
+using System.Collections.Generic;
+using System.IO;
+using System.Runtime.Serialization.Formatters.Binary;
+using System.Threading;
 
 namespace OpenSim.Region.ScriptEngine.DotNetEngine
 {
-    public class ScriptManager : Common.ScriptEngineBase.ScriptManager
+    public class ScriptManager
     {
         private static readonly ILog m_log = LogManager.GetLogger(MethodBase.GetCurrentMethod().DeclaringType);
 
-        public ScriptManager(Common.ScriptEngineBase.ScriptEngine scriptEngine)
-            : base(scriptEngine)
+        #region Declares
+
+        private Thread scriptLoadUnloadThread;
+        private static Thread staticScriptLoadUnloadThread;
+        // private int scriptLoadUnloadThread_IdleSleepms;
+        private Queue<LUStruct> LUQueue = new Queue<LUStruct>();
+        private static bool PrivateThread;
+        private int LoadUnloadMaxQueueSize;
+        private Object scriptLock = new Object();
+        private bool m_started = false;
+        private Dictionary<IScript, DetectParams[]> detparms = new Dictionary<IScript, DetectParams[]>();
+
+        // Load/Unload structure
+        private struct LUStruct
+        {
+            public uint localID;
+            public UUID itemID;
+            public string script;
+            public LUType Action;
+            public int startParam;
+            public bool postOnRez;
+        }
+
+        private enum LUType
+        {
+            Unknown = 0,
+            Load = 1,
+            Unload = 2
+        }
+
+        // Xantor 20080525: Keep a list of compiled scripts this session for reuse
+        public Dictionary<UUID, String> scriptList = new Dictionary<UUID, string>();
+
+        // Object<string, Script<string, script>>
+        // IMPORTANT: Types and MemberInfo-derived objects require a LOT of memory.
+        // Instead use RuntimeTypeHandle, RuntimeFieldHandle and RunTimeHandle (IntPtr) instead!
+        public Dictionary<uint, Dictionary<UUID, IScript>> Scripts =
+            new Dictionary<uint, Dictionary<UUID, IScript>>();
+
+
+        public Scene World
         {
-            base.m_scriptEngine = scriptEngine;
+            get { return m_scriptEngine.World; }
         }
+
+        #endregion
         private Compiler.LSL.Compiler LSLCompiler;
 
-        public override void Initialize()
+        public void Initialize()
         {
             // Create our compiler
             LSLCompiler = new Compiler.LSL.Compiler(m_scriptEngine);
@@ -62,7 +106,7 @@ namespace OpenSim.Region.ScriptEngine.DotNetEngine
         // PROVIDE SCRIPT WITH ITS INTERFACE TO OpenSim
 
 
-        public override void _StartScript(uint localID, UUID itemID, string Script, int startParam, bool postOnRez)
+        public void _StartScript(uint localID, UUID itemID, string Script, int startParam, bool postOnRez)
         {
             m_log.DebugFormat(
                 "[{0}]: ScriptManager StartScript: localID: {1}, itemID: {2}",
@@ -173,7 +217,7 @@ namespace OpenSim.Region.ScriptEngine.DotNetEngine
             }
         }
 
-        public override void _StopScript(uint localID, UUID itemID)
+        public void _StopScript(uint localID, UUID itemID)
         {
             IScript LSLBC = GetScript(localID, itemID);
             if (LSLBC == null)
@@ -202,5 +246,405 @@ namespace OpenSim.Region.ScriptEngine.DotNetEngine
                                             ": " + e.ToString());
             }
         }
+
+        public void ReadConfig()
+        {
+            // scriptLoadUnloadThread_IdleSleepms = m_scriptEngine.ScriptConfigSource.GetInt("ScriptLoadUnloadLoopms", 30);
+            // TODO: Requires sharing of all ScriptManagers to single thread
+            PrivateThread = true; // m_scriptEngine.ScriptConfigSource.GetBoolean("PrivateScriptLoadUnloadThread", false);
+            LoadUnloadMaxQueueSize = m_scriptEngine.ScriptConfigSource.GetInt("LoadUnloadMaxQueueSize", 100);
+        }
+
+        #region Object init/shutdown
+
+        public ScriptEngine m_scriptEngine;
+
+        public ScriptManager(ScriptEngine scriptEngine)
+        {
+            m_scriptEngine = scriptEngine;
+        }
+        public void Setup()
+        {
+            ReadConfig();
+            Initialize();
+        }
+        public void Start()
+        {
+            m_started = true;
+
+
+            AppDomain.CurrentDomain.AssemblyResolve += new ResolveEventHandler(CurrentDomain_AssemblyResolve);
+
+            //
+            // CREATE THREAD
+            // Private or shared
+            //
+            if (PrivateThread)
+            {
+                // Assign one thread per region
+                //scriptLoadUnloadThread = StartScriptLoadUnloadThread();
+            }
+            else
+            {
+                // Shared thread - make sure one exist, then assign it to the private
+                if (staticScriptLoadUnloadThread == null)
+                {
+                    //staticScriptLoadUnloadThread = StartScriptLoadUnloadThread();
+                }
+                scriptLoadUnloadThread = staticScriptLoadUnloadThread;
+            }
+        }
+
+// TODO: unused
+//        private static int privateThreadCount = 0;
+//         private Thread StartScriptLoadUnloadThread()
+//         {
+//             Thread t = new Thread(ScriptLoadUnloadThreadLoop);
+//             string name = "ScriptLoadUnloadThread:";
+//             if (PrivateThread)
+//             {
+//                 name += "Private:" + privateThreadCount;
+//                 privateThreadCount++;
+//             }
+//             else
+//             {
+//                 name += "Shared";
+//             }
+//             t.Name = name;
+//             t.IsBackground = true;
+//             t.Priority = ThreadPriority.Normal;
+//             t.Start();
+//             OpenSim.Framework.ThreadTracker.Add(t);
+//             return t;
+//         }
+
+        ~ScriptManager()
+        {
+            // Abort load/unload thread
+            try
+            {
+                //PleaseShutdown = true;
+                //Thread.Sleep(100);
+                if (scriptLoadUnloadThread != null && scriptLoadUnloadThread.IsAlive == true)
+                {
+                    scriptLoadUnloadThread.Abort();
+                    //scriptLoadUnloadThread.Join();
+                }
+            }
+            catch
+            {
+            }
+        }
+
+        #endregion
+
+        #region Load / Unload scripts (Thread loop)
+
+// TODO: unused
+//         private void ScriptLoadUnloadThreadLoop()
+//         {
+//             try
+//             {
+//                 while (true)
+//                 {
+//                     if (LUQueue.Count == 0)
+//                         Thread.Sleep(scriptLoadUnloadThread_IdleSleepms);
+//                     //if (PleaseShutdown)
+//                     //    return;
+//                     DoScriptLoadUnload();
+//                 }
+//             }
+//             catch (ThreadAbortException tae)
+//             {
+//                 string a = tae.ToString();
+//                 a = String.Empty;
+//                 // Expected
+//             }
+//         }
+
+        public void DoScriptLoadUnload()
+        {
+            if (!m_started)
+                return;
+
+            lock (LUQueue)
+            {
+                if (LUQueue.Count > 0)
+                {
+m_scriptEngine.Log.InfoFormat("[{0}]: Loading script", m_scriptEngine.ScriptEngineName);
+                    LUStruct item = LUQueue.Dequeue();
+
+                    if (item.Action == LUType.Unload)
+                    {
+                        _StopScript(item.localID, item.itemID);
+                        RemoveScript(item.localID, item.itemID);
+                    }
+                    else if (item.Action == LUType.Load)
+                    {
+                        _StartScript(item.localID, item.itemID, item.script, item.startParam, item.postOnRez);
+                    }
+                }
+            }
+        }
+
+        #endregion
+
+        #region Helper functions
+
+        private static Assembly CurrentDomain_AssemblyResolve(object sender, ResolveEventArgs args)
+        {
+            //Console.WriteLine("ScriptManager.CurrentDomain_AssemblyResolve: " + args.Name);
+            return Assembly.GetExecutingAssembly().FullName == args.Name ? Assembly.GetExecutingAssembly() : null;
+        }
+
+        #endregion
+
+
+
+        #region Start/Stop/Reset script
+
+        // private readonly Object startStopLock = new Object();
+
+        /// <summary>
+        /// Fetches, loads and hooks up a script to an objects events
+        /// </summary>
+        /// <param name="itemID"></param>
+        /// <param name="localID"></param>
+        public void StartScript(uint localID, UUID itemID, string Script, int startParam, bool postOnRez)
+        {
+            lock (LUQueue)
+            {
+                if ((LUQueue.Count >= LoadUnloadMaxQueueSize) && m_started)
+                {
+                    m_scriptEngine.Log.Error("[" + m_scriptEngine.ScriptEngineName + "]: ERROR: Load/unload queue item count is at " + LUQueue.Count + ". Config variable \"LoadUnloadMaxQueueSize\" is set to " + LoadUnloadMaxQueueSize + ", so ignoring new script.");
+                    return;
+                }
+
+                LUStruct ls = new LUStruct();
+                ls.localID = localID;
+                ls.itemID = itemID;
+                ls.script = Script;
+                ls.Action = LUType.Load;
+                ls.startParam = startParam;
+                ls.postOnRez = postOnRez;
+                LUQueue.Enqueue(ls);
+m_scriptEngine.Log.InfoFormat("[{0}]: Queued script for load", m_scriptEngine.ScriptEngineName);
+            }
+        }
+
+        /// <summary>
+        /// Disables and unloads a script
+        /// </summary>
+        /// <param name="localID"></param>
+        /// <param name="itemID"></param>
+        public void StopScript(uint localID, UUID itemID)
+        {
+            LUStruct ls = new LUStruct();
+            ls.localID = localID;
+            ls.itemID = itemID;
+            ls.Action = LUType.Unload;
+            ls.startParam = 0;
+            ls.postOnRez = false;
+            lock (LUQueue)
+            {
+                LUQueue.Enqueue(ls);
+            }
+        }
+
+        // Create a new instance of the compiler (reuse)
+        //private Compiler.LSL.Compiler LSLCompiler = new Compiler.LSL.Compiler();
+
+
+        #endregion
+
+        #region Perform event execution in script
+
+        /// <summary>
+        /// Execute a LL-event-function in Script
+        /// </summary>
+        /// <param name="localID">Object the script is located in</param>
+        /// <param name="itemID">Script ID</param>
+        /// <param name="FunctionName">Name of function</param>
+        /// <param name="args">Arguments to pass to function</param>
+        internal void ExecuteEvent(uint localID, UUID itemID, string FunctionName, DetectParams[] qParams, object[] args)
+        {
+            //cfk 2-7-08 dont need this right now and the default Linux build has DEBUG defined
+            ///#if DEBUG
+            ///            Console.WriteLine("ScriptEngine: Inside ExecuteEvent for event " + FunctionName);
+            ///#endif
+            // Execute a function in the script
+            //m_scriptEngine.Log.Info("[" + ScriptEngineName + "]: Executing Function localID: " + localID + ", itemID: " + itemID + ", FunctionName: " + FunctionName);
+            //ScriptBaseInterface Script = (ScriptBaseInterface)GetScript(localID, itemID);
+            IScript Script = GetScript(localID, itemID);
+            if (Script == null)
+            {
+                return;
+            }
+            //cfk 2-7-08 dont need this right now and the default Linux build has DEBUG defined
+            ///#if DEBUG
+            ///            Console.WriteLine("ScriptEngine: Executing event: " + FunctionName);
+            ///#endif
+            // Must be done in correct AppDomain, so leaving it up to the script itself
+            detparms[Script] = qParams;
+            Script.Exec.ExecuteEvent(FunctionName, args);
+            detparms.Remove(Script);
+        }
+
+        public uint GetLocalID(UUID itemID)
+        {
+            foreach (KeyValuePair<uint, Dictionary<UUID, IScript> > k in Scripts)
+            {
+                if (k.Value.ContainsKey(itemID))
+                    return k.Key;
+            }
+            return 0;
+        }
+
+        public int GetStateEventFlags(uint localID, UUID itemID)
+        {
+            // Console.WriteLine("GetStateEventFlags for <" + localID + "," + itemID + ">");
+            try
+            {
+                IScript Script = GetScript(localID, itemID);
+                if (Script == null)
+                {
+                    return 0;
+                }
+                ExecutorBase.scriptEvents evflags = Script.Exec.GetStateEventFlags();
+                return (int)evflags;
+            }
+            catch (Exception)
+            {
+            }
+
+            return 0;
+        }
+
+
+        #endregion
+
+        #region Internal functions to keep track of script
+
+        public List<UUID> GetScriptKeys(uint localID)
+        {
+            if (Scripts.ContainsKey(localID) == false)
+                return new List<UUID>();
+
+            Dictionary<UUID, IScript> Obj;
+            Scripts.TryGetValue(localID, out Obj);
+
+            return new List<UUID>(Obj.Keys);
+        }
+
+        public IScript GetScript(uint localID, UUID itemID)
+        {
+            lock (scriptLock)
+            {
+                IScript Script = null;
+
+                if (Scripts.ContainsKey(localID) == false)
+                    return null;
+
+                Dictionary<UUID, IScript> Obj;
+                Scripts.TryGetValue(localID, out Obj);
+                if (Obj.ContainsKey(itemID) == false)
+                    return null;
+
+                // Get script
+                Obj.TryGetValue(itemID, out Script);
+                return Script;
+            }
+        }
+
+        public void SetScript(uint localID, UUID itemID, IScript Script)
+        {
+            lock (scriptLock)
+            {
+                // Create object if it doesn't exist
+                if (Scripts.ContainsKey(localID) == false)
+                {
+                    Scripts.Add(localID, new Dictionary<UUID, IScript>());
+                }
+
+                // Delete script if it exists
+                Dictionary<UUID, IScript> Obj;
+                Scripts.TryGetValue(localID, out Obj);
+                if (Obj.ContainsKey(itemID) == true)
+                    Obj.Remove(itemID);
+
+                // Add to object
+                Obj.Add(itemID, Script);
+            }
+        }
+
+        public void RemoveScript(uint localID, UUID itemID)
+        {
+            if (localID == 0)
+                localID = GetLocalID(itemID);
+
+            // Don't have that object?
+            if (Scripts.ContainsKey(localID) == false)
+                return;
+
+            // Delete script if it exists
+            Dictionary<UUID, IScript> Obj;
+            Scripts.TryGetValue(localID, out Obj);
+            if (Obj.ContainsKey(itemID) == true)
+                Obj.Remove(itemID);
+        }
+
+        #endregion
+
+
+        public void ResetScript(uint localID, UUID itemID)
+        {
+            IScript s = GetScript(localID, itemID);
+            string script = s.Source;
+            StopScript(localID, itemID);
+            SceneObjectPart part = World.GetSceneObjectPart(localID);
+            part.GetInventoryItem(itemID).PermsMask = 0;
+            part.GetInventoryItem(itemID).PermsGranter = UUID.Zero;
+            StartScript(localID, itemID, script, s.StartParam, false);
+        }
+
+
+        #region Script serialization/deserialization
+
+        public void GetSerializedScript(uint localID, UUID itemID)
+        {
+            // Serialize the script and return it
+            // Should not be a problem
+            FileStream fs = File.Create("SERIALIZED_SCRIPT_" + itemID);
+            BinaryFormatter b = new BinaryFormatter();
+            b.Serialize(fs, GetScript(localID, itemID));
+            fs.Close();
+        }
+
+        public void PutSerializedScript(uint localID, UUID itemID)
+        {
+            // Deserialize the script and inject it into an AppDomain
+
+            // How to inject into an AppDomain?
+        }
+
+        #endregion
+
+        ///// <summary>
+        ///// If set to true then threads and stuff should try to make a graceful exit
+        ///// </summary>
+        //public bool PleaseShutdown
+        //{
+        //    get { return _PleaseShutdown; }
+        //    set { _PleaseShutdown = value; }
+        //}
+        //private bool _PleaseShutdown = false;
+        
+        public DetectParams[] GetDetectParams(IScript script)
+        {
+            if (detparms.ContainsKey(script))
+                return detparms[script];
+
+            return null;
+        }
     }
 }