1 files changed, 745 insertions, 764 deletions
diff --git a/OpenSim/Region/OptionalModules/World/AutoBackup/AutoBackupModule.cs b/OpenSim/Region/OptionalModules/World/AutoBackup/AutoBackupModule.cs
index 364697b..a4dbea4 100644
--- a/OpenSim/Region/OptionalModules/World/AutoBackup/AutoBackupModule.cs
+++ b/OpenSim/Region/OptionalModules/World/AutoBackup/AutoBackupModule.cs
@@ -1,764 +1,745 @@
-/*
+#pragma warning disable 1587
- * Copyright (c) Contributors, http://opensimulator.org/
+/// 
- * See CONTRIBUTORS.TXT for a full list of copyright holders.
+/// 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:
+/// Redistribution and use in source and binary forms, with or without
- *     * Redistributions of source code must retain the above copyright
+/// modification, are permitted provided that the following conditions are met:
- *       notice, this list of conditions and the following disclaimer.
+///     * Redistributions of source code must retain the above copyright
- *     * Redistributions in binary form must reproduce the above copyright
+///       notice, this list of conditions and the following disclaimer.
- *       notice, this list of conditions and the following disclaimer in the
+///     * Redistributions in binary form must reproduce the above copyright
- *       documentation and/or other materials provided with the distribution.
+///       notice, this list of conditions and the following disclaimer in the
- *     * Neither the name of the OpenSimulator Project nor the
+///       documentation and/or other materials provided with the distribution.
- *       names of its contributors may be used to endorse or promote products
+///     * Neither the name of the OpenSimulator Project nor the
- *       derived from this software without specific prior written permission.
+///       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
+/// THIS SOFTWARE IS PROVIDED BY THE DEVELOPERS ``AS IS'' AND ANY
- * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+/// EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
- * DISCLAIMED. IN NO EVENT SHALL THE CONTRIBUTORS BE LIABLE FOR ANY
+/// WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
- * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+/// DISCLAIMED. IN NO EVENT SHALL THE CONTRIBUTORS BE LIABLE FOR ANY
- * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+/// DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
- * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+/// (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
- * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+/// LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
- * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+/// ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
- * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+/// (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.IO;
+using System;
-using System.Timers;
+using System.Collections.Generic;
-using System.Diagnostics;
+using System.Diagnostics;
-using System.Reflection;
+using System.Globalization;
-using System.Collections.Generic;
+using System.IO;
-using log4net;
+using System.Reflection;
-using Nini;
+using System.Timers;
-using Nini.Config;
+using System.Text.RegularExpressions;
-using OpenSim.Framework;
+using log4net;
-using OpenSim.Framework.Statistics;
+using Nini.Config;
-using OpenSim.Region.Framework.Interfaces;
+using OpenSim.Framework;
-using OpenSim.Region.Framework.Scenes;
+using OpenSim.Region.Framework.Interfaces;
+using OpenSim.Region.Framework.Scenes;
-/*
+///
- * Config Settings Documentation.
+/// Config Settings Documentation.
- * At the TOP LEVEL, e.g. in OpenSim.ini, we have the following options:
+/// At the TOP LEVEL, e.g. in OpenSim.ini, we have the following options:
- * In the [Modules] section:
+/// EACH REGION, in OpenSim.ini, can have the following settings under the [AutoBackupModule] section.
- *      AutoBackupModule: True/False. Default: False. If True, use the auto backup module. Otherwise it will be disabled regardless of what settings are in Regions.ini!
+/// IMPORTANT: You may optionally specify the key name as follows for a per-region key: <Region Name>.<Key Name>
- * EACH REGION, in OpenSim.ini, can have the following settings under the [AutoBackupModule] section.
+/// Example: My region is named Foo.
- * VERY IMPORTANT: You must create the key name as follows: <Region Name>.<Key Name>
+/// If I wanted to specify the "AutoBackupInterval" key just for this region, I would name my key "Foo.AutoBackupInterval", under the [AutoBackupModule] section of OpenSim.ini.
- * Example: My region is named Foo.
+/// Instead of specifying them on a per-region basis, you can also omit the region name to specify the default setting for all regions.
- * If I wanted to specify the "AutoBackupInterval" key below, I would name my key "Foo.AutoBackupInterval", under the [AutoBackupModule] section of OpenSim.ini.
+/// Region-specific settings take precedence.
- * Instead of specifying them on a per-region basis, you can also omit the region name to specify the default setting for all regions.
+/// 
- * Region-specific settings take precedence.
+/// AutoBackupModuleEnabled: True/False. Default: False. If True, use the auto backup module. This setting does not support per-region basis.
- * AutoBackup: True/False. Default: False. If True, activate auto backup functionality. 
+///     All other settings under [AutoBackupModule] are ignored if AutoBackupModuleEnabled is false, even per-region settings!
- *      This is the only required option for enabling auto-backup; the other options have sane defaults. 
+/// AutoBackup: True/False. Default: False. If True, activate auto backup functionality. 
- *      If False, the auto-backup module becomes a no-op for the region, and all other AutoBackup* settings are ignored.
+///     This is the only required option for enabling auto-backup; the other options have sane defaults. 
- * AutoBackupInterval: Double, non-negative value. Default: 720 (12 hours). 
+///     If False for a particular region, the auto-backup module becomes a no-op for the region, and all other AutoBackup* settings are ignored.
- *      The number of minutes between each backup attempt. 
+///     If False globally (the default), only regions that specifically override this with "FooRegion.AutoBackup = true" will get AutoBackup functionality.
- *      If a negative or zero value is given, it is equivalent to setting AutoBackup = False.
+/// AutoBackupInterval: Double, non-negative value. Default: 720 (12 hours). 
- * AutoBackupBusyCheck: True/False. Default: True. 
+///     The number of minutes between each backup attempt. 
- *      If True, we will only take an auto-backup if a set of conditions are met. 
+///     If a negative or zero value is given, it is equivalent to setting AutoBackup = False.
- *      These conditions are heuristics to try and avoid taking a backup when the sim is busy.
+/// AutoBackupBusyCheck: True/False. Default: True. 
- * AutoBackupScript: String. Default: not specified (disabled). 
+///     If True, we will only take an auto-backup if a set of conditions are met. 
- *      File path to an executable script or binary to run when an automatic backup is taken.
+///     These conditions are heuristics to try and avoid taking a backup when the sim is busy.
- *  The file should really be (Windows) an .exe or .bat, or (Linux/Mac) a shell script or binary.
+/// AutoBackupScript: String. Default: not specified (disabled). 
- *  Trying to "run" directories, or things with weird file associations on Win32, might cause unexpected results!
+///     File path to an executable script or binary to run when an automatic backup is taken.
- *      argv[1] of the executed file/script will be the file name of the generated OAR. 
+///  The file should really be (Windows) an .exe or .bat, or (Linux/Mac) a shell script or binary.
- *      If the process can't be spawned for some reason (file not found, no execute permission, etc), write a warning to the console.
+///  Trying to "run" directories, or things with weird file associations on Win32, might cause unexpected results!
- * AutoBackupNaming: string. Default: Time.
+///     argv[1] of the executed file/script will be the file name of the generated OAR. 
- *      One of three strings (case insensitive):
+///     If the process can't be spawned for some reason (file not found, no execute permission, etc), write a warning to the console.
- *      "Time": Current timestamp is appended to file name. An existing file will never be overwritten.
+/// AutoBackupNaming: string. Default: Time.
- *  "Sequential": A number is appended to the file name. So if RegionName_x.oar exists, we'll save to RegionName_{x+1}.oar next. An existing file will never be overwritten.
+///     One of three strings (case insensitive):
- *  "Overwrite": Always save to file named "${AutoBackupDir}/RegionName.oar", even if we have to overwrite an existing file.
+///     "Time": Current timestamp is appended to file name. An existing file will never be overwritten.
- * AutoBackupDir: String. Default: "." (the current directory).
+///  "Sequential": A number is appended to the file name. So if RegionName_x.oar exists, we'll save to RegionName_{x+1}.oar next. An existing file will never be overwritten.
- *      A directory (absolute or relative) where backups should be saved.
+///  "Overwrite": Always save to file named "${AutoBackupDir}/RegionName.oar", even if we have to overwrite an existing file.
- * AutoBackupDilationThreshold: float. Default: 0.5. Lower bound on time dilation required for BusyCheck heuristics to pass.
+/// AutoBackupDir: String. Default: "." (the current directory).
- *  If the time dilation is below this value, don't take a backup right now.
+///     A directory (absolute or relative) where backups should be saved.
- * AutoBackupAgentThreshold: int. Default: 10. Upper bound on # of agents in region required for BusyCheck heuristics to pass.
+/// AutoBackupDilationThreshold: float. Default: 0.5. Lower bound on time dilation required for BusyCheck heuristics to pass.
- *  If the number of agents is greater than this value, don't take a backup right now.
+///  If the time dilation is below this value, don't take a backup right now.
- * */
+/// AutoBackupAgentThreshold: int. Default: 10. Upper bound on # of agents in region required for BusyCheck heuristics to pass.
+///  If the number of agents is greater than this value, don't take a backup right now.
-namespace OpenSim.Region.OptionalModules.World.AutoBackup
+///
-{
+namespace OpenSim.Region.OptionalModules.World.AutoBackup
-        public enum NamingType
+{
-        {
+    public enum NamingType
-                TIME,
+    {
-                SEQUENTIAL,
+        Time,
-                OVERWRITE
+        Sequential,
-        }
+        Overwrite
+    }
-        public class AutoBackupModule : ISharedRegionModule, IRegionModuleBase
-        {
+    public class AutoBackupModule : ISharedRegionModule
+    {
-                private static readonly ILog m_log = LogManager.GetLogger (MethodBase.GetCurrentMethod ().DeclaringType);
+        private static readonly ILog m_log =
+            LogManager.GetLogger(MethodBase.GetCurrentMethod().DeclaringType);
-                //AutoBackupModuleState: Auto-Backup state for one region (scene).
-                public class AutoBackupModuleState
+        /// True means IRegionModuleBase.Close() was called on us, and we should stop operation ASAP.
-                {
+        /// Used to prevent elapsing timers after Close() is called from trying to start an autobackup while the sim is shutting down.
-                        private bool m_enabled = false;
+        private readonly AutoBackupModuleState m_defaultState = new AutoBackupModuleState();
-                        private NamingType m_naming = NamingType.TIME;
-                        private Timer m_timer = null;
+        /// Save memory by setting low initial capacities. Minimizes impact in common cases of all regions using same interval, and instances hosting 1 ~ 4 regions.
-                        private bool m_busycheck = true;
+        /// Also helps if you don't want AutoBackup at all
-                        private string m_script = null;
+        private readonly Dictionary<IScene, AutoBackupModuleState> m_states =
-                        private string m_dir = ".";
+            new Dictionary<IScene, AutoBackupModuleState>(1);
-                        public AutoBackupModuleState ()
+        private readonly Dictionary<Timer, List<IScene>> m_timerMap =
-                        {
+            new Dictionary<Timer, List<IScene>>(1);
-                        }
+        private readonly Dictionary<double, Timer> m_timers = new Dictionary<double, Timer>(1);
-                        public void SetEnabled (bool b)
+        private bool m_enabled;
-                        {
-                                m_enabled = b;
+        /// Whether the shared module should be enabled at all. NOT the same as m_Enabled in AutoBackupModuleState!
-                        }
+        private bool m_closed;
-                        public bool GetEnabled ()
+        private IConfigSource m_configSource;
-                        {
-                                return m_enabled;
+        public bool IsSharedModule
-                        }
+        {
+            get { return true; }
-                        public Timer GetTimer ()
+        }
-                        {
-                                return m_timer;
+        #region ISharedRegionModule Members
-                        }
-                        
+        string IRegionModuleBase.Name
-                        public double GetIntervalMinutes ()
+        {
-                        {
+            get { return "AutoBackupModule"; }
-                            if(m_timer == null)
+        }
-                            {
-                                return -1.0;
+        Type IRegionModuleBase.ReplaceableInterface
-                            }
+        {
-                            else
+            get { return null; }
-                            {
+        }
-                                return m_timer.Interval / 60000.0;
-                            }
+        void IRegionModuleBase.Initialise(IConfigSource source)
-                        }
+        {
+            /// Determine if we have been enabled at all in OpenSim.ini -- this is part and parcel of being an optional module
-                        public void SetTimer (Timer t)
+            this.m_configSource = source;
-                        {
+            IConfig moduleConfig = source.Configs["AutoBackupModule"];
-                                m_timer = t;
+            if (moduleConfig == null)
-                        }
+            {
+                this.m_enabled = false;
-                        public bool GetBusyCheck ()
+                return;
-                        {
+            }
-                                return m_busycheck;
+            else
-                        }
+            {
+                this.m_enabled = moduleConfig.GetBoolean("AutoBackupModuleEnabled", false);
-                        public void SetBusyCheck (bool b)
+                if (this.m_enabled)
-                        {
+                {
-                                m_busycheck = b;
+                    m_log.Info("[AUTO BACKUP]: AutoBackupModule enabled");
-                        }
+                }
+                else
+                {
-                        public string GetScript ()
+                    return;
-                        {
+                }
-                                return m_script;
+            }
-                        }
+            Timer defTimer = new Timer(43200000);
-                        public void SetScript (string s)
+            this.m_defaultState.Timer = defTimer;
-                        {
+            this.m_timers.Add(43200000, defTimer);
-                                m_script = s;
+            defTimer.Elapsed += this.HandleElapsed;
-                        }
+            defTimer.AutoReset = true;
+            defTimer.Start();
-                        public string GetBackupDir ()
-                        {
+            AutoBackupModuleState abms = this.ParseConfig(null, true);
-                                return m_dir;
+            m_log.Debug("[AUTO BACKUP]: Here is the default config:");
-                        }
+            m_log.Debug(abms.ToString());
+        }
-                        public void SetBackupDir (string s)
-                        {
+        void IRegionModuleBase.Close()
-                                m_dir = s;
+        {
-                        }
+            if (!this.m_enabled)
+            {
-                        public NamingType GetNamingType ()
+                return;
-                        {
+            }
-                                return m_naming;
-                        }
+            /// We don't want any timers firing while the sim's coming down; strange things may happen.
+            this.StopAllTimers();
-                        public void SetNamingType (NamingType n)
+        }
-                        {
-                                m_naming = n;
+        void IRegionModuleBase.AddRegion(Scene scene)
-                        }
+        {
-                        
+            /// NO-OP. Wait for the region to be loaded.
-                        public string ToString()
+        }
-                        {
-                            string retval = "";
+        void IRegionModuleBase.RemoveRegion(Scene scene)
-                            
+        {
-                            retval += "[AUTO BACKUP]: AutoBackup: " + (GetEnabled() ? "ENABLED" : "DISABLED") + "\n";
+            if (!this.m_enabled)
-                            retval += "[AUTO BACKUP]: Interval: " + GetIntervalMinutes() + " minutes" + "\n";
+            {
-                            retval += "[AUTO BACKUP]: Do Busy Check: " + (GetBusyCheck() ? "Yes" : "No") + "\n";
+                return;
-                            retval += "[AUTO BACKUP]: Naming Type: " + GetNamingType().ToString() + "\n";
+            }
-                            retval += "[AUTO BACKUP]: Backup Dir: " + GetBackupDir() + "\n";
-                            retval += "[AUTO BACKUP]: Script: " + GetScript() + "\n";
+            if (this.m_states.ContainsKey(scene))
-                            return retval;
+            {
-                        }
+                AutoBackupModuleState abms = this.m_states[scene];
-                }
+                /// Remove this scene out of the timer map list
-                //Save memory by setting low initial capacities. Minimizes impact in common cases of all regions using same interval, and instances hosting 1 ~ 4 regions.
+                Timer timer = abms.Timer;
-                //Also helps if you don't want AutoBackup at all
+                List<IScene> list = this.m_timerMap[timer];
-                readonly Dictionary<IScene, AutoBackupModuleState> states = new Dictionary<IScene, AutoBackupModuleState> (4);
+                list.Remove(scene);
-                readonly Dictionary<double, Timer> timers = new Dictionary<double, Timer> (1);
-                readonly Dictionary<Timer, List<IScene>> timerMap = new Dictionary<Timer, List<IScene>> (1);
+                /// Shut down the timer if this was the last scene for the timer
-                private IConfigSource m_configSource = null;
+                if (list.Count == 0)
-                private bool m_Enabled = false;
+                {
-                //Whether the shared module should be enabled at all. NOT the same as m_Enabled in AutoBackupModuleState!
+                    this.m_timerMap.Remove(timer);
-                private bool m_closed = false;
+                    this.m_timers.Remove(timer.Interval);
-                //True means IRegionModuleBase.Close() was called on us, and we should stop operation ASAP.
+                    timer.Close();
-                //Used to prevent elapsing timers after Close() is called from trying to start an autobackup while the sim is shutting down.
+                }
-                readonly AutoBackupModuleState defaultState = new AutoBackupModuleState();
+                this.m_states.Remove(scene);
-                
+            }
-                public AutoBackupModule ()
+        }
-                {
-                        
+        void IRegionModuleBase.RegionLoaded(Scene scene)
-                }
+        {
+            if (!this.m_enabled)
-                #region IRegionModuleBase implementation
+            {
-                void IRegionModuleBase.Initialise (Nini.Config.IConfigSource source)
+                return;
-                {
+            }
-                        //Determine if we have been enabled at all in OpenSim.ini -- this is part and parcel of being an optional module
-                        m_configSource = source;
+            /// This really ought not to happen, but just in case, let's pretend it didn't...
-                        IConfig moduleConfig = source.Configs["Modules"];
+            if (scene == null)
-                        if (moduleConfig != null) {
+            {
-                                m_Enabled = moduleConfig.GetBoolean ("AutoBackupModule", false);
+                return;
-                                if (m_Enabled) {
+            }
-                                        m_log.Info ("[AUTO BACKUP]: AutoBackupModule enabled");
-                                }
+            AutoBackupModuleState abms = this.ParseConfig(scene, false);
-                                else {
+            m_log.Debug("[AUTO BACKUP]: Config for " + scene.RegionInfo.RegionName);
-                                    m_log.Info ("[AUTO BACKUP]: AutoBackupModule disabled");
+            m_log.Debug((abms == null ? "DEFAULT" : abms.ToString()));
-                                    return;
+        }
-                                }
-                        }
+        void ISharedRegionModule.PostInitialise()
-                        
+        {
-                        Timer defTimer = new Timer(720 * 60000);
+            /// I don't care right now.
-                        defaultState.SetTimer(defTimer);
+        }
-                        timers.Add (720*60000, defTimer);
-                        defTimer.Elapsed += HandleElapsed;
+        #endregion
-                        defTimer.AutoReset = true;
-                        defTimer.Start ();
+        private AutoBackupModuleState ParseConfig(IScene scene, bool parseDefault)
-                        
+        {
-                        AutoBackupModuleState abms = ParseConfig(null, true);
+            string sRegionName;
-                        m_log.Debug("[AUTO BACKUP]: Config for default");
+            string sRegionLabel;
-                        m_log.Debug(abms.ToString());
+            string prepend;
-                }
+            AutoBackupModuleState state;
-                void IRegionModuleBase.Close ()
+            if (parseDefault)
-                {
+            {
-                        if (!m_Enabled)
+                sRegionName = null;
-                                return;
+                sRegionLabel = "DEFAULT";
-                        
+                prepend = "";
-                        //We don't want any timers firing while the sim's coming down; strange things may happen.
+                state = this.m_defaultState;
-                        StopAllTimers ();
+            }
-                }
+            else
+            {
-                void IRegionModuleBase.AddRegion (Framework.Scenes.Scene scene)
+                sRegionName = scene.RegionInfo.RegionName;
-                {
+                sRegionLabel = sRegionName;
-                        //NO-OP. Wait for the region to be loaded.
+                prepend = sRegionName + ".";
-                }
+                state = null;
+            }
-                void IRegionModuleBase.RemoveRegion (Framework.Scenes.Scene scene)
-                {
+            /// Read the config settings and set variables.
-                        if (!m_Enabled)
+            IConfig config = this.m_configSource.Configs["AutoBackupModule"];
-                                return;
+            if (config == null)
-                        
+            {
-                        if(states.ContainsKey(scene))
+                /// defaultState would be disabled too if the section doesn't exist.
-                        {
+                state = this.m_defaultState;
-                                AutoBackupModuleState abms = states[scene];
+                m_log.Info("[AUTO BACKUP]: Region " + sRegionLabel + " is NOT AutoBackup enabled.");
-                                
+                return state;
-                                //Remove this scene out of the timer map list
+            }
-                                Timer timer = abms.GetTimer ();
-                                List<IScene> list = timerMap[timer];
+            bool tmpEnabled = config.GetBoolean(prepend + "AutoBackup", this.m_defaultState.Enabled);
-                                list.Remove (scene);
+            if (state == null && tmpEnabled != this.m_defaultState.Enabled)
-                                
+                //Varies from default state
-                                //Shut down the timer if this was the last scene for the timer
+            {
-                                if (list.Count == 0) {
+                state = new AutoBackupModuleState();
-                                        timerMap.Remove (timer);
+            }
-                                        timers.Remove (timer.Interval);
-                                        timer.Close ();
+            if (state != null)
-                                }
+            {
-                                states.Remove(scene);
+                state.Enabled = tmpEnabled;
-                        }
+            }
-                }
+            /// If you don't want AutoBackup, we stop.
-                void IRegionModuleBase.RegionLoaded (Framework.Scenes.Scene scene)
+            if ((state == null && !this.m_defaultState.Enabled) || (state != null && !state.Enabled))
-                {
+            {
-                        if (!m_Enabled)
+                m_log.Info("[AUTO BACKUP]: Region " + sRegionLabel + " is NOT AutoBackup enabled.");
-                                return;
+                return state;
-                        
+            }
-                        //This really ought not to happen, but just in case, let's pretend it didn't...
+            else
-                        if (scene == null)
+            {
-                                return;
+                m_log.Info("[AUTO BACKUP]: Region " + sRegionLabel + " is AutoBackup ENABLED.");
-                                        
+            }
-                        AutoBackupModuleState abms = ParseConfig(scene, false);
-                        m_log.Debug("[AUTO BACKUP]: Config for " + scene.RegionInfo.RegionName);
+            /// Borrow an existing timer if one exists for the same interval; otherwise, make a new one.
-                        m_log.Debug((abms == null ? "DEFAULT" : abms.ToString()));
+            double interval =
-                }
+                config.GetDouble(prepend + "AutoBackupInterval", this.m_defaultState.IntervalMinutes)*
-                
+                60000.0;
-                AutoBackupModuleState ParseConfig (IScene scene, bool parseDefault)
+            if (state == null && interval != this.m_defaultState.IntervalMinutes*60000.0)
-                {
+            {
-                    string sRegionName;
+                state = new AutoBackupModuleState();
-                    string sRegionLabel;
+            }
-                    string prepend;
-                    AutoBackupModuleState state;
+            if (this.m_timers.ContainsKey(interval))
-                    
+            {
-                    if(parseDefault)
+                if (state != null)
-                    {
+                {
-                        sRegionName = null;
+                    state.Timer = this.m_timers[interval];
-                        sRegionLabel = "DEFAULT";
+                }
-                        prepend = "";
+                m_log.Debug("[AUTO BACKUP]: Reusing timer for " + interval + " msec for region " +
-                        state = defaultState;
+                            sRegionLabel);
-                    }
+            }
-                    else
+            else
-                    {
+            {
-                        sRegionName = scene.RegionInfo.RegionName;
+                /// 0 or negative interval == do nothing.
-                        sRegionLabel = sRegionName;
+                if (interval <= 0.0 && state != null)
-                        prepend = sRegionName + ".";
+                {
-                        state = null;
+                    state.Enabled = false;
-                    }
+                    return state;
-                    
+                }
-                    //Read the config settings and set variables.
+                if (state == null)
-                        IConfig config = m_configSource.Configs["AutoBackupModule"];
+                {
-                        if (config == null) {
+                    state = new AutoBackupModuleState();
-                            state = defaultState; //defaultState would be disabled too if the section doesn't exist.
+                }
-                                m_log.Info ("[AUTO BACKUP]: Region " + sRegionLabel + " is NOT AutoBackup enabled.");
+                Timer tim = new Timer(interval);
-                                return state;
+                state.Timer = tim;
-                        }
+                //Milliseconds -> minutes
-                        
+                this.m_timers.Add(interval, tim);
-                        bool tmpEnabled = config.GetBoolean (prepend + "AutoBackup", defaultState.GetEnabled());
+                tim.Elapsed += this.HandleElapsed;
-                        if(state == null && tmpEnabled != defaultState.GetEnabled()) //Varies from default state
+                tim.AutoReset = true;
-                        {
+                tim.Start();
-                            state = new AutoBackupModuleState();
+            }
-                        }
-                        
+            /// Add the current region to the list of regions tied to this timer.
-                        if(state != null)
+            if (scene != null)
-                        {
+            {
-                            state.SetEnabled (tmpEnabled);      
+                if (state != null)
-                        }
+                {
-                        
+                    if (this.m_timerMap.ContainsKey(state.Timer))
-                        //If you don't want AutoBackup, we stop.
+                    {
-                        if ((state == null && !defaultState.GetEnabled()) || (state != null && !state.GetEnabled ())) {
+                        this.m_timerMap[state.Timer].Add(scene);
-                                m_log.Info ("[AUTO BACKUP]: Region " + sRegionLabel + " is NOT AutoBackup enabled.");
+                    }
-                                return state;
+                    else
-                        } else {
+                    {
-                                m_log.Info ("[AUTO BACKUP]: Region " + sRegionLabel + " is AutoBackup ENABLED.");
+                        List<IScene> scns = new List<IScene>(1);
-                        }
+                        scns.Add(scene);
-                        
+                        this.m_timerMap.Add(state.Timer, scns);
-                        //Borrow an existing timer if one exists for the same interval; otherwise, make a new one.
+                    }
-                        double interval = config.GetDouble (prepend + "AutoBackupInterval", defaultState.GetIntervalMinutes()) * 60000.0;
+                }
-                    if(state == null && interval != defaultState.GetIntervalMinutes() * 60000.0)
+                else
-                    {
+                {
-                        state = new AutoBackupModuleState();
+                    if (this.m_timerMap.ContainsKey(this.m_defaultState.Timer))
-                }
+                    {
-                
+                        this.m_timerMap[this.m_defaultState.Timer].Add(scene);
-                        if (timers.ContainsKey (interval)) {
+                    }
-                            if(state != null)
+                    else
-                            state.SetTimer (timers[interval]);
+                    {
-                                m_log.Debug ("[AUTO BACKUP]: Reusing timer for " + interval + " msec for region " + sRegionLabel);
+                        List<IScene> scns = new List<IScene>(1);
-                        } else {
+                        scns.Add(scene);
-                                //0 or negative interval == do nothing.
+                        this.m_timerMap.Add(this.m_defaultState.Timer, scns);
-                                if (interval <= 0.0 && state != null) {
+                    }
-                                        state.SetEnabled (false);
+                }
-                                        return state;
+            }
-                                }
-                                if(state == null)
+            bool tmpBusyCheck = config.GetBoolean(prepend + "AutoBackupBusyCheck",
-                                    state = new AutoBackupModuleState();
+                                                  this.m_defaultState.BusyCheck);
-                                Timer tim = new Timer (interval);
+            if (state == null && tmpBusyCheck != this.m_defaultState.BusyCheck)
-                                state.SetTimer (tim);
+            {
-                                //Milliseconds -> minutes
+                state = new AutoBackupModuleState();
-                                timers.Add (interval, tim);
+            }
-                                tim.Elapsed += HandleElapsed;
-                                tim.AutoReset = true;
+            if (state != null)
-                                tim.Start ();
+            {
-                                //m_log.Debug("[AUTO BACKUP]: New timer for " + interval + " msec for region " + sRegionName);
+                state.BusyCheck = tmpBusyCheck;
-                        }
+            }
-                        
-                        //Add the current region to the list of regions tied to this timer.
+            /// Set file naming algorithm
-                        if(scene != null)
+            string stmpNamingType = config.GetString(prepend + "AutoBackupNaming",
-                        {
+                                                     this.m_defaultState.NamingType.ToString());
-                            if(state != null)
+            NamingType tmpNamingType;
-                            {
+            if (stmpNamingType.Equals("Time", StringComparison.CurrentCultureIgnoreCase))
-                                if (timerMap.ContainsKey (state.GetTimer ())) {
+            {
-                                        timerMap[state.GetTimer ()].Add (scene);
+                tmpNamingType = NamingType.Time;
-                                } else {
+            }
-                                        List<IScene> scns = new List<IScene> (1);
+            else if (stmpNamingType.Equals("Sequential", StringComparison.CurrentCultureIgnoreCase))
-                                        scns.Add (scene);
+            {
-                                        timerMap.Add (state.GetTimer (), scns);
+                tmpNamingType = NamingType.Sequential;
-                                }
+            }
-                            }
+            else if (stmpNamingType.Equals("Overwrite", StringComparison.CurrentCultureIgnoreCase))
-                            else
+            {
-                            {
+                tmpNamingType = NamingType.Overwrite;
-                                if(timerMap.ContainsKey(defaultState.GetTimer())) {
+            }
-                                    timerMap[defaultState.GetTimer()].Add(scene);
+            else
-                                } else {
+            {
-                                    List<IScene> scns = new List<IScene> (1);
+                m_log.Warn("Unknown naming type specified for region " + sRegionLabel + ": " +
-                                    scns.Add(scene);
+                           stmpNamingType);
-                                    timerMap.Add(defaultState.GetTimer(), scns);
+                tmpNamingType = NamingType.Time;
-                                }
+            }
-                            }
-                        }
+            if (state == null && tmpNamingType != this.m_defaultState.NamingType)
-                        
+            {
-                        bool tmpBusyCheck = config.GetBoolean (prepend + "AutoBackupBusyCheck", defaultState.GetBusyCheck());
+                state = new AutoBackupModuleState();
-                        if(state == null && tmpBusyCheck != defaultState.GetBusyCheck())
+            }
-                        {
-                            state = new AutoBackupModuleState();
+            if (state != null)
-                        }
+            {
-                        
+                state.NamingType = tmpNamingType;
-                        if(state != null)
+            }
-                        {
-                        state.SetBusyCheck (tmpBusyCheck);
+            string tmpScript = config.GetString(prepend + "AutoBackupScript",
-                        }
+                                                this.m_defaultState.Script);
-                        
+            if (state == null && tmpScript != this.m_defaultState.Script)
-                        //Set file naming algorithm
+            {
-                        string stmpNamingType = config.GetString (prepend + "AutoBackupNaming", defaultState.GetNamingType().ToString());
+                state = new AutoBackupModuleState();
-                        NamingType tmpNamingType;
+            }
-                        if (stmpNamingType.Equals ("Time", StringComparison.CurrentCultureIgnoreCase)) {
-                                tmpNamingType = NamingType.TIME;
+            if (state != null)
-                        } else if (stmpNamingType.Equals ("Sequential", StringComparison.CurrentCultureIgnoreCase)) {
+            {
-                                tmpNamingType = NamingType.SEQUENTIAL;
+                state.Script = tmpScript;
-                        } else if (stmpNamingType.Equals ("Overwrite", StringComparison.CurrentCultureIgnoreCase)) {
+            }
-                                tmpNamingType = NamingType.OVERWRITE;
-                        } else {
+            string tmpBackupDir = config.GetString(prepend + "AutoBackupDir", ".");
-                                m_log.Warn ("Unknown naming type specified for region " + sRegionLabel + ": " + stmpNamingType);
+            if (state == null && tmpBackupDir != this.m_defaultState.BackupDir)
-                tmpNamingType = NamingType.TIME;
+            {
-                        }
+                state = new AutoBackupModuleState();
-                        
+            }
-                        if(state == null && tmpNamingType != defaultState.GetNamingType())
-                        {
+            if (state != null)
-                            state = new AutoBackupModuleState();
+            {
-                        }
+                state.BackupDir = tmpBackupDir;
-                        
+                /// Let's give the user *one* convenience and auto-mkdir
-                        if(state != null)
+                if (state.BackupDir != ".")
-                        {
+                {
-                            state.SetNamingType(tmpNamingType);
+                    try
-                        }
+                    {
-                        
+                        DirectoryInfo dirinfo = new DirectoryInfo(state.BackupDir);
-                        string tmpScript = config.GetString (prepend + "AutoBackupScript", defaultState.GetScript());
+                        if (!dirinfo.Exists)
-                        if(state == null && tmpScript != defaultState.GetScript())
+                        {
-                        {
+                            dirinfo.Create();
-                            state = new AutoBackupModuleState();
+                        }
-                        }
+                    }
-                        
+                    catch (Exception e)
-                        if(state != null)
+                    {
-                        {
+                        m_log.Warn(
-                            state.SetScript (tmpScript);
+                            "BAD NEWS. You won't be able to save backups to directory " +
-                        }
+                            state.BackupDir +
-                        
+                            " because it doesn't exist or there's a permissions issue with it. Here's the exception.",
-                        string tmpBackupDir = config.GetString (prepend + "AutoBackupDir", ".");
+                            e);
-                        if(state == null && tmpBackupDir != defaultState.GetBackupDir())
+                    }
-                        {
+                }
-                            state = new AutoBackupModuleState();
+            }
-                        }
-                        
+            return state;
-                        if(state != null)
+        }
-                        {
-                            state.SetBackupDir (tmpBackupDir);
+        private void HandleElapsed(object sender, ElapsedEventArgs e)
-                            //Let's give the user *one* convenience and auto-mkdir
+        {
-                            if (state.GetBackupDir () != ".") {
+            /// TODO?: heuristic thresholds are per-region, so we should probably run heuristics once per region
-                                    try {
+            /// XXX: Running heuristics once per region could add undue performance penalty for something that's supposed to
-                                            DirectoryInfo dirinfo = new DirectoryInfo (state.GetBackupDir ());
+            /// check whether the region is too busy! Especially on sims with LOTS of regions.
-                                            if (!dirinfo.Exists) {
+            /// Alternative: make heuristics thresholds global to the module rather than per-region. Less flexible,
-                                                    dirinfo.Create ();
+            ///  but would allow us to be semantically correct while being easier on perf.
-                                            }
+            /// Alternative 2: Run heuristics once per unique set of heuristics threshold parameters! Ay yi yi...
-                                    } catch (Exception e) {
+            if (this.m_closed)
-                                            m_log.Warn ("BAD NEWS. You won't be able to save backups to directory " + state.GetBackupDir () + " because it doesn't exist or there's a permissions issue with it. Here's the exception.", e);
+            {
-                                    }
+                return;
-                            }
+            }
-                        }
+            bool heuristicsRun = false;
-                        
+            bool heuristicsPassed = false;
-                        return state;
+            if (!this.m_timerMap.ContainsKey((Timer) sender))
-                }
+            {
+                m_log.Debug("Code-up error: timerMap doesn't contain timer " + sender);
-                void HandleElapsed (object sender, ElapsedEventArgs e)
+            }
-                {
-                        //TODO?: heuristic thresholds are per-region, so we should probably run heuristics once per region
+            List<IScene> tmap = this.m_timerMap[(Timer) sender];
-                        //XXX: Running heuristics once per region could add undue performance penalty for something that's supposed to
+            if (tmap != null && tmap.Count > 0)
-                        //check whether the region is too busy! Especially on sims with LOTS of regions.
+            {
-                        //Alternative: make heuristics thresholds global to the module rather than per-region. Less flexible,
+                foreach (IScene scene in tmap)
-                        // but would allow us to be semantically correct while being easier on perf.
+                {
-                        //Alternative 2: Run heuristics once per unique set of heuristics threshold parameters! Ay yi yi...
+                    AutoBackupModuleState state = this.m_states[scene];
-                        if (m_closed)
+                    bool heuristics = state.BusyCheck;
-                                return;
-                        bool heuristicsRun = false;
+                    /// Fast path: heuristics are on; already ran em; and sim is fine; OR, no heuristics for the region.
-                        bool heuristicsPassed = false;
+                    if ((heuristics && heuristicsRun && heuristicsPassed) || !heuristics)
-                        if (!timerMap.ContainsKey ((Timer)sender)) {
+                    {
-                                m_log.Debug ("Code-up error: timerMap doesn't contain timer " + sender.ToString ());
+                        this.DoRegionBackup(scene);
-                        }
+                        /// Heuristics are on; ran but we're too busy -- keep going. Maybe another region will have heuristics off!
-                        
+                    }
-                        List<IScene> tmap = timerMap[(Timer)sender];
+                    else if (heuristicsRun)
-                        if(tmap != null && tmap.Count > 0)
+                    {
-                        foreach (IScene scene in tmap) {
+                        m_log.Info("[AUTO BACKUP]: Heuristics: too busy to backup " +
-                                AutoBackupModuleState state = states[scene];
+                                   scene.RegionInfo.RegionName + " right now.");
-                                bool heuristics = state.GetBusyCheck ();
+                        continue;
-                                
+                        /// Logical Deduction: heuristics are on but haven't been run
-                                //Fast path: heuristics are on; already ran em; and sim is fine; OR, no heuristics for the region.
+                    }
-                                if ((heuristics && heuristicsRun && heuristicsPassed) || !heuristics) {
+                    else
-                                        doRegionBackup (scene);
+                    {
-                                        //Heuristics are on; ran but we're too busy -- keep going. Maybe another region will have heuristics off!
+                        heuristicsPassed = this.RunHeuristics(scene);
-                                } else if (heuristics && heuristicsRun && !heuristicsPassed) {
+                        heuristicsRun = true;
-                                        m_log.Info ("[AUTO BACKUP]: Heuristics: too busy to backup " + scene.RegionInfo.RegionName + " right now.");
+                        if (!heuristicsPassed)
-                                        continue;
+                        {
-                                        //Logical Deduction: heuristics are on but haven't been run
+                            m_log.Info("[AUTO BACKUP]: Heuristics: too busy to backup " +
-                                } else {
+                                       scene.RegionInfo.RegionName + " right now.");
-                                        heuristicsPassed = RunHeuristics (scene);
+                            continue;
-                                        heuristicsRun = true;
+                        }
-                                        if (!heuristicsPassed) {
+                        this.DoRegionBackup(scene);
-                                                m_log.Info ("[AUTO BACKUP]: Heuristics: too busy to backup " + scene.RegionInfo.RegionName + " right now.");
+                    }
-                                                continue;
+                }
-                                        }
+            }
-                                        doRegionBackup (scene);
+        }
-                                }
-                        }
+        private void DoRegionBackup(IScene scene)
-                }
+        {
+            if (scene.RegionStatus != RegionStatus.Up)
-                void doRegionBackup (IScene scene)
+            {
-                {
+                /// We won't backup a region that isn't operating normally.
-                        if (scene.RegionStatus != RegionStatus.Up) {
+                m_log.Warn("[AUTO BACKUP]: Not backing up region " + scene.RegionInfo.RegionName +
-                                //We won't backup a region that isn't operating normally.
+                           " because its status is " + scene.RegionStatus);
-                                m_log.Warn ("[AUTO BACKUP]: Not backing up region " + scene.RegionInfo.RegionName + " because its status is " + scene.RegionStatus.ToString ());
+                return;
-                                return;
+            }
-                        }
-                        
+            AutoBackupModuleState state = this.m_states[scene];
-                        AutoBackupModuleState state = states[scene];
+            IRegionArchiverModule iram = scene.RequestModuleInterface<IRegionArchiverModule>();
-                        IRegionArchiverModule iram = scene.RequestModuleInterface<IRegionArchiverModule> ();
+            string savePath = BuildOarPath(scene.RegionInfo.RegionName,
-                        string savePath = BuildOarPath (scene.RegionInfo.RegionName, state.GetBackupDir (), state.GetNamingType ());
+                                                state.BackupDir,
-                        //m_log.Debug("[AUTO BACKUP]: savePath = " + savePath);
+                                                state.NamingType);
-                        if (savePath == null) {
+            /// m_log.Debug("[AUTO BACKUP]: savePath = " + savePath);
-                                m_log.Warn ("[AUTO BACKUP]: savePath is null in HandleElapsed");
+            if (savePath == null)
-                                return;
+            {
-                        }
+                m_log.Warn("[AUTO BACKUP]: savePath is null in HandleElapsed");
-                        iram.ArchiveRegion (savePath, null);
+                return;
-                        ExecuteScript (state.GetScript (), savePath);
+            }
-                }
+            iram.ArchiveRegion(savePath, Guid.NewGuid(), null);
+            ExecuteScript(state.Script, savePath);
-                string IRegionModuleBase.Name {
+        }
-                        get { return "AutoBackupModule"; }
-                }
+        /// This format may turn out to be too unwieldy to keep...
+        /// Besides, that's what ctimes are for. But then how do I name each file uniquely without using a GUID?
-                Type IRegionModuleBase.ReplaceableInterface {
+        /// Sequential numbers, right? Ugh. Almost makes TOO much sense.
-                        get { return null; }
+        private static string GetTimeString()
-                }
+        {
+            StringWriter sw = new StringWriter();
-                #endregion
+            sw.Write("_");
-                #region ISharedRegionModule implementation
+            DateTime now = DateTime.Now;
-                void ISharedRegionModule.PostInitialise ()
+            sw.Write(now.Year);
-                {
+            sw.Write("y_");
-                        //I don't care right now.
+            sw.Write(now.Month);
-                }
+            sw.Write("M_");
+            sw.Write(now.Day);
-                #endregion
+            sw.Write("d_");
+            sw.Write(now.Hour);
-                //Is this even needed?
+            sw.Write("h_");
-                public bool IsSharedModule {
+            sw.Write(now.Minute);
-                        get { return true; }
+            sw.Write("m_");
-                }
+            sw.Write(now.Second);
+            sw.Write("s");
-                private string BuildOarPath (string regionName, string baseDir, NamingType naming)
+            sw.Flush();
-                {
+            string output = sw.ToString();
-                        FileInfo path = null;
+            sw.Close();
-                        switch (naming) {
+            return output;
-                        case NamingType.OVERWRITE:
+        }
-                                path = new FileInfo (baseDir + Path.DirectorySeparatorChar + regionName);
-                                return path.FullName;
+        ///
-                        case NamingType.TIME:
+        /// Return value of true ==> not too busy; false ==> too busy to backup an OAR right now, or error.
-                                path = new FileInfo (baseDir + Path.DirectorySeparatorChar + regionName + GetTimeString () + ".oar");
+        ///
-                                return path.FullName;
+        private bool RunHeuristics(IScene region)
-                        case NamingType.SEQUENTIAL:
+        {
-                                path = new FileInfo (GetNextFile (baseDir, regionName));
+            try
-                                return path.FullName;
+            {
-                        default:
+                return this.RunTimeDilationHeuristic(region) && this.RunAgentLimitHeuristic(region);
-                                m_log.Warn ("VERY BAD: Unhandled case element " + naming.ToString ());
+            }
-                                break;
+            catch (Exception e)
-                        }
+            {
-                        
+                m_log.Warn("[AUTO BACKUP]: Exception in RunHeuristics", e);
-                        return path.FullName;
+                return false;
-                }
+            }
+        }
-                //Welcome to the TIME STRING. 4 CORNER INTEGERS, CUBES 4 QUAD MEMORY -- No 1 Integer God.
-                //(Terrible reference to <timecube.com>)
+        ///
-                //This format may turn out to be too unwieldy to keep...
+        /// If the time dilation right at this instant is less than the threshold specified in AutoBackupDilationThreshold (default 0.5),
-                //Besides, that's what ctimes are for. But then how do I name each file uniquely without using a GUID?
+        /// then we return false and trip the busy heuristic's "too busy" path (i.e. don't save an OAR).
-                //Sequential numbers, right? Ugh. Almost makes TOO much sense.
+        /// AutoBackupDilationThreshold is a _LOWER BOUND_. Lower Time Dilation is bad, so if you go lower than our threshold, it's "too busy".
-                private string GetTimeString ()
+        /// Return value of "true" ==> not too busy. Return value of "false" ==> too busy!
-                {
+        ///
-                        StringWriter sw = new StringWriter ();
+        private bool RunTimeDilationHeuristic(IScene region)
-                        sw.Write ("_");
+        {
-                        DateTime now = DateTime.Now;
+            string regionName = region.RegionInfo.RegionName;
-                        sw.Write (now.Year);
+            return region.TimeDilation >=
-                        sw.Write ("y_");
+                   this.m_configSource.Configs["AutoBackupModule"].GetFloat(
-                        sw.Write (now.Month);
+                       regionName + ".AutoBackupDilationThreshold", 0.5f);
-                        sw.Write ("M_");
+        }
-                        sw.Write (now.Day);
-                        sw.Write ("d_");
+        ///
-                        sw.Write (now.Hour);
+        /// If the root agent count right at this instant is less than the threshold specified in AutoBackupAgentThreshold (default 10),
-                        sw.Write ("h_");
+        /// then we return false and trip the busy heuristic's "too busy" path (i.e., don't save an OAR).
-                        sw.Write (now.Minute);
+        /// AutoBackupAgentThreshold is an _UPPER BOUND_. Higher Agent Count is bad, so if you go higher than our threshold, it's "too busy".
-                        sw.Write ("m_");
+        /// Return value of "true" ==> not too busy. Return value of "false" ==> too busy!
-                        sw.Write (now.Second);
+        ///
-                        sw.Write ("s");
+        private bool RunAgentLimitHeuristic(IScene region)
-                        sw.Flush ();
+        {
-                        string output = sw.ToString ();
+            string regionName = region.RegionInfo.RegionName;
-                        sw.Close ();
+            try
-                        return output;
+            {
-                }
+                Scene scene = (Scene) region;
+                /// TODO: Why isn't GetRootAgentCount() a method in the IScene interface? Seems generally useful...
-                //Get the next logical file name
+                return scene.GetRootAgentCount() <=
-                //I really shouldn't put fields here, but for now.... ;)
+                       this.m_configSource.Configs["AutoBackupModule"].GetInt(
-                private string m_dirName = null;
+                           regionName + ".AutoBackupAgentThreshold", 10);
-                private string m_regionName = null;
+            }
-                private string GetNextFile (string dirName, string regionName)
+            catch (InvalidCastException ice)
-                {
+            {
-                        FileInfo uniqueFile = null;
+                m_log.Debug(
-                        m_dirName = dirName;
+                    "[AUTO BACKUP]: I NEED MAINTENANCE: IScene is not a Scene; can't get root agent count!",
-                        m_regionName = regionName;
+                    ice);
-                        long biggestExistingFile = HalfIntervalMaximize (1, FileExistsTest);
+                return true;
-                        biggestExistingFile++;
+                /// Non-obstructionist safest answer...
-                        //We don't want to overwrite the biggest existing file; we want to write to the NEXT biggest.
+            }
-                        uniqueFile = new FileInfo (m_dirName + Path.DirectorySeparatorChar + m_regionName + "_" + biggestExistingFile + ".oar");
+        }
-                        if (uniqueFile.Exists) {
-                                //Congratulations, your strange deletion patterns fooled my half-interval search into picking an existing file!
+        private static void ExecuteScript(string scriptName, string savePath)
-                                //Now you get to pay the performance cost :)
+        {
-                                uniqueFile = UniqueFileSearchLinear (biggestExistingFile);
+            //Fast path out
-                        }
+            if (scriptName == null || scriptName.Length <= 0)
-                        
+            {
-                        return uniqueFile.FullName;
+                return;
-                }
+            }
-                /*
+            try
-                 * Return value of true ==> not too busy; false ==> too busy to backup an OAR right now, or error.
+            {
-                 * */
+                FileInfo fi = new FileInfo(scriptName);
-                private bool RunHeuristics (IScene region)
+                if (fi.Exists)
-                {
+                {
-                        try {
+                    ProcessStartInfo psi = new ProcessStartInfo(scriptName);
-                                return RunTimeDilationHeuristic (region) && RunAgentLimitHeuristic (region);
+                    psi.Arguments = savePath;
-                        } catch (Exception e) {
+                    psi.CreateNoWindow = true;
-                                m_log.Warn ("[AUTO BACKUP]: Exception in RunHeuristics", e);
+                    Process proc = Process.Start(psi);
-                                return false;
+                    proc.ErrorDataReceived += HandleProcErrorDataReceived;
-                        }
+                }
-                }
+            }
+            catch (Exception e)
-                /*
+            {
-                 * If the time dilation right at this instant is less than the threshold specified in AutoBackupDilationThreshold (default 0.5),
+                m_log.Warn(
-                 * then we return false and trip the busy heuristic's "too busy" path (i.e. don't save an OAR).
+                    "Exception encountered when trying to run script for oar backup " + savePath, e);
-                 * AutoBackupDilationThreshold is a _LOWER BOUND_. Lower Time Dilation is bad, so if you go lower than our threshold, it's "too busy".
+            }
-                 * Return value of "true" ==> not too busy. Return value of "false" ==> too busy!
+        }
-                 * */
-                private bool RunTimeDilationHeuristic (IScene region)
+        private static void HandleProcErrorDataReceived(object sender, DataReceivedEventArgs e)
-                {
+        {
-                        string regionName = region.RegionInfo.RegionName;
+            m_log.Warn("ExecuteScript hook " + ((Process) sender).ProcessName +
-                        return region.TimeDilation >= m_configSource.Configs["AutoBackupModule"].GetFloat (regionName + ".AutoBackupDilationThreshold", 0.5f);
+                       " is yacking on stderr: " + e.Data);
-                }
+        }
-                /*
+        private void StopAllTimers()
-                 * If the root agent count right at this instant is less than the threshold specified in AutoBackupAgentThreshold (default 10),
+        {
-                 * then we return false and trip the busy heuristic's "too busy" path (i.e., don't save an OAR).
+            foreach (Timer t in this.m_timerMap.Keys)
-                 * AutoBackupAgentThreshold is an _UPPER BOUND_. Higher Agent Count is bad, so if you go higher than our threshold, it's "too busy".
+            {
-                 * Return value of "true" ==> not too busy. Return value of "false" ==> too busy!
+                t.Close();
-                 * */
+            }
-                private bool RunAgentLimitHeuristic (IScene region)
+            this.m_closed = true;
-                {
+        }
-                        string regionName = region.RegionInfo.RegionName;
-                        try {
+        private static string GetNextFile(string dirName, string regionName)
-                                Scene scene = (Scene)region;
+        {
-                                //TODO: Why isn't GetRootAgentCount() a method in the IScene interface? Seems generally useful...
+            FileInfo uniqueFile = null;
-                                return scene.GetRootAgentCount () <= m_configSource.Configs["AutoBackupModule"].GetInt (regionName + ".AutoBackupAgentThreshold", 10);
+            long biggestExistingFile = GetNextOarFileNumber(dirName, regionName);
-                        } catch (InvalidCastException ice) {
+            biggestExistingFile++;
-                                m_log.Debug ("[AUTO BACKUP]: I NEED MAINTENANCE: IScene is not a Scene; can't get root agent count!");
+            //We don't want to overwrite the biggest existing file; we want to write to the NEXT biggest.
-                                return true;
+            uniqueFile =
-                                //Non-obstructionist safest answer...
+                new FileInfo(dirName + Path.DirectorySeparatorChar + regionName + "_" +
-                        }
+                             biggestExistingFile + ".oar");
-                }
+            return uniqueFile.FullName;
+        }
-                private void ExecuteScript (string scriptName, string savePath)
-                {
+        private static string BuildOarPath(string regionName, string baseDir, NamingType naming)
-                        //Fast path out
+        {
-                        if (scriptName == null || scriptName.Length <= 0)
+            FileInfo path = null;
-                                return;
+            switch (naming)
-                        
+            {
-                        try {
+                case NamingType.Overwrite:
-                                FileInfo fi = new FileInfo (scriptName);
+                    path = new FileInfo(baseDir + Path.DirectorySeparatorChar + regionName + ".oar");
-                                if (fi.Exists) {
+                    return path.FullName;
-                                        ProcessStartInfo psi = new ProcessStartInfo (scriptName);
+                case NamingType.Time:
-                                        psi.Arguments = savePath;
+                    path =
-                                        psi.CreateNoWindow = true;
+                        new FileInfo(baseDir + Path.DirectorySeparatorChar + regionName +
-                                        Process proc = Process.Start (psi);
+                                     GetTimeString() + ".oar");
-                                        proc.ErrorDataReceived += HandleProcErrorDataReceived;
+                    return path.FullName;
-                                }
+                case NamingType.Sequential:
-                        } catch (Exception e) {
+                    /// All codepaths in GetNextFile should return a file name ending in .oar
-                                m_log.Warn ("Exception encountered when trying to run script for oar backup " + savePath, e);
+                    path = new FileInfo(GetNextFile(baseDir, regionName));
-                        }
+                    return path.FullName;
-                }
+                default:
+                    m_log.Warn("VERY BAD: Unhandled case element " + naming);
-                void HandleProcErrorDataReceived (object sender, DataReceivedEventArgs e)
+                    break;
-                {
+            }
-                        m_log.Warn ("ExecuteScript hook " + ((Process)sender).ProcessName + " is yacking on stderr: " + e.Data);
-                }
+            return null;
+        }
-                private void StopAllTimers ()
-                {
+        private static long GetNextOarFileNumber(string dirName, string regionName)
-                        foreach (Timer t in timerMap.Keys) {
+        {
-                                t.Close ();
+            long retval = 1;
-                        }
-                        m_closed = true;
+            DirectoryInfo di = new DirectoryInfo(dirName);
-                }
+            FileInfo[] fi = di.GetFiles(regionName, SearchOption.TopDirectoryOnly);
+            Array.Sort(fi, (f1, f2) => StringComparer.CurrentCultureIgnoreCase.Compare(f1.Name, f2.Name));
-                /* Find the largest value for which the predicate returns true.
-                 * We use a bisection algorithm (half interval) to make the algorithm scalable.
+            if (fi.LongLength > 0)
-                 * The worst-case complexity is about O(log(n)^2) in practice.
+            {
-                 * Only for extremely small values (under 10) do you notice it taking more iterations than a linear search.
+                long subtract = 1L;
-                 * The number of predicate invocations only hits a few hundred when the maximized value
+                bool worked = false;
-                 *     is in the tens of millions, so prepare for the predicate to be invoked between 10 and 100 times.
+                Regex reg = new Regex(regionName + "_([0-9])+" + ".oar");
-                 * And of course it is fantastic with powers of 2, which are densely packed in values under 100 anyway.
-                 * The Predicate<long> parameter must be a function that accepts a long and returns a bool.
+                while (!worked && subtract <= fi.LongLength)
-                 * */
+                {
-                public long HalfIntervalMaximize (long start, Predicate<long> pred)
+                    /// Pick the file with the last natural ordering
-                {
+                    string biggestFileName = fi[fi.LongLength - subtract].Name;
-                        long prev = start, curr = start, biggest = 0;
+                    MatchCollection matches = reg.Matches(biggestFileName);
-                        
+                    long l = 1;
-                        if (start < 0)
+                    if (matches.Count > 0 && matches[0].Groups.Count > 0)
-                                throw new IndexOutOfRangeException ("Start value for HalfIntervalMaximize must be non-negative");
+                    {
-                        
+                        try
-                        do {
+                        {
-                                if (pred (curr)) {
+                            long.TryParse(matches[0].Groups[1].Value, out l);
-                                        if (curr > biggest) {
+                            retval = l;
-                                                biggest = curr;
+                            worked = true;
-                                        }
+                        }
-                                        prev = curr;
+                        catch (FormatException fe)
-                                        if (curr == 0) {
+                        {
-                                                //Special case because 0 * 2 = 0 :)
+                            m_log.Warn(
-                                                curr = 1;
+                                "[AUTO BACKUP]: Error: Can't parse long value from file name to determine next OAR backup file number!",
-                                        } else {
+                                fe);
-                                                //Look deeper
+                            subtract++;
-                                                curr *= 2;
+                        }
-                                        }
+                    }
-                                } else {
+                    else
-                                        // We went too far, back off halfway
+                    {
-                                        curr = (curr + prev) / 2;
+                        subtract++;
-                                }
+                    }
-                        } while (curr - prev > 0);
+                }
-                        
+            }
-                        return biggest;
+            return retval;
-                }
+        }
+    }
-                public bool FileExistsTest (long num)
+}
-                {
-                        FileInfo test = new FileInfo (m_dirName + Path.DirectorySeparatorChar + m_regionName + "_" + num + ".oar");
-                        return test.Exists;
-                }
-                //Very slow, hence why we try the HalfIntervalMaximize first!
-                public FileInfo UniqueFileSearchLinear (long start)
-                {
-                        long l = start;
-                        FileInfo retval = null;
-                        do {
-                                retval = new FileInfo (m_dirName + Path.DirectorySeparatorChar + m_regionName + "_" + (l++) + ".oar");
-                        } while (retval.Exists);
-                        
-                        return retval;
-                }
-        }
-        
-}