721 lines
28 KiB
C#
Executable File
721 lines
28 KiB
C#
Executable File
/*
|
|
* 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 OpenSimulator 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.Diagnostics;
|
|
using System.IO;
|
|
using System.Reflection;
|
|
using System.Timers;
|
|
using System.Text.RegularExpressions;
|
|
using log4net;
|
|
using Mono.Addins;
|
|
using Nini.Config;
|
|
using OpenSim.Framework;
|
|
using OpenSim.Region.Framework.Interfaces;
|
|
using OpenSim.Region.Framework.Scenes;
|
|
|
|
namespace OpenSim.Region.OptionalModules.World.AutoBackup
|
|
{
|
|
/// <summary>
|
|
/// Choose between ways of naming the backup files that are generated.
|
|
/// </summary>
|
|
/// <remarks>Time: OARs are named by a timestamp.
|
|
/// Sequential: OARs are named by counting (Region_1.oar, Region_2.oar, etc.)
|
|
/// Overwrite: Only one file per region is created; it's overwritten each time a backup is made.</remarks>
|
|
public enum NamingType
|
|
{
|
|
Time,
|
|
Sequential,
|
|
Overwrite
|
|
}
|
|
|
|
///<summary>
|
|
/// AutoBackupModule: save OAR region backups to disk periodically
|
|
/// </summary>
|
|
/// <remarks>
|
|
/// Config Settings Documentation.
|
|
/// Configuration setting can be specified in two places: OpenSim.ini and/or Regions.ini.
|
|
///
|
|
/// OpenSim.ini only settings section [AutoBackupModule]
|
|
/// AutoBackupModuleEnabled: True/False. Default: False. If True, use the auto backup module.
|
|
/// if false module is disable and all rest is ignored
|
|
/// AutoBackupInterval: Double, non-negative value. Default: 720 (12 hours).
|
|
/// The number of minutes between each backup attempt.
|
|
/// AutoBackupDir: String. Default: "." (the current directory).
|
|
/// A directory (absolute or relative) where backups should be saved.
|
|
/// AutoBackupKeepFilesForDays remove files older than this number of days. 0 disables
|
|
///
|
|
/// Next can be set on OpenSim.ini, as default, and or per region in Regions.ini
|
|
/// Region-specific settings take precedence.
|
|
///
|
|
/// AutoBackup: True/False. Default: False. If True, activate auto backup functionality.
|
|
/// controls backup per region, with default optionaly set on OpenSim.ini
|
|
|
|
/// AutoBackupSkipAssets
|
|
/// If true, assets are not saved to the oar file. Considerably reduces impact on simulator when backing up. Intended for when assets db is backed up separately
|
|
/// AutoBackupKeepFilesForDays
|
|
/// Backup files older than this value (in days) are deleted during the current backup process, 0 will disable this and keep all backup files indefinitely
|
|
/// AutoBackupScript: String. Default: not specified (disabled).
|
|
/// File path to an executable script or binary to run when an automatic backup is taken.
|
|
/// The file should really be (Windows) an .exe or .bat, or (Linux/Mac) a shell script or binary.
|
|
/// Trying to "run" directories, or things with weird file associations on Win32, might cause unexpected results!
|
|
/// argv[1] of the executed file/script will be the file name of the generated OAR.
|
|
/// If the process can't be spawned for some reason (file not found, no execute permission, etc), write a warning to the console.
|
|
/// AutoBackupNaming: string. Default: Time.
|
|
/// One of three strings (case insensitive):
|
|
/// "Time": Current timestamp is appended to file name. An existing file will never be overwritten.
|
|
/// "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.
|
|
/// "Overwrite": Always save to file named "${AutoBackupDir}/RegionName.oar", even if we have to overwrite an existing file.
|
|
/// </remarks>
|
|
[Extension(Path = "/OpenSim/RegionModules", NodeName = "RegionModule", Id = "AutoBackupModule")]
|
|
public class AutoBackupModule : ISharedRegionModule
|
|
{
|
|
private static readonly ILog m_log =
|
|
LogManager.GetLogger(MethodBase.GetCurrentMethod().DeclaringType);
|
|
private readonly AutoBackupModuleState m_defaultState = new AutoBackupModuleState();
|
|
private readonly Dictionary<IScene, AutoBackupModuleState> m_states =
|
|
new Dictionary<IScene, AutoBackupModuleState>(1);
|
|
|
|
private delegate T DefaultGetter<T>(string settingName, T defaultValue);
|
|
private bool m_enabled;
|
|
private ICommandConsole m_console;
|
|
private List<Scene> m_Scenes = new List<Scene> ();
|
|
private Timer m_masterTimer;
|
|
private bool m_busy;
|
|
private int m_KeepFilesForDays = -1;
|
|
private string m_backupDir;
|
|
private bool m_doneFirst;
|
|
private double m_baseInterval;
|
|
|
|
private IConfigSource m_configSource;
|
|
|
|
/// <summary>
|
|
/// Required by framework.
|
|
/// </summary>
|
|
public bool IsSharedModule
|
|
{
|
|
get { return true; }
|
|
}
|
|
|
|
#region ISharedRegionModule Members
|
|
|
|
/// <summary>
|
|
/// Identifies the module to the system.
|
|
/// </summary>
|
|
public string Name
|
|
{
|
|
get { return "AutoBackupModule"; }
|
|
}
|
|
|
|
/// <summary>
|
|
/// We don't implement an interface, this is a single-use module.
|
|
/// </summary>
|
|
public Type ReplaceableInterface
|
|
{
|
|
get { return null; }
|
|
}
|
|
|
|
/// <summary>
|
|
/// Called once in the lifetime of the module at startup.
|
|
/// </summary>
|
|
/// <param name="source">The input config source for OpenSim.ini.</param>
|
|
public void Initialise(IConfigSource source)
|
|
{
|
|
// Determine if we have been enabled at all in OpenSim.ini -- this is part and parcel of being an optional module
|
|
m_configSource = source;
|
|
IConfig moduleConfig = source.Configs["AutoBackupModule"];
|
|
if (moduleConfig == null)
|
|
{
|
|
m_enabled = false;
|
|
return;
|
|
}
|
|
|
|
m_enabled = moduleConfig.GetBoolean("AutoBackupModuleEnabled", false);
|
|
if(!m_enabled)
|
|
return;
|
|
|
|
ParseDefaultConfig(moduleConfig);
|
|
if(!m_enabled)
|
|
return;
|
|
|
|
m_log.Debug("[AUTO BACKUP]: Default config:");
|
|
m_log.Debug(m_defaultState.ToString());
|
|
|
|
m_log.Info("[AUTO BACKUP]: AutoBackupModule enabled");
|
|
m_masterTimer = new Timer();
|
|
m_masterTimer.Interval = m_baseInterval;
|
|
m_masterTimer.Elapsed += HandleElapsed;
|
|
m_masterTimer.AutoReset = false;
|
|
|
|
m_console = MainConsole.Instance;
|
|
|
|
m_console.Commands.AddCommand (
|
|
"AutoBackup", true, "dooarbackup",
|
|
"dooarbackup <regionName> | ALL",
|
|
"saves the single region <regionName> to a oar or ALL regions in instance to oars, using same settings as AutoBackup. Note it restarts time interval", DoBackup);
|
|
m_busy = true;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Called once at de-init (sim shutting down).
|
|
/// </summary>
|
|
public void Close()
|
|
{
|
|
if (!m_enabled)
|
|
return;
|
|
|
|
// We don't want any timers firing while the sim's coming down; strange things may happen.
|
|
m_masterTimer.Dispose();
|
|
}
|
|
|
|
/// <summary>
|
|
/// Currently a no-op for AutoBackup because we have to wait for region to be fully loaded.
|
|
/// </summary>
|
|
/// <param name="scene"></param>
|
|
public void AddRegion (Scene scene)
|
|
{
|
|
if (!m_enabled)
|
|
return;
|
|
|
|
lock (m_Scenes)
|
|
m_Scenes.Add (scene);
|
|
}
|
|
|
|
/// <summary>
|
|
/// Here we just clean up some resources and stop the OAR backup (if any) for the given scene.
|
|
/// </summary>
|
|
/// <param name="scene">The scene (region) to stop performing AutoBackup on.</param>
|
|
public void RemoveRegion(Scene scene)
|
|
{
|
|
if (m_enabled)
|
|
return;
|
|
|
|
lock(m_Scenes)
|
|
{
|
|
if (m_states.ContainsKey(scene))
|
|
m_states.Remove(scene);
|
|
m_Scenes.Remove(scene);
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Most interesting/complex code paths in AutoBackup begin here.
|
|
/// We read lots of Nini config, maybe set a timer, add members to state tracking Dictionaries, etc.
|
|
/// </summary>
|
|
/// <param name="scene">The scene to (possibly) perform AutoBackup on.</param>
|
|
public void RegionLoaded(Scene scene)
|
|
{
|
|
if (!m_enabled)
|
|
return;
|
|
|
|
// This really ought not to happen, but just in case, let's pretend it didn't...
|
|
if (scene == null)
|
|
return;
|
|
|
|
AutoBackupModuleState abms = ParseConfig(scene);
|
|
if(abms == null)
|
|
{
|
|
m_log.Debug("[AUTO BACKUP]: Config for " + scene.RegionInfo.RegionName);
|
|
m_log.Debug("DEFAULT");
|
|
abms = new AutoBackupModuleState(m_defaultState);
|
|
}
|
|
else
|
|
{
|
|
m_log.Debug("[AUTO BACKUP]: Config for " + scene.RegionInfo.RegionName);
|
|
m_log.Debug(abms.ToString());
|
|
}
|
|
|
|
m_states.Add(scene, abms);
|
|
m_busy = false;
|
|
m_masterTimer.Start();
|
|
}
|
|
|
|
/// <summary>
|
|
/// Currently a no-op.
|
|
/// </summary>
|
|
public void PostInitialise()
|
|
{
|
|
}
|
|
|
|
#endregion
|
|
|
|
private void DoBackup (string module, string[] args)
|
|
{
|
|
if (!m_enabled)
|
|
return;
|
|
|
|
if (args.Length != 2)
|
|
{
|
|
MainConsole.Instance.Output("Usage: dooarbackup <regionname>");
|
|
return;
|
|
}
|
|
|
|
if(m_busy)
|
|
{
|
|
MainConsole.Instance.Output("Already doing a backup, please try later");
|
|
return;
|
|
}
|
|
|
|
m_masterTimer.Stop();
|
|
m_busy = true;
|
|
|
|
bool found = false;
|
|
string name = args [1];
|
|
Scene[] scenes;
|
|
lock (m_Scenes)
|
|
scenes = m_Scenes.ToArray();
|
|
|
|
if(scenes == null)
|
|
return;
|
|
|
|
Scene s;
|
|
try
|
|
{
|
|
if(name == "ALL")
|
|
{
|
|
for(int i = 0; i < scenes.Length; i++)
|
|
{
|
|
s = scenes[i];
|
|
DoRegionBackup(s);
|
|
if (!m_enabled)
|
|
return;
|
|
}
|
|
return;
|
|
}
|
|
|
|
for(int i = 0; i < scenes.Length; i++)
|
|
{
|
|
s = scenes[i];
|
|
if (s.Name == name)
|
|
{
|
|
found = true;
|
|
DoRegionBackup(s);
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
catch { }
|
|
finally
|
|
{
|
|
if (m_enabled)
|
|
m_masterTimer.Start();
|
|
m_busy = false;
|
|
}
|
|
if (!found)
|
|
MainConsole.Instance.Output("No such region {0}. Nothing to backup", null, name);
|
|
}
|
|
|
|
private void ParseDefaultConfig(IConfig config)
|
|
{
|
|
|
|
m_backupDir = ".";
|
|
string backupDir = config.GetString("AutoBackupDir", ".");
|
|
if (backupDir != ".")
|
|
{
|
|
try
|
|
{
|
|
DirectoryInfo dirinfo = new DirectoryInfo(backupDir);
|
|
if (!dirinfo.Exists)
|
|
dirinfo.Create();
|
|
}
|
|
catch (Exception e)
|
|
{
|
|
m_enabled = false;
|
|
m_log.WarnFormat("[AUTO BACKUP]: Error accessing backup folder {0}. Module disabled. {1}",
|
|
backupDir, e);
|
|
return;
|
|
}
|
|
}
|
|
m_backupDir = backupDir;
|
|
|
|
double interval = config.GetDouble("AutoBackupInterval", 720);
|
|
interval *= 60000.0;
|
|
m_baseInterval = interval;
|
|
|
|
// How long to keep backup files in days, 0 Disables this feature
|
|
m_KeepFilesForDays = config.GetInt("AutoBackupKeepFilesForDays",m_KeepFilesForDays);
|
|
|
|
m_defaultState.Enabled = config.GetBoolean("AutoBackup", m_defaultState.Enabled);
|
|
|
|
m_defaultState.SkipAssets = config.GetBoolean("AutoBackupSkipAssets",m_defaultState.SkipAssets);
|
|
|
|
// Set file naming algorithm
|
|
string stmpNamingType = config.GetString("AutoBackupNaming", m_defaultState.NamingType.ToString());
|
|
NamingType tmpNamingType;
|
|
if (stmpNamingType.Equals("Time", StringComparison.CurrentCultureIgnoreCase))
|
|
tmpNamingType = NamingType.Time;
|
|
else if (stmpNamingType.Equals("Sequential", StringComparison.CurrentCultureIgnoreCase))
|
|
tmpNamingType = NamingType.Sequential;
|
|
else if (stmpNamingType.Equals("Overwrite", StringComparison.CurrentCultureIgnoreCase))
|
|
tmpNamingType = NamingType.Overwrite;
|
|
else
|
|
{
|
|
m_log.Warn("Unknown naming type specified for Default");
|
|
tmpNamingType = NamingType.Time;
|
|
}
|
|
m_defaultState.NamingType = tmpNamingType;
|
|
|
|
m_defaultState.Script = config.GetString("AutoBackupScript", m_defaultState.Script);
|
|
|
|
}
|
|
|
|
/// <summary>
|
|
/// Set up internal state for a given scene. Fairly complex code.
|
|
/// When this method returns, we've started auto-backup timers, put members in Dictionaries, and created a State object for this scene.
|
|
/// </summary>
|
|
/// <param name="scene">The scene to look at.</param>
|
|
/// <param name="parseDefault">Whether this call is intended to figure out what we consider the "default" config (applied to all regions unless overridden by per-region settings).</param>
|
|
/// <returns>An AutoBackupModuleState contains most information you should need to know relevant to auto-backup, as applicable to a single region.</returns>
|
|
private AutoBackupModuleState ParseConfig(IScene scene)
|
|
{
|
|
if(scene == null)
|
|
return null;
|
|
|
|
string sRegionName;
|
|
AutoBackupModuleState state = null;
|
|
|
|
sRegionName = scene.RegionInfo.RegionName;
|
|
|
|
// Read the config settings and set variables.
|
|
IConfig regionConfig = scene.Config.Configs[sRegionName];
|
|
if (regionConfig == null)
|
|
return null;
|
|
|
|
state = new AutoBackupModuleState();
|
|
|
|
state.Enabled = regionConfig.GetBoolean("AutoBackup", m_defaultState.Enabled);
|
|
|
|
// Included Option To Skip Assets
|
|
state.SkipAssets = regionConfig.GetBoolean("AutoBackupSkipAssets", m_defaultState.SkipAssets);
|
|
|
|
// Set file naming algorithm
|
|
string stmpNamingType = regionConfig.GetString("AutoBackupNaming", m_defaultState.NamingType.ToString());
|
|
NamingType tmpNamingType;
|
|
if (stmpNamingType.Equals("Time", StringComparison.CurrentCultureIgnoreCase))
|
|
tmpNamingType = NamingType.Time;
|
|
else if (stmpNamingType.Equals("Sequential", StringComparison.CurrentCultureIgnoreCase))
|
|
tmpNamingType = NamingType.Sequential;
|
|
else if (stmpNamingType.Equals("Overwrite", StringComparison.CurrentCultureIgnoreCase))
|
|
tmpNamingType = NamingType.Overwrite;
|
|
else
|
|
{
|
|
m_log.Warn("Unknown naming type specified for region " + sRegionName + ": " +
|
|
stmpNamingType);
|
|
tmpNamingType = NamingType.Time;
|
|
}
|
|
m_defaultState.NamingType = tmpNamingType;
|
|
|
|
state.Script = regionConfig.GetString("AutoBackupScript", m_defaultState.Script);
|
|
return state;
|
|
}
|
|
|
|
|
|
/// <summary>
|
|
/// Called when any auto-backup timer expires. This starts the code path for actually performing a backup.
|
|
/// </summary>
|
|
/// <param name="sender"></param>
|
|
/// <param name="e"></param>
|
|
private void HandleElapsed(object sender, ElapsedEventArgs e)
|
|
{
|
|
if (!m_enabled || m_busy)
|
|
return;
|
|
|
|
m_busy = true;
|
|
if(m_doneFirst && m_KeepFilesForDays > 0)
|
|
RemoveOldFiles();
|
|
|
|
foreach (IScene scene in m_Scenes)
|
|
{
|
|
if (!m_enabled)
|
|
return;
|
|
DoRegionBackup(scene);
|
|
}
|
|
|
|
if (m_enabled)
|
|
{
|
|
m_masterTimer.Start();
|
|
m_busy = false;
|
|
}
|
|
|
|
m_doneFirst = true;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Save an OAR, register for the callback for when it's done, then call the AutoBackupScript (if applicable).
|
|
/// </summary>
|
|
/// <param name="scene"></param>
|
|
private void DoRegionBackup(IScene scene)
|
|
{
|
|
if (!scene.Ready)
|
|
{
|
|
// We won't backup a region that isn't operating normally.
|
|
m_log.Warn("[AUTO BACKUP]: Not backing up region " + scene.RegionInfo.RegionName +
|
|
" because its status is " + scene.RegionStatus);
|
|
return;
|
|
}
|
|
|
|
m_busy = true;
|
|
|
|
AutoBackupModuleState state;
|
|
if(!m_states.TryGetValue(scene, out state))
|
|
return;
|
|
|
|
if(state == null || !state.Enabled)
|
|
return;
|
|
|
|
IRegionArchiverModule iram = scene.RequestModuleInterface<IRegionArchiverModule>();
|
|
if(iram == null)
|
|
return;
|
|
|
|
string savePath = BuildOarPath(scene.RegionInfo.RegionName,
|
|
m_backupDir,
|
|
state.NamingType);
|
|
if (savePath == null)
|
|
{
|
|
m_log.Warn("[AUTO BACKUP]: savePath is null in HandleElapsed");
|
|
return;
|
|
}
|
|
|
|
Guid guid = Guid.NewGuid();
|
|
m_log.Info("[AUTO BACKUP]: Backing up region " + scene.RegionInfo.RegionName);
|
|
|
|
// Must pass options, even if dictionary is empty!
|
|
Dictionary<string, object> options = new Dictionary<string, object>();
|
|
|
|
if (state.SkipAssets)
|
|
options["noassets"] = true;
|
|
|
|
iram.ArchiveRegion(savePath, guid, options);
|
|
ExecuteScript(state.Script, savePath);
|
|
}
|
|
|
|
// For the given state, remove backup files older than the states KeepFilesForDays property
|
|
private void RemoveOldFiles()
|
|
{
|
|
string[] files;
|
|
try
|
|
{
|
|
files = Directory.GetFiles(m_backupDir, "*.oar");
|
|
}
|
|
catch (Exception Ex)
|
|
{
|
|
m_log.Error("[AUTO BACKUP]: Error reading backup folder " + m_backupDir + ": " + Ex.Message);
|
|
return;
|
|
}
|
|
|
|
DateTime CuttOffDate = DateTime.Now.AddDays(-m_KeepFilesForDays);
|
|
|
|
foreach (string file in files)
|
|
{
|
|
try
|
|
{
|
|
FileInfo fi = new FileInfo(file);
|
|
if (fi.CreationTime < CuttOffDate)
|
|
fi.Delete();
|
|
}
|
|
catch (Exception Ex)
|
|
{
|
|
m_log.Error("[AUTO BACKUP]: Error deleting old backup file '" + file + "': " + Ex.Message);
|
|
}
|
|
}
|
|
}
|
|
|
|
/// <summary>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?
|
|
/// Sequential numbers, right? We support those, too!</summary>
|
|
private static string GetTimeString()
|
|
{
|
|
StringWriter sw = new StringWriter();
|
|
sw.Write("_");
|
|
DateTime now = DateTime.Now;
|
|
sw.Write(now.Year);
|
|
sw.Write("y_");
|
|
sw.Write(now.Month);
|
|
sw.Write("M_");
|
|
sw.Write(now.Day);
|
|
sw.Write("d_");
|
|
sw.Write(now.Hour);
|
|
sw.Write("h_");
|
|
sw.Write(now.Minute);
|
|
sw.Write("m_");
|
|
sw.Write(now.Second);
|
|
sw.Write("s");
|
|
sw.Flush();
|
|
string output = sw.ToString();
|
|
sw.Close();
|
|
return output;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Run the script or executable specified by the "AutoBackupScript" config setting.
|
|
/// Of course this is a security risk if you let anyone modify OpenSim.ini and they want to run some nasty bash script.
|
|
/// But there are plenty of other nasty things that can be done with an untrusted OpenSim.ini, such as running high threat level scripting functions.
|
|
/// </summary>
|
|
/// <param name="scriptName"></param>
|
|
/// <param name="savePath"></param>
|
|
private static void ExecuteScript(string scriptName, string savePath)
|
|
{
|
|
// Do nothing if there's no script.
|
|
if (scriptName == null || scriptName.Length <= 0)
|
|
{
|
|
return;
|
|
}
|
|
|
|
try
|
|
{
|
|
FileInfo fi = new FileInfo(scriptName);
|
|
if (fi.Exists)
|
|
{
|
|
ProcessStartInfo psi = new ProcessStartInfo(scriptName);
|
|
psi.Arguments = savePath;
|
|
psi.CreateNoWindow = true;
|
|
Process proc = Process.Start(psi);
|
|
proc.ErrorDataReceived += HandleProcErrorDataReceived;
|
|
}
|
|
}
|
|
catch (Exception e)
|
|
{
|
|
m_log.Warn(
|
|
"Exception encountered when trying to run script for oar backup " + savePath, e);
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Called if a running script process writes to stderr.
|
|
/// </summary>
|
|
/// <param name="sender"></param>
|
|
/// <param name="e"></param>
|
|
private static void HandleProcErrorDataReceived(object sender, DataReceivedEventArgs e)
|
|
{
|
|
m_log.Warn("ExecuteScript hook " + ((Process) sender).ProcessName +
|
|
" is yacking on stderr: " + e.Data);
|
|
}
|
|
|
|
/// <summary>
|
|
/// Determine the next unique filename by number, for "Sequential" AutoBackupNamingType.
|
|
/// </summary>
|
|
/// <param name="dirName"></param>
|
|
/// <param name="regionName"></param>
|
|
/// <returns></returns>
|
|
private static string GetNextFile(string dirName, string regionName)
|
|
{
|
|
FileInfo uniqueFile = null;
|
|
long biggestExistingFile = GetNextOarFileNumber(dirName, regionName);
|
|
biggestExistingFile++;
|
|
// We don't want to overwrite the biggest existing file; we want to write to the NEXT biggest.
|
|
uniqueFile =
|
|
new FileInfo(dirName + Path.DirectorySeparatorChar + regionName + "_" +
|
|
biggestExistingFile + ".oar");
|
|
return uniqueFile.FullName;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Top-level method for creating an absolute path to an OAR backup file based on what naming scheme the user wants.
|
|
/// </summary>
|
|
/// <param name="regionName">Name of the region to save.</param>
|
|
/// <param name="baseDir">Absolute or relative path to the directory where the file should reside.</param>
|
|
/// <param name="naming">The naming scheme for the file name.</param>
|
|
/// <returns></returns>
|
|
private static string BuildOarPath(string regionName, string baseDir, NamingType naming)
|
|
{
|
|
FileInfo path = null;
|
|
switch (naming)
|
|
{
|
|
case NamingType.Overwrite:
|
|
path = new FileInfo(baseDir + Path.DirectorySeparatorChar + regionName + ".oar");
|
|
return path.FullName;
|
|
case NamingType.Time:
|
|
path =
|
|
new FileInfo(baseDir + Path.DirectorySeparatorChar + regionName +
|
|
GetTimeString() + ".oar");
|
|
return path.FullName;
|
|
case NamingType.Sequential:
|
|
// All codepaths in GetNextFile should return a file name ending in .oar
|
|
path = new FileInfo(GetNextFile(baseDir, regionName));
|
|
return path.FullName;
|
|
default:
|
|
m_log.Warn("VERY BAD: Unhandled case element " + naming);
|
|
break;
|
|
}
|
|
|
|
return null;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Helper function for Sequential file naming type (see BuildOarPath and GetNextFile).
|
|
/// </summary>
|
|
/// <param name="dirName"></param>
|
|
/// <param name="regionName"></param>
|
|
/// <returns></returns>
|
|
private static long GetNextOarFileNumber(string dirName, string regionName)
|
|
{
|
|
long retval = 1;
|
|
|
|
DirectoryInfo di = new DirectoryInfo(dirName);
|
|
FileInfo[] fi = di.GetFiles(regionName, SearchOption.TopDirectoryOnly);
|
|
Array.Sort(fi, (f1, f2) => StringComparer.CurrentCultureIgnoreCase.Compare(f1.Name, f2.Name));
|
|
|
|
if (fi.LongLength > 0)
|
|
{
|
|
long subtract = 1L;
|
|
bool worked = false;
|
|
Regex reg = new Regex(regionName + "_([0-9])+" + ".oar");
|
|
|
|
while (!worked && subtract <= fi.LongLength)
|
|
{
|
|
// Pick the file with the last natural ordering
|
|
string biggestFileName = fi[fi.LongLength - subtract].Name;
|
|
MatchCollection matches = reg.Matches(biggestFileName);
|
|
long l = 1;
|
|
if (matches.Count > 0 && matches[0].Groups.Count > 0)
|
|
{
|
|
try
|
|
{
|
|
long.TryParse(matches[0].Groups[1].Value, out l);
|
|
retval = l;
|
|
worked = true;
|
|
}
|
|
catch (FormatException fe)
|
|
{
|
|
m_log.Warn(
|
|
"[AUTO BACKUP]: Error: Can't parse long value from file name to determine next OAR backup file number!",
|
|
fe);
|
|
subtract++;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
subtract++;
|
|
}
|
|
}
|
|
}
|
|
return retval;
|
|
}
|
|
}
|
|
}
|