1 files changed, 452 insertions, 8 deletions

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;
+        }
     }
 }