Merge commit '601dabb1b73a894e4f2f61abe6e9053d380008cd' into bigmerge

OpenSim/Region/Framework/Interfaces/IScriptModule.cs

@@ -41,12 +41,16 @@ namespace OpenSim.Region.Framework.Interfaces
         bool PostScriptEvent(UUID itemID, string name, Object[] args);
         bool PostObjectEvent(UUID itemID, string name, Object[] args);
 
-        // Suspend ALL scripts in a given scene object. The item ID
+        /// <summary>
-        // is the UUID of a SOG, and the method acts on all contained
+        /// Suspends a script.
-        // scripts. This is different from the suspend/resume that
+        /// </summary>
-        // can be issued by a client.
+        /// <param name="itemID">The item ID of the script.</param>
-        //
         void SuspendScript(UUID itemID);
+
+        /// <summary>
+        /// Resumes a script.
+        /// </summary>
+        /// <param name="itemID">The item ID of the script.</param>
         void ResumeScript(UUID itemID);
 
         ArrayList GetScriptErrors(UUID itemID);

OpenSim/Region/ScriptEngine/XEngine/XEngine.cs

@@ -344,14 +344,31 @@ namespace OpenSim.Region.ScriptEngine.XEngine
                 "Synonym for scripts show command", HandleShowScripts);
 
             MainConsole.Instance.Commands.AddCommand(
-                "scripts", false, "scripts suspend", "scripts suspend", "Suspend all scripts",
+                "scripts", false, "scripts suspend", "scripts suspend [<script-item-uuid>]", "Suspends all running scripts",
                 "Suspends all currently running scripts.  This only suspends event delivery, it will not suspend a"
-                    + " script that is currently processing an event.",
+                    + " script that is currently processing an event.\n"
-                HandleSuspendScripts);
+                    + "Suspended scripts will continue to accumulate events but won't process them.\n"
+                    + "If a <script-item-uuid> is given then only that script will be suspended.  Otherwise, all suitable scripts are suspended.",
+                 (module, cmdparams) => HandleScriptsAction(cmdparams, HandleSuspendScript));
 
             MainConsole.Instance.Commands.AddCommand(
-                "scripts", false, "scripts resume", "scripts resume", "Resume all scripts",
+                "scripts", false, "scripts resume", "scripts resume [<script-item-uuid>]", "Resumes all suspended scripts",
-                "Resumes all currently suspended scripts", HandleResumeScripts);
+                "Resumes all currently suspended scripts.\n"
+                    + "Resumed scripts will process all events accumulated whilst suspended."
+                    + "If a <script-item-uuid> is given then only that script will be resumed.  Otherwise, all suitable scripts are resumed.",
+                (module, cmdparams) => HandleScriptsAction(cmdparams, HandleResumeScript));
+
+            MainConsole.Instance.Commands.AddCommand(
+                "scripts", false, "scripts stop", "scripts stop [<script-item-uuid>]", "Stops all running scripts",
+                "Stops all running scripts."
+                    + "If a <script-item-uuid> is given then only that script will be stopped.  Otherwise, all suitable scripts are stopped.",
+                (module, cmdparams) => HandleScriptsAction(cmdparams, HandleStopScript));
+
+            MainConsole.Instance.Commands.AddCommand(
+                "scripts", false, "scripts start", "scripts start [<script-item-uuid>]", "Starts all stopped scripts",
+                "Starts all stopped scripts."
+                    + "If a <script-item-uuid> is given then only that script will be started.  Otherwise, all suitable scripts are started.",
+                (module, cmdparams) => HandleScriptsAction(cmdparams, HandleStartScript));
         }
 
         public void HandleShowScripts(string module, string[] cmdparams)
@@ -391,11 +408,53 @@ namespace OpenSim.Region.ScriptEngine.XEngine
             }
         }
 
-        public void HandleSuspendScripts(string module, string[] cmdparams)
+        /// <summary>
+        /// Parse the raw item id into a script instance from the command params if it's present.
+        /// </summary>
+        /// <param name="cmdparams"></param>
+        /// <param name="instance"></param>
+        /// <returns>true if we're okay to proceed, false if not.</returns>
+        private void HandleScriptsAction(string[] cmdparams, Action<IScriptInstance> action)
         {
             lock (m_Scripts)
+            {
+                string rawItemId;
+                UUID itemId = UUID.Zero;
+    
+                if (cmdparams.Length == 2)
                 {
                     foreach (IScriptInstance instance in m_Scripts.Values)
+                        action(instance);
+
+                    return;
+                }
+    
+                rawItemId = cmdparams[2];
+    
+                if (!UUID.TryParse(rawItemId, out itemId))
+                {
+                    MainConsole.Instance.OutputFormat("Error - {0} is not a valid UUID", rawItemId);
+                    return;
+                }
+    
+                if (itemId != UUID.Zero)
+                {
+                    IScriptInstance instance = GetInstance(itemId);
+                    if (instance == null)
+                    {
+                        MainConsole.Instance.OutputFormat("Error - No item found with id {0}", itemId);
+                        return;
+                    }
+                    else
+                    {
+                        action(instance);
+                        return;
+                    }
+                }
+            }
+        }
+
+        private void HandleSuspendScript(IScriptInstance instance)
         {
             if (!instance.Suspended)
             {
@@ -407,14 +466,8 @@ namespace OpenSim.Region.ScriptEngine.XEngine
                     instance.PrimName, instance.ScriptName, instance.ItemID, instance.ObjectID, sop.AbsolutePosition);
             }
         }
-            }
-        }
 
-        public void HandleResumeScripts(string module, string[] cmdparams)
+        private void HandleResumeScript(IScriptInstance instance)
-        {
-            lock (m_Scripts)
-            {
-                foreach (IScriptInstance instance in m_Scripts.Values)
         {
             if (instance.Suspended)
             {
@@ -426,6 +479,30 @@ namespace OpenSim.Region.ScriptEngine.XEngine
                     instance.PrimName, instance.ScriptName, instance.ItemID, instance.ObjectID, sop.AbsolutePosition);
             }
         }
+
+        private void HandleStartScript(IScriptInstance instance)
+        {
+            if (!instance.Running)
+            {
+                instance.Start();
+
+                SceneObjectPart sop = m_Scene.GetSceneObjectPart(instance.ObjectID);
+                MainConsole.Instance.OutputFormat(
+                    "Started {0}.{1}, item UUID {2}, prim UUID {3} @ {4}",
+                    instance.PrimName, instance.ScriptName, instance.ItemID, instance.ObjectID, sop.AbsolutePosition);
+            }
+        }
+
+        private void HandleStopScript(IScriptInstance instance)
+        {
+            if (instance.Running)
+            {
+                instance.Stop(0);
+
+                SceneObjectPart sop = m_Scene.GetSceneObjectPart(instance.ObjectID);
+                MainConsole.Instance.OutputFormat(
+                    "Stopped {0}.{1}, item UUID {2}, prim UUID {3} @ {4}",
+                    instance.PrimName, instance.ScriptName, instance.ItemID, instance.ObjectID, sop.AbsolutePosition);
             }
         }
 
@@ -1804,18 +1881,14 @@ namespace OpenSim.Region.ScriptEngine.XEngine
         public void SuspendScript(UUID itemID)
         {
             IScriptInstance instance = GetInstance(itemID);
-            if (instance == null)
+            if (instance != null)
-                return;
-
                 instance.Suspend();
         }
 
         public void ResumeScript(UUID itemID)
         {
             IScriptInstance instance = GetInstance(itemID);
-            if (instance == null)
+            if (instance != null)
-                return;
-
                 instance.Resume();
         }