529 lines
21 KiB
C#
529 lines
21 KiB
C#
/*
|
|
* Copyright (c) Contributors, http://opensimulator.org/
|
|
* See CONTRIBUTORS.TXT for a full list of copyright holders.
|
|
*
|
|
* Redistribution and use in source and binary forms, with or without
|
|
* modification, are permitted provided that the following conditions are met:
|
|
* * Redistributions of source code must retain the above copyright
|
|
* notice, this list of conditions and the following disclaimer.
|
|
* * Redistributions in binary form must reproduce the above copyright
|
|
* notice, this list of conditions and the following disclaimer in the
|
|
* documentation and/or other materials provided with the distribution.
|
|
* * Neither the name of the OpenSim Project nor the
|
|
* names of its contributors may be used to endorse or promote products
|
|
* derived from this software without specific prior written permission.
|
|
*
|
|
* THIS SOFTWARE IS PROVIDED BY THE DEVELOPERS ``AS IS'' AND ANY
|
|
* EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
|
|
* WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
|
|
* DISCLAIMED. IN NO EVENT SHALL THE CONTRIBUTORS BE LIABLE FOR ANY
|
|
* DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
|
|
* (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
|
|
* LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
|
|
* ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
|
|
* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
|
|
* SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
|
*
|
|
*/
|
|
|
|
using System;
|
|
using System.Collections.Generic;
|
|
using System.IO;
|
|
using System.Net;
|
|
using System.Reflection;
|
|
using System.Text;
|
|
using System.Timers;
|
|
using System.Xml;
|
|
using libsecondlife;
|
|
using log4net;
|
|
using Nini.Config;
|
|
using OpenSim.Framework.Communications;
|
|
using OpenSim.Region.DataSnapshot.Interfaces;
|
|
using OpenSim.Region.Environment.Interfaces;
|
|
using OpenSim.Region.Environment.Scenes;
|
|
|
|
namespace OpenSim.Region.DataSnapshot
|
|
{
|
|
public class DataSnapshotManager : IRegionModule
|
|
{
|
|
#region Class members
|
|
private List<Scene> m_scenes = new List<Scene>();
|
|
private static readonly ILog m_log = LogManager.GetLogger(MethodBase.GetCurrentMethod().DeclaringType);
|
|
private bool m_enabled = false;
|
|
private bool m_configLoaded = false;
|
|
internal object m_syncInit = new object();
|
|
private DataRequestHandler m_requests = null;
|
|
private Dictionary<Scene, List<IDataSnapshotProvider>> m_dataproviders = new Dictionary<Scene, List<IDataSnapshotProvider>>();
|
|
private Dictionary<string, string> m_gridinfo = new Dictionary<string, string>();
|
|
//private int m_oldestSnapshot = 0;
|
|
private int m_maxSnapshots = 500;
|
|
private int m_lastSnapshot = 0;
|
|
private string m_snapsDir = "DataSnapshot";
|
|
private string m_dataServices = "noservices";
|
|
private string m_listener_port = "9000"; //TODO: Set default port over 9000
|
|
private string m_hostname = "127.0.0.1";
|
|
private Timer m_periodic = null;
|
|
private int m_period = 60; // in seconds
|
|
private List<string> m_disabledModules = new List<string>();
|
|
#endregion
|
|
|
|
#region IRegionModule
|
|
public void Close()
|
|
{
|
|
|
|
}
|
|
|
|
public void Initialise(Scene scene, IConfigSource config)
|
|
{
|
|
if (!m_scenes.Contains(scene))
|
|
m_scenes.Add(scene);
|
|
|
|
if (!m_configLoaded)
|
|
{
|
|
m_configLoaded = true;
|
|
m_log.Info("[DATASNAPSHOT]: Loading configuration");
|
|
//Read from the config for options
|
|
lock (m_syncInit)
|
|
{
|
|
try
|
|
{
|
|
m_enabled = config.Configs["DataSnapshot"].GetBoolean("index_sims", m_enabled);
|
|
if (config.Configs["Startup"].GetBoolean("gridmode", true))
|
|
{
|
|
m_gridinfo.Add("gridserverURL", config.Configs["Network"].GetString("grid_server_url", "harbl"));
|
|
m_gridinfo.Add("userserverURL", config.Configs["Network"].GetString("user_server_url", "harbl"));
|
|
m_gridinfo.Add("assetserverURL", config.Configs["Network"].GetString("asset_server_url", "harbl"));
|
|
}
|
|
else
|
|
{
|
|
//Non gridmode stuff
|
|
}
|
|
|
|
m_gridinfo.Add("Name", config.Configs["DataSnapshot"].GetString("gridname", "harbl"));
|
|
m_maxSnapshots = config.Configs["DataSnapshot"].GetInt("max_snapshots", m_maxSnapshots);
|
|
m_period = config.Configs["DataSnapshot"].GetInt("default_snapshot_period", m_period);
|
|
m_snapsDir = config.Configs["DataSnapshot"].GetString("snapshot_cache_directory", m_snapsDir);
|
|
m_dataServices = config.Configs["DataSnapshot"].GetString("data_services", m_dataServices);
|
|
m_listener_port = config.Configs["Network"].GetString("http_listener_port", m_listener_port);
|
|
//BUG: Naming a search data module "DESUDESUDESU" will cause it to not get loaded by default.
|
|
//RESOLUTION: Wontfix, there are no Suiseiseki-loving developers
|
|
String[] annoying_string_array = config.Configs["DataSnapshot"].GetString("disable_modules", "DESUDESUDESU").Split(".".ToCharArray());
|
|
foreach (String bloody_wanker in annoying_string_array)
|
|
{
|
|
m_disabledModules.Add(bloody_wanker);
|
|
}
|
|
}
|
|
catch (Exception)
|
|
{
|
|
m_log.Info("[DATASNAPSHOT]: Could not load configuration. DataSnapshot will be disabled.");
|
|
m_enabled = false;
|
|
return;
|
|
}
|
|
}
|
|
}
|
|
if (Directory.Exists(m_snapsDir))
|
|
{
|
|
m_log.Info("[DATASNAPSHOT] DataSnapshot directory already exists.");
|
|
}
|
|
else
|
|
{
|
|
// Try to create the directory.
|
|
m_log.Info("[DATASNAPSHOT] Creating " + m_snapsDir + " directory.");
|
|
try
|
|
{
|
|
Directory.CreateDirectory(m_snapsDir);
|
|
}
|
|
catch (Exception)
|
|
{
|
|
m_log.Error("[DATASNAPSHOT] Failed to create " + m_snapsDir + " directory.");
|
|
}
|
|
}
|
|
|
|
if (m_enabled)
|
|
{
|
|
m_log.Info("[DATASNAPSHOT]: Scene added to module.");
|
|
}
|
|
else
|
|
{
|
|
m_log.Warn("[DATASNAPSHOT]: Data snapshot disabled, not adding scene to module (or anything else).");
|
|
}
|
|
}
|
|
|
|
public bool IsSharedModule
|
|
{
|
|
get { return true; }
|
|
}
|
|
|
|
public string Name
|
|
{
|
|
get { return "External Data Generator"; }
|
|
}
|
|
|
|
public void PostInitialise()
|
|
{
|
|
if (m_enabled)
|
|
{
|
|
//Right now, only load ISearchData objects in the current assembly.
|
|
//Eventually allow it to load ISearchData objects from all assemblies.
|
|
Assembly currentasm = Assembly.GetExecutingAssembly();
|
|
|
|
//Stolen from ModuleLoader.cs
|
|
foreach (Type pluginType in currentasm.GetTypes())
|
|
{
|
|
if (pluginType.IsPublic)
|
|
{
|
|
if (!pluginType.IsAbstract)
|
|
{
|
|
if (pluginType.GetInterface("IDataSnapshotProvider") != null)
|
|
{
|
|
foreach (Scene scene in m_scenes)
|
|
{
|
|
IDataSnapshotProvider module = (IDataSnapshotProvider)Activator.CreateInstance(pluginType);
|
|
module.Initialize(scene, this);
|
|
//module.PrepareData();
|
|
List<IDataSnapshotProvider> providerlist = null;
|
|
m_dataproviders.TryGetValue(scene, out providerlist);
|
|
if (providerlist == null)
|
|
{
|
|
providerlist = new List<IDataSnapshotProvider>();
|
|
m_dataproviders.Add(scene, providerlist);
|
|
}
|
|
providerlist.Add(module);
|
|
|
|
}
|
|
m_log.Info("[DATASNAPSHOT]: Added new data provider type: " + pluginType.Name);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
//Hand it the first scene, assuming that all scenes have the same BaseHTTPServer
|
|
m_requests = new DataRequestHandler(m_scenes[0], this);
|
|
|
|
//Create timer
|
|
m_periodic = new Timer();
|
|
m_periodic.Interval = m_period * 1000;
|
|
m_periodic.Elapsed += SnapshotTimerCallback;
|
|
m_periodic.Enabled = true;
|
|
|
|
m_hostname = m_scenes[0].RegionInfo.ExternalHostName;
|
|
|
|
MakeNewSnapshot(); //Make the initial snapshot
|
|
|
|
if (m_dataServices != "noservices")
|
|
NotifyDataServices(m_dataServices);
|
|
}
|
|
}
|
|
#endregion
|
|
|
|
#region Associated helper functions
|
|
|
|
string DataFileName(Scene scene)
|
|
{
|
|
return Path.Combine(m_snapsDir, Path.ChangeExtension(scene.RegionInfo.RegionName, "xml"));
|
|
//return (m_snapsDir + Path.DirectorySeparatorChar + scene.RegionInfo.RegionName + ".xml");
|
|
}
|
|
|
|
Scene SceneForName(string name)
|
|
{
|
|
foreach (Scene scene in m_scenes)
|
|
if (scene.RegionInfo.RegionName == name)
|
|
return scene;
|
|
|
|
return null;
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region [Private] XML snapshot generator
|
|
|
|
private XmlDocument Snapshot(Scene scene)
|
|
{
|
|
XmlDocument basedoc = new XmlDocument();
|
|
XmlNode regionElement = MakeRegionNode(scene, basedoc);
|
|
|
|
regionElement.AppendChild(GetGridSnapshotData(basedoc));
|
|
XmlNode regionData = basedoc.CreateNode(XmlNodeType.Element, "data", "");
|
|
|
|
foreach (KeyValuePair<Scene, List<IDataSnapshotProvider>> dataprovider in m_dataproviders)
|
|
{
|
|
if (dataprovider.Key == scene)
|
|
{
|
|
foreach (IDataSnapshotProvider provider in dataprovider.Value)
|
|
{
|
|
XmlNode data = provider.RequestSnapshotData(basedoc);
|
|
regionData.AppendChild(data);
|
|
}
|
|
}
|
|
}
|
|
|
|
regionElement.AppendChild(regionData);
|
|
|
|
basedoc.AppendChild(regionElement);
|
|
|
|
return basedoc;
|
|
}
|
|
|
|
private XmlNode MakeRegionNode(Scene scene, XmlDocument basedoc)
|
|
{
|
|
XmlNode docElement = basedoc.CreateNode(XmlNodeType.Element, "region", "");
|
|
|
|
XmlAttribute attr = basedoc.CreateAttribute("category");
|
|
attr.Value = GetRegionCategory(scene);
|
|
docElement.Attributes.Append(attr);
|
|
|
|
attr = basedoc.CreateAttribute("entities");
|
|
attr.Value = scene.Entities.Count.ToString();
|
|
docElement.Attributes.Append(attr);
|
|
|
|
//attr = basedoc.CreateAttribute("parcels");
|
|
//attr.Value = scene.LandManager.landList.Count.ToString();
|
|
//docElement.Attributes.Append(attr);
|
|
|
|
|
|
XmlNode infoblock = basedoc.CreateNode(XmlNodeType.Element, "info", "");
|
|
|
|
XmlNode infopiece = basedoc.CreateNode(XmlNodeType.Element, "uuid", "");
|
|
infopiece.InnerText = scene.RegionInfo.RegionID.ToString();
|
|
infoblock.AppendChild(infopiece);
|
|
|
|
infopiece = basedoc.CreateNode(XmlNodeType.Element, "url", "");
|
|
infopiece.InnerText = "http://" + m_hostname + ":" + m_listener_port;
|
|
infoblock.AppendChild(infopiece);
|
|
|
|
infopiece = basedoc.CreateNode(XmlNodeType.Element, "name", "");
|
|
infopiece.InnerText = scene.RegionInfo.RegionName;
|
|
infoblock.AppendChild(infopiece);
|
|
|
|
docElement.AppendChild(infoblock);
|
|
|
|
return docElement;
|
|
}
|
|
|
|
private XmlNode GetGridSnapshotData(XmlDocument factory)
|
|
{
|
|
XmlNode griddata = factory.CreateNode(XmlNodeType.Element, "grid", "");
|
|
|
|
foreach (KeyValuePair<String, String> GridData in m_gridinfo)
|
|
{
|
|
//TODO: make it lowercase tag names for diva
|
|
XmlNode childnode = factory.CreateNode(XmlNodeType.Element, GridData.Key, "");
|
|
childnode.InnerText = GridData.Value;
|
|
griddata.AppendChild(childnode);
|
|
}
|
|
|
|
return griddata;
|
|
}
|
|
|
|
private String GetRegionCategory(Scene scene)
|
|
{
|
|
|
|
//Boolean choice between:
|
|
// "PG" - Mormontown
|
|
// "Mature" - Sodom and Gomorrah
|
|
// (Depreciated) "Patriotic Nigra Testing Sandbox" - Abandon Hope All Ye Who Enter Here
|
|
if ((scene.RegionInfo.EstateSettings.simAccess & Simulator.SimAccess.Mature) == Simulator.SimAccess.Mature)
|
|
{
|
|
return "Mature";
|
|
}
|
|
else if ((scene.RegionInfo.EstateSettings.simAccess & Simulator.SimAccess.PG) == Simulator.SimAccess.PG)
|
|
{
|
|
return "PG";
|
|
}
|
|
else
|
|
{
|
|
return "Unknown";
|
|
}
|
|
}
|
|
|
|
/* Code's closed due to AIDS, See EstateSnapshot.cs for CURE
|
|
private XmlNode GetEstateSnapshotData(Scene scene, XmlDocument factory)
|
|
{
|
|
//Estate data section - contains who owns a set of sims and the name of the set.
|
|
//In Opensim all the estate names are the same as the Master Avatar (owner of the sim)
|
|
XmlNode estatedata = factory.CreateNode(XmlNodeType.Element, "estate", "");
|
|
|
|
LLUUID ownerid = scene.RegionInfo.MasterAvatarAssignedUUID;
|
|
String firstname = scene.RegionInfo.MasterAvatarFirstName;
|
|
String lastname = scene.RegionInfo.MasterAvatarLastName;
|
|
String hostname = scene.RegionInfo.ExternalHostName;
|
|
|
|
XmlNode user = factory.CreateNode(XmlNodeType.Element, "owner", "");
|
|
|
|
XmlNode username = factory.CreateNode(XmlNodeType.Element, "name", "");
|
|
username.InnerText = firstname + " " + lastname;
|
|
user.AppendChild(username);
|
|
|
|
XmlNode useruuid = factory.CreateNode(XmlNodeType.Element, "uuid", "");
|
|
useruuid.InnerText = ownerid.ToString();
|
|
user.AppendChild(useruuid);
|
|
|
|
estatedata.AppendChild(user);
|
|
|
|
return estatedata;
|
|
} */
|
|
|
|
#endregion
|
|
|
|
#region [Public] Snapshot storage functions
|
|
|
|
public void MakeNewSnapshot()
|
|
{
|
|
foreach (Scene scene in m_scenes)
|
|
{
|
|
XmlDocument snapshot = Snapshot(scene);
|
|
|
|
string path = DataFileName(scene);
|
|
|
|
try
|
|
{
|
|
using (XmlTextWriter snapXWriter = new XmlTextWriter(path, Encoding.Default))
|
|
{
|
|
snapXWriter.Formatting = Formatting.Indented;
|
|
snapXWriter.WriteStartDocument();
|
|
snapshot.WriteTo(snapXWriter);
|
|
snapXWriter.WriteEndDocument();
|
|
|
|
m_lastSnapshot++;
|
|
}
|
|
}
|
|
catch (Exception e)
|
|
{
|
|
m_log.Warn("[DATASNAPSHOT]: Caught unknown exception while trying to save snapshot: " + path + "\n" + e.ToString());
|
|
}
|
|
m_log.Info("[DATASNAPSHOT]: Made external data snapshot " + path);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Reply to the http request
|
|
*/
|
|
public XmlDocument GetSnapshot(string regionName)
|
|
{
|
|
XmlDocument requestedSnap = new XmlDocument();
|
|
requestedSnap.AppendChild(requestedSnap.CreateXmlDeclaration("1.0", null, null));
|
|
requestedSnap.AppendChild(requestedSnap.CreateWhitespace("\r\n"));
|
|
XmlNode regiondata = requestedSnap.CreateNode(XmlNodeType.Element, "regiondata", "");
|
|
try
|
|
{
|
|
if (regionName == null || regionName == "")
|
|
{
|
|
foreach (Scene scene in m_scenes)
|
|
{
|
|
string path = DataFileName(scene);
|
|
XmlDocument regionSnap = new XmlDocument();
|
|
regionSnap.PreserveWhitespace = true;
|
|
|
|
regionSnap.Load(path);
|
|
XmlNode nodeOrig = regionSnap["region"];
|
|
XmlNode nodeDest = requestedSnap.ImportNode(nodeOrig, true);
|
|
//requestedSnap.AppendChild(nodeDest);
|
|
|
|
regiondata.AppendChild(requestedSnap.CreateWhitespace("\r\n"));
|
|
regiondata.AppendChild(nodeDest);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
Scene scene = SceneForName(regionName);
|
|
requestedSnap.Load(DataFileName(scene));
|
|
}
|
|
// requestedSnap.InsertBefore(requestedSnap.CreateXmlDeclaration("1.0", null, null),
|
|
// requestedSnap.DocumentElement);
|
|
requestedSnap.AppendChild(regiondata);
|
|
regiondata.AppendChild(requestedSnap.CreateWhitespace("\r\n"));
|
|
|
|
|
|
}
|
|
catch (XmlException e)
|
|
{
|
|
m_log.Warn("[DATASNAPSHOT]: XmlException while trying to load snapshot: " + e.ToString());
|
|
requestedSnap = GetErrorMessage(regionName, e);
|
|
}
|
|
catch (Exception e)
|
|
{
|
|
m_log.Warn("[DATASNAPSHOT]: Caught unknown exception while trying to load snapshot: " + e.StackTrace);
|
|
requestedSnap = GetErrorMessage(regionName, e);
|
|
}
|
|
|
|
|
|
return requestedSnap;
|
|
}
|
|
|
|
private XmlDocument GetErrorMessage(string regionName, Exception e)
|
|
{
|
|
XmlDocument errorMessage = new XmlDocument();
|
|
XmlNode error = errorMessage.CreateNode(XmlNodeType.Element, "error", "");
|
|
XmlNode region = errorMessage.CreateNode(XmlNodeType.Element, "region", "");
|
|
region.InnerText = regionName;
|
|
|
|
XmlNode exception = errorMessage.CreateNode(XmlNodeType.Element, "exception", "");
|
|
exception.InnerText = e.ToString();
|
|
|
|
error.AppendChild(region);
|
|
error.AppendChild(exception);
|
|
errorMessage.AppendChild(error);
|
|
|
|
return errorMessage;
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region Event callbacks
|
|
|
|
private void SnapshotTimerCallback(object timer, ElapsedEventArgs args)
|
|
{
|
|
MakeNewSnapshot();
|
|
//Add extra calls here
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region External data services
|
|
private void NotifyDataServices(string servicesStr)
|
|
{
|
|
Stream reply = null;
|
|
string delimStr = ";";
|
|
char [] delimiter = delimStr.ToCharArray();
|
|
|
|
string[] services = servicesStr.Split(delimiter);
|
|
|
|
for (int i = 0; i < services.Length; i++)
|
|
{
|
|
string url = services[i].Trim();
|
|
RestClient cli = new RestClient(url);
|
|
cli.AddQueryParameter("host", m_hostname);
|
|
cli.AddQueryParameter("port", m_listener_port);
|
|
cli.RequestMethod = "GET";
|
|
try
|
|
{
|
|
reply = cli.Request();
|
|
}
|
|
catch (WebException)
|
|
{
|
|
m_log.Warn("[DATASNAPSHOT] Unable to notify " + url);
|
|
}
|
|
catch (Exception e)
|
|
{
|
|
m_log.Warn("[DATASNAPSHOT] Ignoring unknown exception " + e.ToString());
|
|
}
|
|
byte[] response = new byte[1024];
|
|
int n = 0;
|
|
try
|
|
{
|
|
n = reply.Read(response, 0, 1024);
|
|
}
|
|
catch (Exception e)
|
|
{
|
|
m_log.Warn("[DATASNAPSHOT] Unable to decode reply from data service. Ignoring. " + e.StackTrace);
|
|
}
|
|
// This is not quite working, so...
|
|
string responseStr = Encoding.UTF8.GetString(response);
|
|
m_log.Info("[DATASNAPSHOT] data service notified: " + url);
|
|
}
|
|
|
|
}
|
|
#endregion
|
|
}
|
|
}
|