path: root/OpenSim/Region/ScriptEngine/Common/ScriptEngineBase/EventQueueThreadClass.cs

/*
* Copyright (c) Contributors, http://opensimulator.org/
* See CONTRIBUTORS.TXT for a full list of copyright holders.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions are met:
*     * Redistributions of source code must retain the above copyright
*       notice, this list of conditions and the following disclaimer.
*     * Redistributions in binary form must reproduce the above copyright
*       notice, this list of conditions and the following disclaimer in the
*       documentation and/or other materials provided with the distribution.
*     * Neither the name of the OpenSim Project nor the
*       names of its contributors may be used to endorse or promote products
*       derived from this software without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE DEVELOPERS ``AS IS'' AND ANY
* EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
* WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
* DISCLAIMED. IN NO EVENT SHALL THE CONTRIBUTORS BE LIABLE FOR ANY
* DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
* (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
* LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
* ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
* SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
* 
*/

using System;
using System.Collections.Generic;
using System.Text;
using System.Threading;
using libsecondlife;
using Nini.Config;
using OpenSim.Framework;
using OpenSim.Region.Environment.Scenes.Scripting;

namespace OpenSim.Region.ScriptEngine.Common.ScriptEngineBase
{
    /// <summary>
    /// Because every thread needs some data set for it (time started to execute current function), it will do its work within a class
    /// </summary>
    public class EventQueueThreadClass : iScriptEngineFunctionModule
    {
        /// <summary>
        /// How many ms to sleep if queue is empty
        /// </summary>
        private static int nothingToDoSleepms;// = 50;
        private static ThreadPriority MyThreadPriority;

        public long LastExecutionStarted;
        public bool InExecution = false;
        public bool KillCurrentScript = false;

        //private EventQueueManager eventQueueManager;
        public Thread EventQueueThread;
        private static int ThreadCount = 0;

        private string ScriptEngineName = "ScriptEngine.Common";

        public EventQueueThreadClass()//EventQueueManager eqm
        {
            //eventQueueManager = eqm;
            ReadConfig();
            Start();
        }

        ~EventQueueThreadClass()
        {
            Stop();
        }

        public void ReadConfig()
        {
            foreach (ScriptEngine m_ScriptEngine in ScriptEngine.ScriptEngines)
            {
                ScriptEngineName = m_ScriptEngine.ScriptEngineName;
                nothingToDoSleepms = m_ScriptEngine.ScriptConfigSource.GetInt("SleepTimeIfNoScriptExecutionMs", 50);

                // Later with ScriptServer we might want to ask OS for stuff too, so doing this a bit manually
                string pri = m_ScriptEngine.ScriptConfigSource.GetString("ScriptThreadPriority", "BelowNormal");
                switch (pri.ToLower())
                {
                    case "lowest":
                        MyThreadPriority = ThreadPriority.Lowest;
                        break;
                    case "belownormal":
                        MyThreadPriority = ThreadPriority.BelowNormal;
                        break;
                    case "normal":
                        MyThreadPriority = ThreadPriority.Normal;
                        break;
                    case "abovenormal":
                        MyThreadPriority = ThreadPriority.AboveNormal;
                        break;
                    case "highest":
                        MyThreadPriority = ThreadPriority.Highest;
                        break;
                    default:
                        MyThreadPriority = ThreadPriority.BelowNormal; // Default
                        m_ScriptEngine.Log.Error("[ScriptEngineBase]: Unknown priority type \"" + pri +
                                                 "\" in config file. Defaulting to \"BelowNormal\".");
                        break;
                }
            }

            // Now set that priority
            if (EventQueueThread != null)
                if (EventQueueThread.IsAlive)
                    EventQueueThread.Priority = MyThreadPriority;
        }

        /// <summary>
        /// Start thread
        /// </summary>
        private void Start()
        {
            EventQueueThread = new Thread(EventQueueThreadLoop);
            EventQueueThread.IsBackground = true;

            EventQueueThread.Priority = MyThreadPriority;
            EventQueueThread.Name = "EventQueueManagerThread_" + ThreadCount;
            EventQueueThread.Start();
            OpenSim.Framework.ThreadTracker.Add(EventQueueThread);

            // Look at this... Don't you wish everyone did that solid coding everywhere? :P
            if (ThreadCount == int.MaxValue)
                ThreadCount = 0;
            ThreadCount++;
        }

        public void Stop()
        {
            //PleaseShutdown = true;                  // Set shutdown flag
            //Thread.Sleep(100);                       // Wait a bit
            if (EventQueueThread != null && EventQueueThread.IsAlive == true)
            {
                try
                {
                    EventQueueThread.Abort();               // Send abort
                    //EventQueueThread.Join();                // Wait for it
                }
                catch (Exception)
                {
                    //myScriptEngine.Log.Info("[" + ScriptEngineName + "]: EventQueueManager Exception killing worker thread: " + e.ToString());
                }
            }
        }

        private EventQueueManager.QueueItemStruct BlankQIS = new EventQueueManager.QueueItemStruct();
        private ScriptEngine lastScriptEngine;
        /// <summary>
        /// Queue processing thread loop
        /// </summary>
        private void EventQueueThreadLoop()
        {
            //myScriptEngine.Log.Info("[" + ScriptEngineName + "]: EventQueueManager Worker thread spawned");
            try
            {
                while (true)
                {
                    try
                    {
                        while (true)
                        {
                            DoProcessQueue();
                        }
                    }
                    catch (ThreadAbortException tae)
                    {
                        if (lastScriptEngine != null)
                        lastScriptEngine.Log.Info("[" + ScriptEngineName + "]: ThreadAbortException while executing function.");
                    }
                    catch (Exception e)
                    {
                        if (lastScriptEngine != null)
                        lastScriptEngine.Log.Error("[" + ScriptEngineName + "]: Exception in EventQueueThreadLoop: " + e.ToString());
                    }
                }
            }
            catch (ThreadAbortException)
            {
                //myScriptEngine.Log.Info("[" + ScriptEngineName + "]: EventQueueManager Worker thread killed: " + tae.Message);
            }
        }

        public void DoProcessQueue()
        {
            foreach (ScriptEngine m_ScriptEngine in ScriptEngine.ScriptEngines)
            {
                lastScriptEngine = m_ScriptEngine;
                // Every now and then check if we should shut down
                //if (PleaseShutdown || EventQueueManager.ThreadsToExit > 0)
                //{
                //    // Someone should shut down, lets get exclusive lock
                //    lock (EventQueueManager.ThreadsToExitLock)
                //    {
                //        // Lets re-check in case someone grabbed it
                //        if (EventQueueManager.ThreadsToExit > 0)
                //        {
                //            // Its crowded here so we'll shut down
                //            EventQueueManager.ThreadsToExit--;
                //            Stop();
                //            return;
                //        }
                //        else
                //        {
                //            // We have been asked to shut down
                //            Stop();
                //            return;
                //        }
                //    }
                //}

                //try
                //  {
                EventQueueManager.QueueItemStruct QIS = BlankQIS;
                bool GotItem = false;

                //if (PleaseShutdown)
                //    return;

                if (m_ScriptEngine.m_EventQueueManager.eventQueue.Count == 0)
                {
                    // Nothing to do? Sleep a bit waiting for something to do
                    Thread.Sleep(nothingToDoSleepms);
                }
                else
                {
                    // Something in queue, process
                    //myScriptEngine.Log.Info("[" + ScriptEngineName + "]: Processing event for localID: " + QIS.localID + ", itemID: " + QIS.itemID + ", FunctionName: " + QIS.FunctionName);

                    // OBJECT BASED LOCK - TWO THREADS WORKING ON SAME OBJECT IS NOT GOOD
                    lock (m_ScriptEngine.m_EventQueueManager.eventQueue)
                    {
                        GotItem = false;
                        for (int qc = 0; qc < m_ScriptEngine.m_EventQueueManager.eventQueue.Count; qc++)
                        {
                            // Get queue item
                            QIS = m_ScriptEngine.m_EventQueueManager.eventQueue.Dequeue();

                            // Check if object is being processed by someone else
                            if (m_ScriptEngine.m_EventQueueManager.TryLock(QIS.localID) == false)
                            {
                                // Object is already being processed, requeue it
                                m_ScriptEngine.m_EventQueueManager.eventQueue.Enqueue(QIS);
                            }
                            else
                            {
                                // We have lock on an object and can process it
                                GotItem = true;
                                break;
                            }
                        }
                    }

                    if (GotItem == true)
                    {
                        // Execute function
                        try
                        {
                            ///cfk 2-7-08 dont need this right now and the default Linux build has DEBUG defined
#if DEBUG
                            //eventQueueManager.m_ScriptEngine.Log.Debug("[" + ScriptEngineName + "]: " +
                            //                                              "Executing event:\r\n"
                            //                                              + "QIS.localID: " + QIS.localID
                            //                                              + ", QIS.itemID: " + QIS.itemID
                            //                                              + ", QIS.functionName: " +
                            //                                              QIS.functionName);
#endif
                            LastExecutionStarted = DateTime.Now.Ticks;
                            KillCurrentScript = false;
                            InExecution = true;
                            m_ScriptEngine.m_ScriptManager.ExecuteEvent(QIS.localID,
                                                                                          QIS.itemID,
                                                                                          QIS.functionName,
                                                                                          QIS.llDetectParams,
                                                                                          QIS.param);
                            InExecution = false;
                        }
                        catch (Exception e)
                        {
                            InExecution = false;
                            // DISPLAY ERROR INWORLD
                            string text = "Error executing script function \"" + QIS.functionName +
                                          "\":\r\n";
                            if (e.InnerException != null)
                            {
                                // Send inner exception
                                text += e.InnerException.Message.ToString();
                            }
                            else
                            {
                                text += "\r\n";
                                // Send normal
                                text += e.Message.ToString();
                            }
                            if (KillCurrentScript)
                                text += "\r\nScript will be deactivated!";

                            try
                            {
                                if (text.Length > 1500)
                                    text = text.Substring(0, 1500);
                                IScriptHost m_host =
                                    m_ScriptEngine.World.GetSceneObjectPart(QIS.localID);
                                //if (m_host != null)
                                //{
                                m_ScriptEngine.World.SimChat(Helpers.StringToField(text),
                                                                               ChatTypeEnum.Say, 0,
                                                                               m_host.AbsolutePosition,
                                                                               m_host.Name, m_host.UUID);
                            }
                            catch
                            {
                                //}
                                //else
                                //{
                                // T oconsole
                                m_ScriptEngine.m_EventQueueManager.m_ScriptEngine.Log.Error("[" + ScriptEngineName + "]: " +
                                                                              "Unable to send text in-world:\r\n" +
                                                                              text);
                            }
                            finally
                            {
                                // So we are done sending message in-world
                                if (KillCurrentScript)
                                {
                                    m_ScriptEngine.m_EventQueueManager.m_ScriptEngine.m_ScriptManager.StopScript(
                                        QIS.localID, QIS.itemID);
                                }
                            }
                        }
                        finally
                        {
                            InExecution = false;
                            m_ScriptEngine.m_EventQueueManager.ReleaseLock(QIS.localID);
                        }
                    }
                }
            }
        }

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