/// <summary>
/// Save an inventory folder
/// </summary>
/// <param name="inventoryFolder">The inventory folder to save</param>
/// <param name="path">The path to which the folder should be saved</param>
/// <param name="saveThisFolderItself">If true, save this folder itself. If false, only saves contents</param>
/// <param name="options"></param>
/// <param name="userAccountService"></param>
protected void SaveInvFolder(
InventoryFolderBase inventoryFolder, string path, bool saveThisFolderItself,
Dictionary <string, object> options, IUserAccountService userAccountService)
{
if (options.ContainsKey("excludefolders"))
{
if (((List <String>)options["excludefolders"]).Contains(inventoryFolder.Name) ||
((List <String>)options["excludefolders"]).Contains(inventoryFolder.ID.ToString()))
{
if (options.ContainsKey("verbose"))
{
m_log.InfoFormat(
"[INVENTORY ARCHIVER]: Skipping folder {0} at {1}",
inventoryFolder.Name, path);
}
return;
}
}
if (options.ContainsKey("verbose"))
{
m_log.InfoFormat("[INVENTORY ARCHIVER]: Saving folder {0}", inventoryFolder.Name);
}
if (saveThisFolderItself)
{
path += CreateArchiveFolderName(inventoryFolder);
// We need to make sure that we record empty folders
m_archiveWriter.WriteDir(path);
}
InventoryCollection contents
= m_scene.InventoryService.GetFolderContent(inventoryFolder.Owner, inventoryFolder.ID);
foreach (InventoryFolderBase childFolder in contents.Folders)
{
SaveInvFolder(childFolder, path, true, options, userAccountService);
}
foreach (InventoryItemBase item in contents.Items)
{
SaveInvItem(item, path, options, userAccountService);
}
}
private static void WriteInventoryFolderToArchive(
TarArchiveWriter archive, InventoryFolderWithChildren folder, string path)
{
path += string.Format("{0}{1}{2}/", folder.Name, ArchiveConstants.INVENTORY_NODE_NAME_COMPONENT_SEPARATOR, folder.ID);
archive.WriteDir(path);
foreach (InventoryNodeBase inventoryNode in folder.Children.Values)
{
if (inventoryNode is InventoryFolderWithChildren)
{
WriteInventoryFolderToArchive(archive, (InventoryFolderWithChildren)inventoryNode, path);
}
else if (inventoryNode is InventoryItemBase)
{
WriteInventoryItemToArchive(archive, (InventoryItemBase)inventoryNode, path);
}
}
}
public void SaveRegionBackup(TarArchiveWriter writer, IScene scene)
{
writer.WriteDir("assets"); //Used by many, create it by default
IAuroraBackupModule[] modules = scene.RequestModuleInterfaces <IAuroraBackupModule>();
foreach (IAuroraBackupModule module in modules)
{
module.SaveModuleToArchive(writer, scene);
}
foreach (IAuroraBackupModule module in modules)
{
while (module.IsArchiving) //Wait until all are done
{
System.Threading.Thread.Sleep(100);
}
}
writer.Close();
}
public void SaveRegionBackup(TarArchiveWriter writer, IScene scene)
{
writer.WriteDir("assets"); //Used by many, create it by default
IAuroraBackupModule[] modules = scene.RequestModuleInterfaces <IAuroraBackupModule>();
foreach (IAuroraBackupModule module in modules)
{
module.SaveModuleToArchive(writer, scene);
}
foreach (IAuroraBackupModule module in modules)
{
while (module.IsArchiving) //Wait until all are done
{
Thread.Sleep(100);
}
}
writer.Close();
GC.Collect();
MainConsole.Instance.Info("[Archive]: Finished saving of archive.");
}
/// <summary>
/// Save an inventory folder
/// </summary>
/// <param name="inventoryFolder">The inventory folder to save</param>
/// <param name="path">The path to which the folder should be saved</param>
/// <param name="saveThisFolderItself">If true, save this folder itself. If false, only saves contents</param>
protected void SaveInvFolder(InventoryFolderBase inventoryFolder, string path, bool saveThisFolderItself)
{
if (saveThisFolderItself)
{
path += CreateArchiveFolderName(inventoryFolder);
// We need to make sure that we record empty folders
m_archiveWriter.WriteDir(path);
}
InventoryCollection contents = FindInventoryCollection(inventoryFolder.Owner, inventoryFolder.ID);
foreach (InventoryFolderBase childFolder in contents.Folders)
{
SaveInvFolder(childFolder, path, true);
}
foreach (InventoryItemBase item in contents.Items)
{
SaveInvItem(item, path);
}
}
/// <summary>
/// Save a backup of the sim
/// </summary>
/// <param name = "appendedFilePath">The file path where the backup will be saved</param>
protected virtual void SaveBackup(string appendedFilePath, bool saveAssets)
{
if (appendedFilePath == "/")
{
appendedFilePath = "";
}
if (m_scene.RegionInfo.HasBeenDeleted)
{
return;
}
IBackupModule backupModule = m_scene.RequestModuleInterface <IBackupModule>();
if (backupModule != null && backupModule.LoadingPrims) //Something is changing lots of prims
{
MainConsole.Instance.Info("[Backup]: Not saving backup because the backup module is loading prims");
return;
}
//Save any script state saves that might be around
IScriptModule[] engines = m_scene.RequestModuleInterfaces <IScriptModule>();
try
{
if (engines != null)
{
#if (!ISWIN)
foreach (IScriptModule engine in engines)
{
if (engine != null)
{
engine.SaveStateSaves();
}
}
#else
foreach (IScriptModule engine in engines.Where(engine => engine != null))
{
engine.SaveStateSaves();
}
#endif
}
}
catch (Exception ex)
{
MainConsole.Instance.WarnFormat("[Backup]: Exception caught: {0}", ex);
}
MainConsole.Instance.Info("[FileBasedSimulationData]: Saving backup for region " + m_scene.RegionInfo.RegionName);
string fileName = appendedFilePath + m_scene.RegionInfo.RegionName + m_saveAppendedFileName + ".abackup";
if (File.Exists(fileName))
{
//Do new style saving here!
GZipStream m_saveStream = new GZipStream(new FileStream(fileName + ".tmp", FileMode.Create),
CompressionMode.Compress);
TarArchiveWriter writer = new TarArchiveWriter(m_saveStream);
GZipStream m_loadStream = new GZipStream(new FileStream(fileName, FileMode.Open),
CompressionMode.Decompress);
TarArchiveReader reader = new TarArchiveReader(m_loadStream);
writer.WriteDir("parcels");
IParcelManagementModule module = m_scene.RequestModuleInterface <IParcelManagementModule>();
if (module != null)
{
List <ILandObject> landObject = module.AllParcels();
foreach (ILandObject parcel in landObject)
{
OSDMap parcelMap = parcel.LandData.ToOSD();
var binary = OSDParser.SerializeLLSDBinary(parcelMap);
writer.WriteFile("parcels/" + parcel.LandData.GlobalID.ToString(),
binary);
binary = null;
parcelMap = null;
}
}
writer.WriteDir("newstyleterrain");
writer.WriteDir("newstylerevertterrain");
writer.WriteDir("newstylewater");
writer.WriteDir("newstylerevertwater");
ITerrainModule tModule = m_scene.RequestModuleInterface <ITerrainModule>();
if (tModule != null)
{
try
{
byte[] sdata = WriteTerrainToStream(tModule.TerrainMap);
writer.WriteFile("newstyleterrain/" + m_scene.RegionInfo.RegionID.ToString() + ".terrain", sdata);
sdata = null;
sdata = WriteTerrainToStream(tModule.TerrainRevertMap);
writer.WriteFile(
"newstylerevertterrain/" + m_scene.RegionInfo.RegionID.ToString() + ".terrain", sdata);
sdata = null;
if (tModule.TerrainWaterMap != null)
{
sdata = WriteTerrainToStream(tModule.TerrainWaterMap);
writer.WriteFile("newstylewater/" + m_scene.RegionInfo.RegionID.ToString() + ".terrain",
sdata);
sdata = null;
sdata = WriteTerrainToStream(tModule.TerrainWaterRevertMap);
writer.WriteFile(
"newstylerevertwater/" + m_scene.RegionInfo.RegionID.ToString() + ".terrain", sdata);
sdata = null;
}
}
catch (Exception ex)
{
MainConsole.Instance.WarnFormat("[Backup]: Exception caught: {0}", ex);
}
}
IDictionary <UUID, AssetType> assets = new Dictionary <UUID, AssetType>();
UuidGatherer assetGatherer = new UuidGatherer(m_scene.AssetService);
ISceneEntity[] saveentities = m_scene.Entities.GetEntities();
List <UUID> entitiesToSave = new List <UUID>();
foreach (ISceneEntity entity in saveentities)
{
try
{
if (entity.IsAttachment ||
((entity.RootChild.Flags & PrimFlags.Temporary) == PrimFlags.Temporary) ||
((entity.RootChild.Flags & PrimFlags.TemporaryOnRez) == PrimFlags.TemporaryOnRez))
{
continue;
}
if (entity.HasGroupChanged)
{
entity.HasGroupChanged = false;
//Write all entities
byte[] xml = ((ISceneObject)entity).ToBinaryXml2();
writer.WriteFile("entities/" + entity.UUID.ToString(), xml);
xml = null;
}
else
{
entitiesToSave.Add(entity.UUID);
}
if (saveAssets)
{
assetGatherer.GatherAssetUuids(entity, assets, m_scene);
}
}
catch (Exception ex)
{
MainConsole.Instance.WarnFormat("[Backup]: Exception caught: {0}", ex);
entitiesToSave.Add(entity.UUID);
}
}
byte[] data;
string filePath;
TarArchiveReader.TarEntryType entryType;
//Load the archive data that we need
try
{
while ((data = reader.ReadEntry(out filePath, out entryType)) != null)
{
if (TarArchiveReader.TarEntryType.TYPE_DIRECTORY == entryType)
{
continue;
}
if (filePath.StartsWith("entities/"))
{
UUID entityID = UUID.Parse(filePath.Remove(0, 9));
if (entitiesToSave.Contains(entityID))
{
writer.WriteFile(filePath, data);
entitiesToSave.Remove(entityID);
}
}
data = null;
}
}
catch (Exception ex)
{
MainConsole.Instance.WarnFormat("[Backup]: Exception caught: {0}", ex);
}
if (entitiesToSave.Count > 0)
{
MainConsole.Instance.Fatal(entitiesToSave.Count + " PRIMS WERE NOT GOING TO BE SAVED! FORCE SAVING NOW! ");
foreach (ISceneEntity entity in saveentities)
{
if (entitiesToSave.Contains(entity.UUID))
{
if (entity.IsAttachment ||
((entity.RootChild.Flags & PrimFlags.Temporary) == PrimFlags.Temporary) ||
((entity.RootChild.Flags & PrimFlags.TemporaryOnRez) == PrimFlags.TemporaryOnRez))
{
continue;
}
//Write all entities
byte[] xml = ((ISceneObject)entity).ToBinaryXml2();
writer.WriteFile("entities/" + entity.UUID.ToString(), xml);
xml = null;
}
}
}
if (saveAssets)
{
foreach (UUID assetID in new List <UUID>(assets.Keys))
{
try
{
WriteAsset(assetID.ToString(), m_scene.AssetService.Get(assetID.ToString()), writer);
}
catch (Exception ex)
{
MainConsole.Instance.WarnFormat("[Backup]: Exception caught: {0}", ex);
}
}
}
reader.Close();
writer.Close();
m_loadStream.Close();
m_saveStream.Close();
GC.Collect();
if (m_keepOldSave && !m_oldSaveHasBeenSaved)
{
//Havn't moved it yet, so make sure the directory exists, then move it
m_oldSaveHasBeenSaved = true;
if (!Directory.Exists(m_oldSaveDirectory))
{
Directory.CreateDirectory(m_oldSaveDirectory);
}
File.Copy(fileName + ".tmp",
Path.Combine(m_oldSaveDirectory,
m_scene.RegionInfo.RegionName + SerializeDateTime() + m_saveAppendedFileName +
".abackup"));
}
//Just remove the file
File.Delete(fileName);
}
else
{
//Add the .temp since we might need to make a backup and so that if something goes wrong, we don't corrupt the main backup
GZipStream m_saveStream = new GZipStream(new FileStream(fileName + ".tmp", FileMode.Create),
CompressionMode.Compress);
TarArchiveWriter writer = new TarArchiveWriter(m_saveStream);
IAuroraBackupArchiver archiver = m_scene.RequestModuleInterface <IAuroraBackupArchiver>();
//Turn off prompting so that we don't ask the user questions every time we need to save the backup
archiver.AllowPrompting = false;
archiver.SaveRegionBackup(writer, m_scene);
archiver.AllowPrompting = true;
m_saveStream.Close();
writer.Close();
GC.Collect();
}
File.Move(fileName + ".tmp", fileName);
ISceneEntity[] entities = m_scene.Entities.GetEntities();
try
{
#if (!ISWIN)
foreach (ISceneEntity entity in entities)
{
if (entity.HasGroupChanged)
{
entity.HasGroupChanged = false;
}
}
#else
foreach (ISceneEntity entity in entities.Where(entity => entity.HasGroupChanged))
{
entity.HasGroupChanged = false;
}
#endif
}
catch (Exception ex)
{
MainConsole.Instance.WarnFormat("[Backup]: Exception caught: {0}", ex);
}
//Now make it the full file again
MapTileNeedsGenerated = true;
MainConsole.Instance.Info("[FileBasedSimulationData]: Saved Backup for region " + m_scene.RegionInfo.RegionName);
}
public void TestLoadOarV0_2()
{
TestHelper.InMethod();
//log4net.Config.XmlConfigurator.Configure();
MemoryStream archiveWriteStream = new MemoryStream();
TarArchiveWriter tar = new TarArchiveWriter(archiveWriteStream);
// Put in a random blank directory to check that this doesn't upset the load process
tar.WriteDir("ignoreme");
// Also check that direct entries which will also have a file entry containing that directory doesn't
// upset load
tar.WriteDir(ArchiveConstants.TERRAINS_PATH);
tar.WriteFile(ArchiveConstants.CONTROL_FILE_PATH, ArchiveWriteRequestExecution.Create0p2ControlFile());
string part1Name = "object1";
PrimitiveBaseShape shape = PrimitiveBaseShape.CreateCylinder();
Vector3 groupPosition = new Vector3(90, 80, 70);
Quaternion rotationOffset = new Quaternion(60, 70, 80, 90);
Vector3 offsetPosition = new Vector3(20, 25, 30);
SerialiserModule serialiserModule = new SerialiserModule();
ArchiverModule archiverModule = new ArchiverModule();
Scene scene = SceneSetupHelpers.SetupScene();
SceneSetupHelpers.SetupSceneModules(scene, serialiserModule, archiverModule);
SceneObjectPart part1
= new SceneObjectPart(
UUID.Zero, shape, groupPosition, rotationOffset, offsetPosition);
part1.Name = part1Name;
SceneObjectGroup object1 = new SceneObjectGroup(part1);
scene.AddNewSceneObject(object1, false);
string object1FileName = string.Format(
"{0}_{1:000}-{2:000}-{3:000}__{4}.xml",
part1Name,
Math.Round(groupPosition.X), Math.Round(groupPosition.Y), Math.Round(groupPosition.Z),
part1.UUID);
tar.WriteFile(ArchiveConstants.OBJECTS_PATH + object1FileName, SceneObjectSerializer.ToXml2Format(object1));
tar.Close();
MemoryStream archiveReadStream = new MemoryStream(archiveWriteStream.ToArray());
lock (this)
{
scene.EventManager.OnOarFileLoaded += LoadCompleted;
archiverModule.DearchiveRegion(archiveReadStream);
}
Assert.That(m_lastErrorMessage, Is.Null);
SceneObjectPart object1PartLoaded = scene.GetSceneObjectPart(part1Name);
Assert.That(object1PartLoaded, Is.Not.Null, "object1 was not loaded");
Assert.That(object1PartLoaded.Name, Is.EqualTo(part1Name), "object1 names not identical");
Assert.That(object1PartLoaded.GroupPosition, Is.EqualTo(groupPosition), "object1 group position not equal");
Assert.That(
object1PartLoaded.RotationOffset, Is.EqualTo(rotationOffset), "object1 rotation offset not equal");
Assert.That(
object1PartLoaded.OffsetPosition, Is.EqualTo(offsetPosition), "object1 offset position not equal");
// Temporary
Console.WriteLine("Successfully completed {0}", MethodBase.GetCurrentMethod());
}
public void SaveModuleToArchive(TarArchiveWriter writer, IScene scene)
{
m_isArchiving = true;
MainConsole.Instance.Info("[Archive]: Writing parcels to archive");
writer.WriteDir("parcels");
IParcelManagementModule module = scene.RequestModuleInterface <IParcelManagementModule> ();
if (module != null)
{
List <ILandObject> landObject = module.AllParcels();
foreach (ILandObject parcel in landObject)
{
OSDMap parcelMap = parcel.LandData.ToOSD();
writer.WriteFile("parcels/" + parcel.LandData.GlobalID,
OSDParser.SerializeLLSDBinary(parcelMap));
}
}
MainConsole.Instance.Info("[Archive]: Finished writing parcels to archive");
MainConsole.Instance.Info("[Archive]: Writing terrain to archive");
writer.WriteDir("newstyleterrain");
writer.WriteDir("newstylerevertterrain");
writer.WriteDir("newstylewater");
writer.WriteDir("newstylerevertwater");
ITerrainModule tModule = scene.RequestModuleInterface <ITerrainModule> ();
if (tModule != null)
{
try {
byte [] sdata = WriteTerrainToStream(tModule.TerrainMap);
writer.WriteFile("newstyleterrain/" + scene.RegionInfo.RegionID + ".terrain", sdata);
sdata = WriteTerrainToStream(tModule.TerrainRevertMap);
writer.WriteFile("newstylerevertterrain/" + scene.RegionInfo.RegionID + ".terrain",
sdata);
sdata = null;
if (tModule.TerrainWaterMap != null)
{
sdata = WriteTerrainToStream(tModule.TerrainWaterMap);
writer.WriteFile("newstylewater/" + scene.RegionInfo.RegionID + ".terrain", sdata);
sdata = WriteTerrainToStream(tModule.TerrainWaterRevertMap);
writer.WriteFile(
"newstylerevertwater/" + scene.RegionInfo.RegionID + ".terrain", sdata);
sdata = null;
}
} catch (Exception ex) {
MainConsole.Instance.WarnFormat("[Backup]: Exception caught: {0}", ex);
}
}
MainConsole.Instance.Info("[Archive]: Finished writing terrain to archive");
MainConsole.Instance.Info("[Archive]: Writing entities to archive");
ISceneEntity [] entities = scene.Entities.GetEntities();
//Get all entities, then start writing them to the database
writer.WriteDir("entities");
IDictionary <UUID, AssetType> assets = new Dictionary <UUID, AssetType> ();
UuidGatherer assetGatherer = new UuidGatherer(m_scene.AssetService);
IWhiteCoreBackupArchiver archiver = m_scene.RequestModuleInterface <IWhiteCoreBackupArchiver> ();
bool saveAssets = false;
if (archiver.AllowPrompting)
{
saveAssets =
MainConsole.Instance.Prompt("Save assets? (Will not be able to load on other grids if not saved)", "false")
.Equals("true", StringComparison.CurrentCultureIgnoreCase);
}
int count = 0;
foreach (ISceneEntity entity in entities)
{
try {
if (entity.IsAttachment ||
((entity.RootChild.Flags & PrimFlags.Temporary) == PrimFlags.Temporary) ||
((entity.RootChild.Flags & PrimFlags.TemporaryOnRez) == PrimFlags.TemporaryOnRez))
{
continue;
}
//Write all entities
byte [] xml = entity.ToBinaryXml2();
writer.WriteFile("entities/" + entity.UUID, xml);
xml = null;
count++;
if (count % 3 == 0)
{
Thread.Sleep(5);
}
//Get all the assets too
if (saveAssets)
{
assetGatherer.GatherAssetUuids(entity, assets);
}
} catch (Exception ex) {
MainConsole.Instance.WarnFormat("[Backup]: Exception caught: {0}", ex);
}
}
entities = null;
MainConsole.Instance.Info("[Archive]: Finished writing entities to archive");
MainConsole.Instance.Info("[Archive]: Writing assets for entities to archive");
bool foundAllAssets = true;
foreach (UUID assetID in new List <UUID> (assets.Keys))
{
try {
foundAllAssets = false; //Not all are cached
m_scene.AssetService.Get(assetID.ToString(), writer, RetrievedAsset);
m_missingAssets.Add(assetID);
} catch (Exception ex) {
MainConsole.Instance.WarnFormat("[Backup]: Exception caught: {0}", ex);
}
}
if (foundAllAssets)
{
m_isArchiving = false; //We're done if all the assets were found
}
MainConsole.Instance.Info("[Archive]: Finished writing assets for entities to archive");
}
public void SaveModuleToArchive(TarArchiveWriter writer, IScene scene)
{
m_isArchiving = true;
m_log.Info("[Archive]: Writing parcels to archive");
writer.WriteDir("parcels");
IParcelManagementModule module = scene.RequestModuleInterface <IParcelManagementModule>();
if (module != null)
{
List <ILandObject> landObject = module.AllParcels();
foreach (ILandObject parcel in landObject)
{
OSDMap parcelMap = parcel.LandData.ToOSD();
writer.WriteFile("parcels/" + parcel.LandData.GlobalID.ToString(), OSDParser.SerializeLLSDBinary(parcelMap));
}
}
m_log.Info("[Archive]: Finished writing parcels to archive");
m_log.Info("[Archive]: Writing terrain to archive");
writer.WriteDir("terrain");
ITerrainModule tModule = scene.RequestModuleInterface <ITerrainModule>();
if (tModule != null)
{
MemoryStream s = new MemoryStream();
tModule.SaveToStream(scene.RegionInfo.RegionID.ToString() + ".r32", s);
writer.WriteFile("terrain/" + scene.RegionInfo.RegionID.ToString() + ".r32", s.ToArray());
s.Close();
}
m_log.Info("[Archive]: Finished writing terrain to archive");
m_log.Info("[Archive]: Writing entities to archive");
ISceneEntity[] entities = scene.Entities.GetEntities();
//Get all entities, then start writing them to the database
writer.WriteDir("entities");
IDictionary <UUID, AssetType> assets = new Dictionary <UUID, AssetType>();
UuidGatherer assetGatherer = new UuidGatherer(m_scene.AssetService);
foreach (ISceneEntity entity in entities)
{
//Write all entities
writer.WriteFile("entities/" + entity.UUID.ToString(), ((ISceneObject)entity).ToXml2());
//Get all the assets too
assetGatherer.GatherAssetUuids(entity, assets, scene);
}
m_log.Info("[Archive]: Finished writing entities to archive");
m_log.Info("[Archive]: Writing assets for entities to archive");
bool foundAllAssets = true;
foreach (UUID assetID in new List <UUID>(assets.Keys))
{
AssetBase asset = m_scene.AssetService.GetCached(assetID.ToString());
if (asset != null)
{
WriteAsset(asset, writer); //Write it syncronously since we havn't
}
else
{
foundAllAssets = false; //Not all are cached
m_missingAssets.Add(assetID);
m_scene.AssetService.Get(assetID.ToString(), writer, RetrievedAsset);
}
}
if (foundAllAssets)
{
m_isArchiving = false; //We're done if all the assets were found
}
m_log.Info("[Archive]: Finished writing assets for entities to archive");
}
public bool SaveBackup(string fileName, RegionData regiondata)
{
try
{
bool oldFileExists = File.Exists(fileName);
//Do new style saving here!
GZipStream m_saveStream = new GZipStream(new FileStream(fileName + ".tmp", FileMode.Create),
CompressionMode.Compress);
TarArchiveWriter writer = new TarArchiveWriter(m_saveStream);
GZipStream m_loadStream = new GZipStream(new FileStream(fileName, FileMode.Open),
CompressionMode.Decompress);
TarArchiveReader reader = new TarArchiveReader(m_loadStream);
writer.WriteDir("parcels");
foreach (LandData parcel in regiondata.Parcels)
{
OSDMap parcelMap = parcel.ToOSD();
var binary = OSDParser.SerializeLLSDBinary(parcelMap);
writer.WriteFile("parcels/" + parcel.GlobalID.ToString(),
binary);
binary = null;
parcelMap = null;
}
writer.WriteDir("newstyleterrain");
writer.WriteDir("newstylerevertterrain");
writer.WriteDir("newstylewater");
writer.WriteDir("newstylerevertwater");
writer.WriteDir("regioninfo");
byte[] regionData = OSDParser.SerializeLLSDBinary(regiondata.RegionInfo.PackRegionInfoData());
writer.WriteFile("regioninfo/regioninfo", regionData);
try
{
writer.WriteFile("newstyleterrain/" + regiondata.RegionInfo.RegionID.ToString() + ".terrain",
regiondata.Terrain);
writer.WriteFile(
"newstylerevertterrain/" + regiondata.RegionInfo.RegionID.ToString() + ".terrain",
regiondata.RevertTerrain);
if (regiondata.Water != null)
{
writer.WriteFile("newstylewater/" + regiondata.RegionInfo.RegionID.ToString() + ".terrain",
regiondata.Water);
writer.WriteFile(
"newstylerevertwater/" + regiondata.RegionInfo.RegionID.ToString() + ".terrain",
regiondata.RevertWater);
}
}
catch (Exception ex)
{
MainConsole.Instance.WarnFormat("[Backup]: Exception caught: {0}", ex);
}
List <UUID> entitiesToSave = new List <UUID>();
foreach (ISceneEntity entity in regiondata.Groups)
{
try
{
if (entity.IsAttachment ||
((entity.RootChild.Flags & PrimFlags.Temporary) == PrimFlags.Temporary) ||
((entity.RootChild.Flags & PrimFlags.TemporaryOnRez) == PrimFlags.TemporaryOnRez))
{
continue;
}
if (entity.HasGroupChanged || !oldFileExists)
{
entity.HasGroupChanged = false;
//Write all entities
writer.WriteFile("entities/" + entity.UUID.ToString(), entity.ToBinaryXml2());
}
else
{
entitiesToSave.Add(entity.UUID);
}
}
catch (Exception ex)
{
MainConsole.Instance.WarnFormat("[Backup]: Exception caught: {0}", ex);
entitiesToSave.Add(entity.UUID);
}
}
if (oldFileExists)
{
byte[] data;
string filePath;
TarArchiveReader.TarEntryType entryType;
//Load the archive data that we need
try
{
while ((data = reader.ReadEntry(out filePath, out entryType)) != null)
{
if (TarArchiveReader.TarEntryType.TYPE_DIRECTORY == entryType)
{
continue;
}
if (filePath.StartsWith("entities/"))
{
UUID entityID = UUID.Parse(filePath.Remove(0, 9));
if (entitiesToSave.Contains(entityID))
{
writer.WriteFile(filePath, data);
entitiesToSave.Remove(entityID);
}
}
data = null;
}
}
catch (Exception ex)
{
MainConsole.Instance.WarnFormat("[Backup]: Exception caught: {0}", ex);
}
if (entitiesToSave.Count > 0)
{
MainConsole.Instance.Fatal(entitiesToSave.Count +
" PRIMS WERE NOT GOING TO BE SAVED! FORCE SAVING NOW! ");
foreach (ISceneEntity entity in regiondata.Groups)
{
if (entitiesToSave.Contains(entity.UUID))
{
if (entity.IsAttachment ||
((entity.RootChild.Flags & PrimFlags.Temporary) == PrimFlags.Temporary) ||
((entity.RootChild.Flags & PrimFlags.TemporaryOnRez) == PrimFlags.TemporaryOnRez))
{
continue;
}
//Write all entities
byte[] xml = entity.ToBinaryXml2();
writer.WriteFile("entities/" + entity.UUID.ToString(), xml);
xml = null;
}
}
}
}
reader.Close();
writer.Close();
m_loadStream.Close();
m_saveStream.Close();
GC.Collect();
}
catch (Exception ex)
{
MainConsole.Instance.Warn("[ProtobufRegionLoader]: Failed to save backup: " + ex.ToString());
return(false);
}
return(true);
}