1 files changed, 400 insertions, 129 deletions

diff --git a/OpenSim/Region/ScriptEngine/XEngine/XEngine.cs b/OpenSim/Region/ScriptEngine/XEngine/XEngine.cs
index 1831c39..466c190 100644..100755
--- a/OpenSim/Region/ScriptEngine/XEngine/XEngine.cs
+++ b/OpenSim/Region/ScriptEngine/XEngine/XEngine.cs
@@ -43,6 +43,7 @@ using OpenMetaverse.StructuredData;
 using log4net;
 using Nini.Config;
 using Amib.Threading;
+using Mono.Addins;
 using OpenSim.Framework;
 using OpenSim.Framework.Console;
 using OpenSim.Region.Framework.Scenes;
@@ -61,6 +62,7 @@ using ScriptCompileQueue = OpenSim.Framework.LocklessQueue<object[]>;
 
 namespace OpenSim.Region.ScriptEngine.XEngine
 {
+    [Extension(Path = "/OpenSim/RegionModules", NodeName = "RegionModule", Id = "XEngine")]
     public class XEngine : INonSharedRegionModule, IScriptModule, IScriptEngine
     {
         private static readonly ILog m_log = LogManager.GetLogger(MethodBase.GetCurrentMethod().DeclaringType);
@@ -71,7 +73,13 @@ namespace OpenSim.Region.ScriptEngine.XEngine
         /// <remarks>
         /// If DebugLevel >= 1, then we log every time that a script is started.
         /// </remarks>
-//        public int DebugLevel { get; set; }
+        public int DebugLevel { get; set; }
+
+        /// <summary>
+        /// A parameter to allow us to notify the log if at least one script has a compilation that is not compatible
+        /// with ScriptStopStrategy.
+        /// </summary>
+        public bool HaveNotifiedLogOfScriptStopMistmatch { get; private set; }
 
         private SmartThreadPool m_ThreadPool;
         private int m_MaxScriptQueue;
@@ -87,6 +95,12 @@ namespace OpenSim.Region.ScriptEngine.XEngine
         /// </summary>
         private int m_StartDelay;
 
+        /// <summary>
+        /// Are we stopping scripts co-operatively by inserting checks in them at C# compile time (true) or aborting
+        /// their threads (false)?
+        /// </summary>
+        private bool m_coopTermination;
+
         private int m_IdleTimeout;
         private int m_StackSize;
         private int m_SleepTime;
@@ -96,7 +110,6 @@ namespace OpenSim.Region.ScriptEngine.XEngine
         private bool m_InitialStartup = true;
         private int m_ScriptFailCount; // Number of script fails since compile queue was last empty
         private string m_ScriptErrorMessage;
-        private Dictionary<string, string> m_uniqueScripts = new Dictionary<string, string>();
         private bool m_AppDomainLoading;
         private Dictionary<UUID,ArrayList> m_ScriptErrors =
                 new Dictionary<UUID,ArrayList>();
@@ -308,12 +321,13 @@ namespace OpenSim.Region.ScriptEngine.XEngine
             m_ScriptConfig = configSource.Configs["XEngine"];
             m_ConfigSource = configSource;
 
-            string rawScriptStopStrategy = m_ScriptConfig.GetString("ScriptStopStrategy", "abort");
+            string rawScriptStopStrategy = m_ScriptConfig.GetString("ScriptStopStrategy", "co-op");
 
             m_log.InfoFormat("[XEngine]: Script stop strategy is {0}", rawScriptStopStrategy);
 
             if (rawScriptStopStrategy == "co-op")
             {
+                m_coopTermination = true;
                 ScriptClassName = "XEngineScript";
                 ScriptBaseClassName = typeof(XEngineScriptBase).FullName;
                 ScriptBaseClassParameters = typeof(XEngineScriptBase).GetConstructor(new Type[] { typeof(WaitHandle) }).GetParameters();
@@ -457,19 +471,19 @@ namespace OpenSim.Region.ScriptEngine.XEngine
                 (module, cmdparams) => HandleScriptsAction(cmdparams, HandleStartScript));
 
             MainConsole.Instance.Commands.AddCommand(
-                "Scripts", false, "debug scripts log", "debug scripts log <item-id> <log-level>", "Extra debug logging for a script",
+                "Debug", false, "debug scripts log", "debug scripts log <item-id> <log-level>", "Extra debug logging for a particular script.",
                 "Activates or deactivates extra debug logging for the given script.\n"
                     + "Level == 0, deactivate extra debug logging.\n"
                     + "Level >= 1, log state changes.\n"
                     + "Level >= 2, log event invocations.\n",
                 HandleDebugScriptLogCommand);
 
-//            MainConsole.Instance.Commands.AddCommand(
-//                "Debug", false, "debug xengine", "debug xengine [<level>]",
-//                "Turn on detailed xengine debugging.",
-//                  "If level <= 0, then no extra logging is done.\n"
-//                + "If level >= 1, then we log every time that a script is started.",
-//                HandleDebugLevelCommand);
+            MainConsole.Instance.Commands.AddCommand(
+                "Debug", false, "debug xengine log", "debug xengine log [<level>]",
+                "Turn on detailed xengine debugging.",
+                  "If level <= 0, then no extra logging is done.\n"
+                + "If level >= 1, then we log every time that a script is started.",
+                HandleDebugLevelCommand);
         }
 
         private void HandleDebugScriptLogCommand(string module, string[] args)
@@ -512,26 +526,26 @@ namespace OpenSim.Region.ScriptEngine.XEngine
         /// </summary>
         /// <param name="module"></param>
         /// <param name="args"></param>
-//        private void HandleDebugLevelCommand(string module, string[] args)
-//        {
-//            if (args.Length == 3)
-//            {
-//                int newDebug;
-//                if (int.TryParse(args[2], out newDebug))
-//                {
-//                    DebugLevel = newDebug;
-//                    MainConsole.Instance.OutputFormat("Debug level set to {0}", newDebug);
-//                }
-//            }
-//            else if (args.Length == 2)
-//            {
-//                MainConsole.Instance.OutputFormat("Current debug level is {0}", DebugLevel);
-//            }
-//            else
-//            {
-//                MainConsole.Instance.Output("Usage: debug xengine 0..1");
-//            }
-//        }
+        private void HandleDebugLevelCommand(string module, string[] args)
+        {
+            if (args.Length >= 4)
+            {
+                int newDebug;
+                if (ConsoleUtil.TryParseConsoleNaturalInt(MainConsole.Instance, args[3], out newDebug))
+                {
+                    DebugLevel = newDebug;
+                    MainConsole.Instance.OutputFormat("Debug level set to {0} in XEngine for region {1}", newDebug, m_Scene.Name);
+                }
+            }
+            else if (args.Length == 3)
+            {
+                MainConsole.Instance.OutputFormat("Current debug level is {0}", DebugLevel);
+            }
+            else
+            {
+                MainConsole.Instance.Output("Usage: debug xengine log <level>");
+            }
+        }
 
         /// <summary>
         /// Parse the raw item id into a script instance from the command params if it's present.
@@ -631,7 +645,6 @@ namespace OpenSim.Region.ScriptEngine.XEngine
             }
 
             sb.AppendFormat("Scripts loaded             : {0}\n", scriptsLoaded);
-            sb.AppendFormat("Unique scripts             : {0}\n", m_uniqueScripts.Count);
             sb.AppendFormat("Scripts waiting for load   : {0}\n", m_CompileQueue.Count);
             sb.AppendFormat("Max threads                : {0}\n", m_ThreadPool.MaxThreads);
             sb.AppendFormat("Min threads                : {0}\n", m_ThreadPool.MinThreads);
@@ -754,6 +767,8 @@ namespace OpenSim.Region.ScriptEngine.XEngine
         {
             if (instance.Running)
             {
+                instance.StayStopped = true;    // the script was stopped explicitly
+
                 instance.Stop(0);
 
                 SceneObjectPart sop = m_Scene.GetSceneObjectPart(instance.ObjectID);
@@ -778,11 +793,20 @@ namespace OpenSim.Region.ScriptEngine.XEngine
                 //
                 if (m_Assemblies.ContainsKey(instance.AssetID))
                 {
+<<<<<<< HEAD
+                    // Force a final state save
+                    //
+                    try
+                    {
+                        if (instance.StatePersistedHere)
+                            instance.SaveState();
+=======
                     string assembly = m_Assemblies[instance.AssetID];
 
                     try
                     {
                         instance.SaveState(assembly);
+>>>>>>> avn/ubitvar
                     }
                     catch (Exception e)
                     {
@@ -794,10 +818,16 @@ namespace OpenSim.Region.ScriptEngine.XEngine
                     }
                 }
 
+<<<<<<< HEAD
+                    // Clear the event queue and abort the instance thread
+                    //
+                    instance.Stop(0, true);
+=======
                 // Clear the event queue and abort the instance thread
                 //
                 instance.ClearQueue();
                 instance.Stop(0);
+>>>>>>> avn/ubitvar
 
                 // Release events, timer, etc
                 //
@@ -898,6 +928,25 @@ namespace OpenSim.Region.ScriptEngine.XEngine
 
             List<IScriptInstance> instances = new List<IScriptInstance>();
 
+<<<<<<< HEAD
+            lock (m_Scripts)
+            {
+                foreach (IScriptInstance instance in m_Scripts.Values)
+                {
+                    if (instance.StatePersistedHere)
+                    {
+//                        m_log.DebugFormat(
+//                            "[XEngine]: Adding script {0}.{1}, item UUID {2}, prim UUID {3} in {4} for state persistence",
+//                            instance.PrimName, instance.ScriptName, instance.ItemID, instance.ObjectID, World.Name);
+
+                        instances.Add(instance);
+                    }
+                }
+            }
+
+            foreach (IScriptInstance i in instances)
+            {
+=======
             lockScriptsForRead(true);
                  foreach (IScriptInstance instance in m_Scripts.Values)
                     instances.Add(instance);
@@ -913,9 +962,10 @@ namespace OpenSim.Region.ScriptEngine.XEngine
                     assembly = m_Assemblies[i.AssetID];
                 
 
+>>>>>>> avn/ubitvar
                 try
                 {
-                    i.SaveState(assembly);
+                    i.SaveState();
                 }
                 catch (Exception e)
                 {
@@ -927,8 +977,6 @@ namespace OpenSim.Region.ScriptEngine.XEngine
                 }
             }
 
-            instances.Clear();
-
             if (saveTime > 0)
                 m_ThreadPool.QueueWorkItem(new WorkItemCallback(this.DoBackup),
                                            new Object[] { saveTime });
@@ -938,6 +986,14 @@ namespace OpenSim.Region.ScriptEngine.XEngine
 
         public void SaveAllState()
         {
+            DoBackup(new object[] { 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)
@@ -947,14 +1003,6 @@ namespace OpenSim.Region.ScriptEngine.XEngine
                         inst.Start();
                 }
             }
-        }
-
-        public object DoMaintenance(object p)
-        {
-            object[] parms = (object[])p;
-            int sleepTime = (int)parms[0];
-
-            SaveAllState();
 
             System.Threading.Thread.Sleep(sleepTime);
 
@@ -1032,8 +1080,6 @@ namespace OpenSim.Region.ScriptEngine.XEngine
                             if (restOfFirstLine.StartsWith("c#")
                                 || restOfFirstLine.StartsWith("vb")
                                 || restOfFirstLine.StartsWith("lsl")
-                                || restOfFirstLine.StartsWith("js")
-                                || restOfFirstLine.StartsWith("yp")
                                 || restOfFirstLine.Length == 0)
                                 warnRunningInXEngine = true;
 
@@ -1067,12 +1113,6 @@ namespace OpenSim.Region.ScriptEngine.XEngine
             if (engine != ScriptEngineName)
                 return;
 
-            // If we've seen this exact script text before, use that reference instead
-            if (m_uniqueScripts.ContainsKey(script))
-                script = m_uniqueScripts[script];
-            else
-                m_uniqueScripts[script] = script;
-
             Object[] parms = new Object[]{localID, itemID, script, startParam, postOnRez, (StateSource)stateSource};
 
             if (stateSource == (int)StateSource.ScriptedRez)
@@ -1086,11 +1126,12 @@ namespace OpenSim.Region.ScriptEngine.XEngine
             }
             else
             {
-                m_CompileQueue.Enqueue(parms);
                 lock (m_CompileDict)
-                {
                     m_CompileDict[itemID] = 0;
-                }
+
+                // This must occur after the m_CompileDict so that an existing compile thread cannot hit the check
+                // in DoOnRezScript() before m_CompileDict has been updated.
+                m_CompileQueue.Enqueue(parms);
 
 //                m_log.DebugFormat("[XEngine]: Added script {0} to compile queue", itemID);
 
@@ -1112,49 +1153,81 @@ namespace OpenSim.Region.ScriptEngine.XEngine
 
         public Object DoOnRezScriptQueue(Object dummy)
         {
-            if (m_InitialStartup)
+            try
             {
-                // This delay exists to stop mono problems where script compilation and startup would stop the sim
-                // working properly for the session.
-                System.Threading.Thread.Sleep(m_StartDelay);
+                if (m_InitialStartup)
+                {
+                    // This delay exists to stop mono problems where script compilation and startup would stop the sim
+                    // working properly for the session.
+                    System.Threading.Thread.Sleep(m_StartDelay);
 
-                m_log.InfoFormat("[XEngine]: Performing initial script startup on {0}", m_Scene.Name);
-            }
+                    m_log.InfoFormat("[XEngine]: Performing initial script startup on {0}", m_Scene.Name);
+                }
 
-            object[] o;
+                object[] o;
 
-            int scriptsStarted = 0;
+                int scriptsStarted = 0;
 
-            while (m_CompileQueue.Dequeue(out o))
-            {
-                if (DoOnRezScript(o))
+                while (m_CompileQueue.Dequeue(out o))
                 {
-                    scriptsStarted++;
+                    try
+                    {
+                        if (DoOnRezScript(o))
+                        {
+                            scriptsStarted++;
 
-                    if (m_InitialStartup)
-                        if (scriptsStarted % 50 == 0)
-                            m_log.InfoFormat(
-                                "[XEngine]: Started {0} scripts in {1}", scriptsStarted, m_Scene.Name);
+                            if (m_InitialStartup)
+                                if (scriptsStarted % 50 == 0)
+                                    m_log.InfoFormat(
+                                        "[XEngine]: Started {0} scripts in {1}", scriptsStarted, m_Scene.Name);
+                        }
+                    }
+                    catch (Exception e)
+                    {
+                        m_log.Error(
+                            string.Format(
+                                "[XEngine]: Failure in DoOnRezScriptQueue() for item {0} in {1}.  Continuing.  Exception  ", 
+                                o[1], m_Scene.Name), 
+                            e);
+                    }
                 }
-            }
 
-            if (m_InitialStartup)
-                m_log.InfoFormat(
-                    "[XEngine]: Completed starting {0} scripts on {1}", scriptsStarted, m_Scene.Name);
+                if (m_InitialStartup)
+                    m_log.InfoFormat(
+                        "[XEngine]: Completed starting {0} scripts on {1}", scriptsStarted, m_Scene.Name);
 
-            // NOTE: Despite having a lockless queue, this lock is required
-            // to make sure there is never no compile thread while there
-            // are still scripts to compile. This could otherwise happen
-            // due to a race condition
-            //
-            lock (m_CompileQueue)
-                m_CurrentCompile = null;
+            }
+            catch (Exception e)
+            {
+                m_log.Error(
+                    string.Format("[XEngine]: Failure in DoOnRezScriptQueue() in {0}.  Exception  ", m_Scene.Name), e);
+            }
+            finally
+            {
+                // FIXME: On failure we must trigger this even if the compile queue is not actually empty so that the 
+                // RegionReadyModule is not forever waiting.  This event really needs a different name.
+                m_Scene.EventManager.TriggerEmptyScriptCompileQueue(m_ScriptFailCount,
+                                                                    m_ScriptErrorMessage);
 
-            m_Scene.EventManager.TriggerEmptyScriptCompileQueue(m_ScriptFailCount,
-                                                                m_ScriptErrorMessage);
+                m_ScriptFailCount = 0;
+                m_InitialStartup = false;
 
-            m_ScriptFailCount = 0;
-            m_InitialStartup = false;
+                // NOTE: Despite having a lockless queue, this lock is required
+                // to make sure there is never no compile thread while there
+                // are still scripts to compile. This could otherwise happen
+                // due to a race condition
+                //
+                lock (m_CompileQueue)
+                {
+                    m_CurrentCompile = null;
+
+                    // This is to avoid a situation where the m_CompileQueue while loop above could complete but 
+                    // OnRezScript() place a new script on the queue and check m_CurrentCompile = null before we hit 
+                    // this section.
+                    if (m_CompileQueue.Count > 0)
+                        m_CurrentCompile = m_ThreadPool.QueueWorkItem(DoOnRezScriptQueue, null);
+                }
+            }
 
             return null;
         }
@@ -1201,16 +1274,17 @@ namespace OpenSim.Region.ScriptEngine.XEngine
                 return false;
             }
 
-            m_log.DebugFormat(
-                "[XEngine]: Loading script {0}.{1}, item UUID {2}, prim UUID {3} @ {4}.{5}",
-                part.ParentGroup.RootPart.Name, item.Name, itemID, part.UUID,
-                part.ParentGroup.RootPart.AbsolutePosition, part.ParentGroup.Scene.RegionInfo.RegionName);
+            if (DebugLevel > 0)
+                m_log.DebugFormat(
+                    "[XEngine]: Loading script {0}.{1}, item UUID {2}, prim UUID {3} @ {4}.{5}",
+                    part.ParentGroup.RootPart.Name, item.Name, itemID, part.UUID,
+                    part.ParentGroup.RootPart.AbsolutePosition, part.ParentGroup.Scene.RegionInfo.RegionName);
 
             UUID assetID = item.AssetID;
 
             ScenePresence presence = m_Scene.GetScenePresence(item.OwnerID);
 
-            string assembly = "";
+            string assemblyPath = "";
 
             Culture.SetCurrentCulture();
 
@@ -1222,12 +1296,16 @@ namespace OpenSim.Region.ScriptEngine.XEngine
                 {
                     lock (m_AddingAssemblies)
                     {
-                        m_Compiler.PerformScriptCompile(script, assetID.ToString(), item.OwnerID, out assembly, out linemap);
-                        
-                        if (!m_AddingAssemblies.ContainsKey(assembly)) {
-                            m_AddingAssemblies[assembly] = 1;
+                        m_Compiler.PerformScriptCompile(script, assetID.ToString(), item.OwnerID, out assemblyPath, out linemap);
+
+//                        m_log.DebugFormat(
+//                            "[XENGINE]: Found assembly path {0} onrez {1} in {2}", 
+//                            assemblyPath, item.ItemID, World.Name);
+
+                        if (!m_AddingAssemblies.ContainsKey(assemblyPath)) {
+                            m_AddingAssemblies[assemblyPath] = 1;
                         } else {
-                            m_AddingAssemblies[assembly]++;
+                            m_AddingAssemblies[assemblyPath]++;
                         }
                     }
 
@@ -1387,11 +1465,156 @@ namespace OpenSim.Region.ScriptEngine.XEngine
                         }
                         else
                         {
+<<<<<<< HEAD
+                            m_log.ErrorFormat("[XEngine] Exception creating app domain:\n {0}", e.ToString());
+                            m_ScriptErrorMessage += "Exception creating app domain:\n";
+                            m_ScriptFailCount++;
+                            lock (m_AddingAssemblies) 
+                            {
+                                m_AddingAssemblies[assemblyPath]--;
+                            }
+                            return false;
+=======
                             sandbox = AppDomain.CurrentDomain;
+>>>>>>> avn/ubitvar
+                        }
+
+<<<<<<< HEAD
+                    IScript scriptObj = null;
+                    EventWaitHandle coopSleepHandle;
+                    bool coopTerminationForThisScript;
+
+                    // Set up assembly name to point to the appropriate scriptEngines directory
+                    AssemblyName assemblyName = new AssemblyName(Path.GetFileNameWithoutExtension(assemblyPath));
+                    assemblyName.CodeBase = Path.GetDirectoryName(assemblyPath);
+
+                    if (m_coopTermination)
+                    {
+                        try
+                        {
+                            coopSleepHandle = new XEngineEventWaitHandle(false, EventResetMode.AutoReset);
+
+                            scriptObj 
+                                = (IScript)m_AppDomains[appDomain].CreateInstanceAndUnwrap(
+                                    assemblyName.FullName,
+                                    "SecondLife.XEngineScript",
+                                    false,
+                                    BindingFlags.Default,
+                                    null,
+                                    new object[] { coopSleepHandle }, 
+                                    null,
+                                    null);
+
+                            coopTerminationForThisScript = true;
+                        }
+                        catch (TypeLoadException)
+                        {
+                            coopSleepHandle = null;
+
+                            try
+                            {
+                                scriptObj 
+                                    = (IScript)m_AppDomains[appDomain].CreateInstanceAndUnwrap(
+                                        assemblyName.FullName,
+                                        "SecondLife.Script",
+                                        false,
+                                        BindingFlags.Default,
+                                        null,
+                                        null,
+                                        null,
+                                        null);
+                            }
+                            catch (Exception e2)
+                            {
+                                m_log.Error(
+                                    string.Format(
+                                        "[XENGINE]: Could not load previous SecondLife.Script from assembly {0} in {1}.  Not starting.  Exception  ", 
+                                        assemblyName.FullName, World.Name),
+                                    e2);
+
+                                return false;
+                            }
+
+                            coopTerminationForThisScript = false;
+                        }
+                    }
+                    else
+                    {
+                        try
+                        {
+                            scriptObj 
+                                = (IScript)m_AppDomains[appDomain].CreateInstanceAndUnwrap(
+                                    assemblyName.FullName,
+                                    "SecondLife.Script",
+                                    false,
+                                    BindingFlags.Default,
+                                    null,
+                                    null,
+                                    null,
+                                    null);
+
+                            coopSleepHandle = null;
+                            coopTerminationForThisScript = false;
                         }
+                        catch (TypeLoadException)
+                        {
+                            coopSleepHandle = new XEngineEventWaitHandle(false, EventResetMode.AutoReset);
+
+                            try
+                            {
+                                scriptObj 
+                                    = (IScript)m_AppDomains[appDomain].CreateInstanceAndUnwrap(
+                                        assemblyName.FullName,
+                                        "SecondLife.XEngineScript",
+                                        false,
+                                        BindingFlags.Default,
+                                        null,
+                                        new object[] { coopSleepHandle },
+                                        null,
+                                        null);
+                            }
+                            catch (Exception e2)
+                            {
+                                m_log.Error(
+                                    string.Format(
+                                        "[XENGINE]: Could not load previous SecondLife.XEngineScript from assembly {0} in {1}.  Not starting.  Exception  ", 
+                                        assemblyName.FullName, World.Name),
+                                    e2);
+
+                                return false;
+                            }
+
+                            coopTerminationForThisScript = true;
+                        }
+                    }
 
+                    if (m_coopTermination != coopTerminationForThisScript && !HaveNotifiedLogOfScriptStopMistmatch)
+                    {
+                        // Notify the log that there is at least one script compile that doesn't match the
+                        // ScriptStopStrategy.  Operator has to manually delete old DLLs - we can't do this on Windows
+                        // once the assembly has been loaded evne if the instantiation of a class was unsuccessful.
+                        m_log.WarnFormat(
+                            "[XEngine]: At least one existing compiled script DLL in {0} has {1} as ScriptStopStrategy whereas config setting is {2}."
+                            + "\nContinuing with script compiled strategy but to remove this message please set [XEngine] DeleteScriptsOnStartup = true for one simulator session to remove old script DLLs (script state will not be lost).",
+                            World.Name, coopTerminationForThisScript ? "co-op" : "abort", m_coopTermination ? "co-op" : "abort");
+
+                        HaveNotifiedLogOfScriptStopMistmatch = true;
+                    }
+
+                    instance = new ScriptInstance(this, part,
+                                                  item,
+                                                  startParam, postOnRez,
+                                                  m_MaxScriptQueue);
+
+                    if (
+                        !instance.Load(
+                            scriptObj, coopSleepHandle, assemblyPath,
+                            Path.Combine(ScriptEnginePath, World.RegionInfo.RegionID.ToString()), stateSource, coopTerminationForThisScript))
+                            return false;
+=======
 //                    if (!instance.Load(m_AppDomains[appDomain], assembly, stateSource))
 //                        return false;
+>>>>>>> avn/ubitvar
 
                         m_AppDomains[appDomain] = sandbox;
 
@@ -1444,11 +1667,11 @@ namespace OpenSim.Region.ScriptEngine.XEngine
             }
 
             if (!m_Assemblies.ContainsKey(assetID))
-                m_Assemblies[assetID] = assembly;
+                m_Assemblies[assetID] = assemblyPath;
 
             lock (m_AddingAssemblies) 
             {
-                m_AddingAssemblies[assembly]--;
+                m_AddingAssemblies[assemblyPath]--;
             }
 
             if (instance!=null) 
@@ -1482,6 +1705,9 @@ namespace OpenSim.Region.ScriptEngine.XEngine
                 return;
             }           
 
+<<<<<<< HEAD
+            instance.Stop(m_WaitForEventCompletionOnScriptStop, true);
+=======
             IScriptInstance instance=m_Scripts[itemID];
             lockScriptsForRead(false);
             lockScriptsForWrite(true);
@@ -1492,6 +1718,7 @@ namespace OpenSim.Region.ScriptEngine.XEngine
             instance.Stop(m_WaitForEventCompletionOnScriptStop);
 
 //                bool objectRemoved = false;
+>>>>>>> avn/ubitvar
 
             lock (m_PrimObjects)
             {
@@ -1504,14 +1731,13 @@ namespace OpenSim.Region.ScriptEngine.XEngine
 
                     // If there are no more scripts, remove prim
                     if (m_PrimObjects[localID].Count == 0)
-                    {
                         m_PrimObjects.Remove(localID);
-//                            objectRemoved = true;
-                    }
                 }
             }
 
-            instance.RemoveState();
+            if (instance.StatePersistedHere)
+                instance.RemoveState(); 
+
             instance.DestroyScriptInstance();
 
             if (m_DomainScripts.ContainsKey(instance.AppDomain))
@@ -1653,7 +1879,7 @@ namespace OpenSim.Region.ScriptEngine.XEngine
 
             IScriptInstance instance = (ScriptInstance) parms;
             
-            //m_log.DebugFormat("[XEngine]: Processing event for {0}", instance);
+//            m_log.DebugFormat("[XEngine]: Processing event for {0}", instance);
 
             return instance.EventProcessor();
         }
@@ -1829,6 +2055,12 @@ namespace OpenSim.Region.ScriptEngine.XEngine
             IScriptInstance instance = GetInstance(itemID);
             if (instance != null)
                 instance.ApiResetScript();
+
+            // Send the new number of threads that are in use by the thread
+            // pool, I believe that by adding them to the locations where the
+            // script is changing states that I will catch all changes to the
+            // thread pool
+            m_Scene.setThreadCount(m_ThreadPool.InUseThreads);
         }
 
         public void ResetScript(UUID itemID)
@@ -1836,6 +2068,12 @@ namespace OpenSim.Region.ScriptEngine.XEngine
             IScriptInstance instance = GetInstance(itemID);
             if (instance != null)
                 instance.ResetScript(m_WaitForEventCompletionOnScriptStop);
+
+            // Send the new number of threads that are in use by the thread
+            // pool, I believe that by adding them to the locations where the
+            // script is changing states that I will catch all changes to the
+            // thread pool
+            m_Scene.setThreadCount(m_ThreadPool.InUseThreads);
         }
 
         public void StartScript(UUID itemID)
@@ -1845,6 +2083,12 @@ namespace OpenSim.Region.ScriptEngine.XEngine
                 instance.Start();
             else
                 m_runFlags.AddOrUpdate(itemID, true, 240);
+
+            // Send the new number of threads that are in use by the thread
+            // pool, I believe that by adding them to the locations where the
+            // script is changing states that I will catch all changes to the
+            // thread pool
+            m_Scene.setThreadCount(m_ThreadPool.InUseThreads);
         }
 
         public void StopScript(UUID itemID)
@@ -1853,6 +2097,9 @@ namespace OpenSim.Region.ScriptEngine.XEngine
 
             if (instance != null)
             {
+                lock (instance.EventQueue)
+                    instance.StayStopped = true;    // the script was stopped explicitly
+
                 instance.Stop(m_WaitForEventCompletionOnScriptStop);
             }
             else
@@ -1860,6 +2107,12 @@ namespace OpenSim.Region.ScriptEngine.XEngine
 //                m_log.DebugFormat("[XENGINE]: Could not find script with ID {0} to stop in {1}", itemID, World.Name);
                 m_runFlags.AddOrUpdate(itemID, false, 240);
             }
+
+            // Send the new number of threads that are in use by the thread
+            // pool, I believe that by adding them to the locations where the
+            // script is changing states that I will catch all changes to the
+            // thread pool
+            m_Scene.setThreadCount(m_ThreadPool.InUseThreads);
         }
 
         public DetectParams GetDetectParams(UUID itemID, int idx)
@@ -2225,7 +2478,8 @@ namespace OpenSim.Region.ScriptEngine.XEngine
                     catch (IOException ex)
                     {
                         // if there already exists a file at that location, it may be locked.
-                        m_log.ErrorFormat("[XEngine]: Linemap file {0} already exists! {1}", mappath, ex.Message);
+                        m_log.Error(
+                            string.Format("[XEngine]: Linemap file {0} could not be written.  Exception  ", mappath), ex);
                     }
                 }
             }
@@ -2251,6 +2505,9 @@ namespace OpenSim.Region.ScriptEngine.XEngine
                 m_log.ErrorFormat("[XEngine]: Error whilst writing state file {0}, {1}", statepath, ex.Message);
             }
 
+//            m_log.DebugFormat(
+//                "[XEngine]: Wrote state for script item with ID {0} at {1} in {2}", itemID, statepath, m_Scene.Name);
+
             return true;
         }
 
@@ -2272,7 +2529,6 @@ namespace OpenSim.Region.ScriptEngine.XEngine
 
         public Dictionary<uint, float> GetObjectScriptsExecutionTimes()
         {
-            long tickNow = Util.EnvironmentTickCount();
             Dictionary<uint, float> topScripts = new Dictionary<uint, float>();
 
             lock (m_Scripts)
@@ -2282,7 +2538,7 @@ namespace OpenSim.Region.ScriptEngine.XEngine
                     if (!topScripts.ContainsKey(si.LocalID))
                         topScripts[si.RootLocalID] = 0;
 
-                    topScripts[si.RootLocalID] += CalculateAdjustedExectionTime(si, tickNow);
+                    topScripts[si.RootLocalID] += GetExectionTime(si);
                 }
             }
 
@@ -2296,7 +2552,6 @@ namespace OpenSim.Region.ScriptEngine.XEngine
                 return 0.0f;
             }
             float time = 0.0f;
-            long tickNow = Util.EnvironmentTickCount();
             IScriptInstance si;
             // Calculate the time for all scripts that this engine is executing
             // Ignore any others
@@ -2305,36 +2560,15 @@ namespace OpenSim.Region.ScriptEngine.XEngine
                 si = GetInstance(id);
                 if (si != null && si.Running)
                 {
-                    time += CalculateAdjustedExectionTime(si, tickNow);
+                    time += GetExectionTime(si);
                 }
             }
             return time;
         }
 
-        private float CalculateAdjustedExectionTime(IScriptInstance si, long tickNow)
+        private float GetExectionTime(IScriptInstance si)
         {
-            long ticksElapsed = tickNow - si.MeasurementPeriodTickStart;
-
-            // Avoid divide by zero
-            if (ticksElapsed == 0)
-                ticksElapsed = 1;
-
-            // Scale execution time to the ideal 55 fps frame time for these reasons.
-            //
-            // 1) XEngine does not execute scripts per frame, unlike other script engines.  Hence, there is no
-            // 'script execution time per frame', which is the original purpose of this value.
-            //
-            // 2) Giving the raw execution times is misleading since scripts start at different times, making
-            // it impossible to compare scripts.
-            //
-            // 3) Scaling the raw execution time to the time that the script has been running is better but
-            // is still misleading since a script that has just been rezzed may appear to have been running
-            // for much longer.
-            //
-            // 4) Hence, we scale execution time to an idealised frame time (55 fps).  This is also not perfect
-            // since the figure does not represent actual execution time and very hard running scripts will
-            // never exceed 18ms (though this is a very high number for script execution so is a warning sign).
-            return ((float)si.MeasurementPeriodExecutionTime / ticksElapsed) * 18.1818f;
+            return (float)si.ExecutionTime.GetSumTime().TotalMilliseconds;
         }
 
         public void SuspendScript(UUID itemID)
@@ -2346,6 +2580,12 @@ namespace OpenSim.Region.ScriptEngine.XEngine
                 instance.Suspend();
 //            else
 //                m_log.DebugFormat("[XEngine]: Could not find script with ID {0} to resume", itemID);
+
+            // Send the new number of threads that are in use by the thread
+            // pool, I believe that by adding them to the locations where the
+            // script is changing states that I will catch all changes to the
+            // thread pool
+            m_Scene.setThreadCount(m_ThreadPool.InUseThreads);
         }
 
         public void ResumeScript(UUID itemID)
@@ -2357,6 +2597,12 @@ namespace OpenSim.Region.ScriptEngine.XEngine
                 instance.Resume();
 //            else
 //                m_log.DebugFormat("[XEngine]: Could not find script with ID {0} to resume", itemID);
+
+            // Send the new number of threads that are in use by the thread
+            // pool, I believe that by adding them to the locations where the
+            // script is changing states that I will catch all changes to the
+            // thread pool
+            m_Scene.setThreadCount(m_ThreadPool.InUseThreads);
         }
 
         public bool HasScript(UUID itemID, out bool running)
@@ -2370,5 +2616,30 @@ namespace OpenSim.Region.ScriptEngine.XEngine
             running = instance.Running;
             return true;
         }
+
+        public void SleepScript(UUID itemID, int delay)
+        {
+            IScriptInstance instance = GetInstance(itemID);
+            if (instance == null)
+                return;
+
+            instance.ExecutionTimer.Stop();
+            try
+            {
+                if (instance.CoopWaitHandle != null)
+                {
+                    if (instance.CoopWaitHandle.WaitOne(delay))
+                        throw new ScriptCoopStopException();
+                }
+                else
+                {
+                    Thread.Sleep(delay);
+                }
+            }
+            finally
+            {
+                instance.ExecutionTimer.Start();
+            }
+        }
     }
 }