public void LoadRegionBackup (TarArchiveReader reader, IScene scene)
{
IUniverseBackupModule[] modules = scene.RequestModuleInterfaces<IUniverseBackupModule> ();
byte[] data;
string filePath;
TarArchiveReader.TarEntryType entryType;
foreach (IUniverseBackupModule module in modules)
module.BeginLoadModuleFromArchive (scene);
while ((data = reader.ReadEntry (out filePath, out entryType)) != null)
{
if (TarArchiveReader.TarEntryType.TYPE_DIRECTORY == entryType)
continue;
foreach (IUniverseBackupModule module in modules)
module.LoadModuleFromArchive (data, filePath, entryType, scene);
}
reader.Close ();
foreach (IUniverseBackupModule module in modules)
module.EndLoadModuleFromArchive (scene);
}
/// <summary>
/// Loads the estate settings from an archive.
/// </summary>
/// <param name="data">Data.</param>
/// <param name="filePath">File path.</param>
/// <param name="type">Type.</param>
/// <param name="scene">Scene.</param>
public void LoadModuleFromArchive(byte[] data, string filePath, TarArchiveReader.TarEntryType type, IScene scene)
{
if (filePath.StartsWith("estatesettings/"))
{
EstateSettings settings = new EstateSettings();
settings.FromOSD((OSDMap) OSDParser.DeserializeLLSDBinary(data));
scene.RegionInfo.EstateSettings = settings;
}
else if (filePath.StartsWith("regioninfo/"))
{
string m_merge =
MainConsole.Instance.Prompt(
"Should we load the region information from the archive (region name, region position, etc)?",
"false");
RegionInfo settings = new RegionInfo();
settings.UnpackRegionInfoData((OSDMap) OSDParser.DeserializeLLSDBinary(data));
if (m_merge == "false")
{
//Still load the region settings though
scene.RegionInfo.RegionSettings = settings.RegionSettings;
return;
}
settings.RegionSettings = scene.RegionInfo.RegionSettings;
settings.EstateSettings = scene.RegionInfo.EstateSettings;
scene.RegionInfo = settings;
}
}
/// <summary>
/// Execute the request
/// </summary>
/// <returns>
/// A list of the inventory nodes loaded. If folders were loaded then only the root folders are
/// returned
/// </returns>
public HashSet<InventoryNodeBase> Execute (bool loadAll)
{
if (m_loadStream == null)
return new HashSet<InventoryNodeBase> ();
string filePath = "ERROR";
int successfulAssetRestores = 0;
int failedAssetRestores = 0;
int successfulItemRestores = 0;
HashSet<InventoryNodeBase> loadedNodes = loadAll ? new HashSet<InventoryNodeBase> () : null;
try {
List<InventoryFolderBase> folderCandidates
= InventoryArchiveUtils.FindFolderByPath (m_inventoryService, m_userInfo.PrincipalID, m_invPath);
if (folderCandidates.Count == 0) {
// try and create requested folder
var rootFolder = m_inventoryService.GetRootFolder (m_userInfo.PrincipalID);
if (rootFolder == null) {
if (m_inventoryService.CreateUserInventory (m_userInfo.PrincipalID, true))
rootFolder = m_inventoryService.GetRootFolder (m_userInfo.PrincipalID);
else {
MainConsole.Instance.Error ("[Inventory Archiver]: Unable to create Inventory root folder");
return loadedNodes; // major bummer
}
}
InventoryFolderBase iarImportFolder = new InventoryFolderBase ();
iarImportFolder.ID = UUID.Random ();
iarImportFolder.Name = m_invPath; // the path
iarImportFolder.Owner = m_userInfo.PrincipalID; // owner
iarImportFolder.ParentID = rootFolder.ID; // the root folder
iarImportFolder.Type = (short)FolderType.None; // user defined folder
iarImportFolder.Version = 1; // initial version
m_inventoryService.AddFolder (iarImportFolder);
// ensure that it now exists...
folderCandidates = InventoryArchiveUtils.FindFolderByPath (m_inventoryService, m_userInfo.PrincipalID, m_invPath);
if (folderCandidates.Count == 0) {
MainConsole.Instance.ErrorFormat ("[Inventory Archiver]: Unable to create Inventory path {0}", m_invPath);
return loadedNodes;
}
}
// we have the base folder... do it...
InventoryFolderBase rootDestinationFolder = folderCandidates [0];
archive = new TarArchiveReader (m_loadStream);
// In order to load identically named folders, we need to keep track of the folders that we have already
// resolved
Dictionary<string, InventoryFolderBase> resolvedFolders = new Dictionary<string, InventoryFolderBase> ();
MainConsole.Instance.Info ("[Archiver]: Commencing load from archive");
int ticker = 0;
byte [] data;
TarArchiveReader.TarEntryType entryType;
while ((data = archive.ReadEntry (out filePath, out entryType)) != null) {
if (TarArchiveReader.TarEntryType.TYPE_NORMAL_FILE == entryType) {
string fName;
try {
fName = Path.GetFileName (filePath);
if (fName.StartsWith (".", StringComparison.Ordinal)) // ignore hidden files
continue;
} catch {
MainConsole.Instance.ErrorFormat ("[Archiver]: Invalid file name in archive: {0}", filePath);
continue;
}
}
ticker++;
if (ticker % 5 == 0)
MainConsole.Instance.Ticker ();
if (filePath.StartsWith (ArchiveConstants.ASSETS_PATH, StringComparison.Ordinal)) {
if (LoadAsset (filePath, data))
successfulAssetRestores++;
else
failedAssetRestores++;
if ((successfulAssetRestores) % 50 == 0)
MainConsole.Instance.Ticker(
string.Format (" [Inventory Archiver]: Loaded {0} assets...", successfulAssetRestores),true);
} else if (filePath.StartsWith (ArchiveConstants.INVENTORY_PATH, StringComparison.Ordinal)) {
filePath = filePath.Substring (ArchiveConstants.INVENTORY_PATH.Length);
// Trim off the file portion if we aren't already dealing with a directory path
if (TarArchiveReader.TarEntryType.TYPE_DIRECTORY != entryType)
filePath = filePath.Remove (filePath.LastIndexOf ("/", StringComparison.Ordinal) + 1);
InventoryFolderBase foundFolder
= ReplicateArchivePathToUserInventory (
filePath, rootDestinationFolder, ref resolvedFolders, ref loadedNodes);
if (TarArchiveReader.TarEntryType.TYPE_DIRECTORY != entryType) {
InventoryItemBase item = LoadItem (data, foundFolder);
if (item != null) {
successfulItemRestores++;
if ((successfulItemRestores) % 50 == 0)
MainConsole.Instance.Ticker(
string.Format("[Inventory Archiver]: Restored {0} items...", successfulItemRestores),
true);
// If we aren't loading the folder containing the item then well need to update the
// viewer separately for that item.
if (loadAll && !loadedNodes.Contains (foundFolder))
loadedNodes.Add (item);
}
item = null;
}
} else if (filePath == ArchiveConstants.CONTROL_FILE_PATH) {
LoadControlFile (data);
}
data = null;
}
MainConsole.Instance.CleanInfo ("");
MainConsole.Instance.Info ("[Inventory Archiver]: Saving loaded inventory items");
ticker = 0;
int successfulItemLoaded = 0;
foreach (InventoryItemBase item in itemsSavedOff) {
ticker++;
if (ticker % 5 == 0)
MainConsole.Instance.Ticker ();
AddInventoryItem (item);
successfulItemLoaded++;
if ((successfulItemLoaded) % 50 == 0)
MainConsole.Instance.Ticker(
string.Format ("[Inventory Archiver]: Restored {0} items of {1}...",
successfulItemLoaded, itemsSavedOff.Count),
true) ;
}
itemsSavedOff.Clear ();
assets2Save.Clear ();
MainConsole.Instance.CleanInfo ("");
MainConsole.Instance.InfoFormat (
"[Inventory Archiver]: Successfully loaded {0} assets with {1} failures",
successfulAssetRestores, failedAssetRestores);
MainConsole.Instance.InfoFormat ("[Inventory Archiver]: Successfully loaded {0} items",
successfulItemRestores);
} finally {
m_loadStream.Close ();
}
return loadedNodes;
}
public RegionData LoadBackup(string file)
{
if (!File.Exists(file))
return null;
var stream = ArchiveHelpers.GetStream(file);
if (stream == null)
return null;
MainConsole.Instance.Warn("[TarRegionDataLoader]: loading region data: " + file);
GZipStream m_loadStream = new GZipStream(stream, CompressionMode.Decompress);
TarArchiveReader reader = new TarArchiveReader(m_loadStream);
List<uint> foundLocalIDs = new List<uint>();
RegionData regiondata = new RegionData();
regiondata.Init();
byte[] data;
string filePath;
TarArchiveReader.TarEntryType entryType;
System.Collections.Concurrent.ConcurrentQueue<byte[]> groups =
new System.Collections.Concurrent.ConcurrentQueue<byte[]>();
//Load the archive data that we need
while ((data = reader.ReadEntry(out filePath, out entryType)) != null)
{
MainConsole.Instance.Warn(".");
if (TarArchiveReader.TarEntryType.TYPE_DIRECTORY == entryType)
continue;
if (filePath.StartsWith("parcels/"))
{
//Only use if we are not merging
LandData parcel = new LandData();
OSD parcelData = OSDParser.DeserializeLLSDBinary(data);
parcel.FromOSD((OSDMap) parcelData);
if (parcel.OwnerID != UUID.Parse("05948863-b678-433e-87a4-e44d17678d1d"))
//The default owner of the 'default' region
regiondata.Parcels.Add(parcel);
}
else if (filePath.StartsWith("newstyleterrain/"))
{
regiondata.Terrain = data;
}
else if (filePath.StartsWith("newstylerevertterrain/"))
{
regiondata.RevertTerrain = data;
}
else if (filePath.StartsWith("newstylewater/"))
{
regiondata.Water = data;
}
else if (filePath.StartsWith("newstylerevertwater/"))
{
regiondata.RevertWater = data;
}
else if (filePath.StartsWith("entities/"))
{
groups.Enqueue(data);
}
else if (filePath.StartsWith("regioninfo/"))
{
RegionInfo info = new RegionInfo();
info.FromOSD((OSDMap) OSDParser.DeserializeLLSDBinary(data));
regiondata.RegionInfo = info;
}
data = null;
}
m_loadStream.Close();
m_loadStream = null;
int threadCount = groups.Count > 16 ? 16 : groups.Count;
System.Threading.Thread[] threads = new System.Threading.Thread[threadCount];
for (int i = 0; i < threadCount; i++)
{
threads[i] = new System.Threading.Thread(() =>
{
byte[] groupData;
while (groups.TryDequeue(out groupData))
{
MemoryStream ms = new MemoryStream(groupData);
ISceneEntity sceneObject =
SceneEntitySerializer.SceneObjectSerializer
.FromXml2Format(ref ms,
null);
ms.Close();
ms = null;
data = null;
if (sceneObject != null)
{
foreach (
ISceneChildEntity part in
sceneObject.ChildrenEntities())
{
lock (foundLocalIDs)
{
if (
!foundLocalIDs.Contains(
part.LocalId))
foundLocalIDs.Add(part.LocalId);
else
part.LocalId = 0;
//Reset it! Only use it once!
}
}
regiondata.Groups.Add(
sceneObject as SceneObjectGroup);
}
}
});
threads[i].Start();
}
for (int i = 0; i < threadCount; i++)
threads[i].Join();
foundLocalIDs.Clear();
MainConsole.Instance.Warn("[TarRegionDataLoader]: completed: ");
return regiondata;
}
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("[TarRegionDataLoader]: Failed to save backup: " + ex.ToString());
return false;
}
return true;
}
bool DearchiveRegion0DotStar()
{
if (m_loadStream == null)
return false;
int successfulAssetRestores = 0;
int failedAssetRestores = 0;
string filePath = "NONE";
DateTime start = DateTime.Now;
TarArchiveReader archive = new TarArchiveReader(m_loadStream);
if (!m_skipAssets)
m_threadpool = new UniverseThreadPool(new UniverseThreadPoolStartInfo()
{
Threads = 1,
priority =
System.Threading.ThreadPriority
.BelowNormal
});
IBackupModule backup = m_scene.RequestModuleInterface<IBackupModule>();
if (!m_merge)
{
DateTime before = DateTime.Now;
MainConsole.Instance.Info("[ARCHIVER]: Clearing all existing scene objects");
if (backup != null)
backup.DeleteAllSceneObjects();
MainConsole.Instance.Info("[ARCHIVER]: Cleared all existing scene objects in " +
(DateTime.Now - before).Minutes + ":" + (DateTime.Now - before).Seconds);
}
IScriptModule[] modules = m_scene.RequestModuleInterfaces<IScriptModule>();
//Disable the script engine so that it doesn't load in the background and kill OAR loading
foreach (IScriptModule module in modules)
{
module.Disabled = true;
}
//Disable backup for now as well
if (backup != null)
backup.LoadingPrims = true;
IRegionSerialiserModule serialiser = m_scene.RequestModuleInterface<IRegionSerialiserModule>();
int sceneObjectsLoadedCount = 0;
//We save the groups so that we can back them up later
List<ISceneEntity> groupsToBackup = new List<ISceneEntity>();
List<LandData> landData = new List<LandData>();
// must save off some stuff until after assets have been saved and recieved new uuids
// keeping these collection local because I am sure they will get large and garbage collection is better that way
List<byte[]> seneObjectGroups = new List<byte[]>();
Dictionary<UUID, UUID> assetBinaryChangeRecord = new Dictionary<UUID, UUID>();
Queue<UUID> assets2Save = new Queue<UUID>();
MainConsole.Instance.Info("[ARCHIVER]: Commencing load from archive");
int ticker = 0;
try
{
byte[] data;
TarArchiveReader.TarEntryType entryType;
while ((data = archive.ReadEntry(out filePath, out entryType)) != null)
{
if (TarArchiveReader.TarEntryType.TYPE_DIRECTORY == entryType)
continue;
if (TarArchiveReader.TarEntryType.TYPE_NORMAL_FILE == entryType)
{
var fName = Path.GetFileName (filePath);
if (fName.StartsWith (".")) // ignore hidden files
continue;
}
ticker ++;
if (ticker % 10 == 0)
MainConsole.Instance.Ticker();
if (filePath.StartsWith(ArchiveConstants.OBJECTS_PATH))
{
seneObjectGroups.Add(data);
if (seneObjectGroups.Count % 100 == 0)
MainConsole.Instance.InfoFormat("[ARCHIVER]: Found {0} scene object groups...",seneObjectGroups.Count);
}
else if (!m_skipAssets && filePath.StartsWith(ArchiveConstants.ASSETS_PATH))
{
AssetBase asset;
if (LoadAsset(filePath, data, out asset))
{
successfulAssetRestores++;
if (m_useAsync)
lock (AssetsToAdd) AssetsToAdd.Add(asset);
else
{
if (asset.IsBinaryAsset)
{
UUID aid = asset.ID;
asset.ID = m_scene.AssetService.Store(asset);
if (asset.ID != aid && asset.ID != UUID.Zero)
assetBinaryChangeRecord.Add(aid, asset.ID);
}
else
{
if (!assetNonBinaryCollection.ContainsKey(asset.ID))
{
assetNonBinaryCollection.Add(asset.ID, asset);
// I need something I can safely loop through
assets2Save.Enqueue(asset.ID);
}
}
}
}
else
failedAssetRestores++;
if ((successfulAssetRestores + failedAssetRestores)%100 == 0)
MainConsole.Instance.Info("[ARCHIVER]: Loaded " + successfulAssetRestores +
" assets and failed to load " + failedAssetRestores + " assets...");
}
else if (!m_skipTerrain && filePath.StartsWith(ArchiveConstants.TERRAINS_PATH))
{
LoadTerrain(filePath, data);
}
else if (!m_merge && filePath.StartsWith(ArchiveConstants.SETTINGS_PATH))
{
LoadRegionSettings(filePath, data);
}
else if (!m_skipTerrain && filePath.StartsWith(ArchiveConstants.LANDDATA_PATH))
{
var parcel = LoadLandData(data);
landData.Add(parcel);
}
else if (filePath == ArchiveConstants.CONTROL_FILE_PATH)
{
LoadControlFile(data);
}
}
MainConsole.Instance.CleanInfo("");
MainConsole.Instance.Info("[ARCHIVER]: Saving loaded assets");
ticker = 0;
// Save Assets
int savingAssetsCount = 0;
while (assets2Save.Count > 0)
{
ticker++;
if (ticker % 10 == 0)
MainConsole.Instance.Ticker();
try
{
UUID assetid = assets2Save.Dequeue();
SaveNonBinaryAssets(assetid, assetNonBinaryCollection[assetid], assetBinaryChangeRecord);
savingAssetsCount++;
if ((savingAssetsCount)%100 == 0)
MainConsole.Instance.Info("[ARCHIVER]: Saving " + savingAssetsCount + " assets...");
}
catch (Exception ex)
{
MainConsole.Instance.Info("[ARCHIVER]: Exception in saving an asset: " + ex.ToString());
}
}
MainConsole.Instance.CleanInfo("");
MainConsole.Instance.Info("[ARCHIVER]: Saving loaded objects");
ticker = 0;
foreach (byte[] data2 in seneObjectGroups)
{
ticker++;
if (ticker % 10 == 0)
MainConsole.Instance.Ticker();
byte[] data3 = data2;
string stringData = Utils.BytesToString(data3);
MatchCollection mc = Regex.Matches(stringData, sPattern);
bool didChange = false;
if (mc.Count >= 1)
{
foreach (Match match in mc)
{
UUID thematch = new UUID(match.Value);
UUID newvalue = thematch;
if (assetNonBinaryCollection.ContainsKey(thematch))
newvalue = assetNonBinaryCollection[thematch].ID;
else if (assetBinaryChangeRecord.ContainsKey(thematch))
newvalue = assetBinaryChangeRecord[thematch];
if (thematch == newvalue) continue;
stringData = stringData.Replace(thematch.ToString().Trim(), newvalue.ToString().Trim());
didChange = true;
}
}
if (didChange)
data3 = Utils.StringToBytes(stringData);
ISceneEntity sceneObject = serialiser.DeserializeGroupFromXml2(data3, m_scene);
if (sceneObject == null)
{
//! big error!
MainConsole.Instance.Error("Error reading SOP XML (Please mantis this!): " +
m_asciiEncoding.GetString(data3));
continue;
}
// check sceneObject ownership
sceneObject.OwnerID = ResolveUserUuid(sceneObject.OwnerID, sceneObject.LastSignificantPosition, landData);
//... and children
foreach (ISceneChildEntity part in sceneObject.ChildrenEntities())
{
// check user ID's
part.CreatorID = ResolveUserUuid(part.CreatorID, part.AbsolutePosition, landData);
part.OwnerID = ResolveUserUuid(part.OwnerID, part.AbsolutePosition, landData);
part.LastOwnerID = ResolveUserUuid(part.LastOwnerID, part.AbsolutePosition, landData);
//check group ID's
part.GroupID = ResolveGroupUuid(part.GroupID);
// And zap any troublesome sit target information
part.SitTargetOrientation = new Quaternion(0, 0, 0, 1);
part.SitTargetPosition = new Vector3(0, 0, 0);
// Fix ownership/creator of inventory items
// Not doing so results in inventory items
// being no copy/no mod for everyone
lock (part.TaskInventory)
{
TaskInventoryDictionary inv = part.TaskInventory;
foreach (KeyValuePair<UUID, TaskInventoryItem> kvp in inv)
{
// check user ID's
kvp.Value.OwnerID = ResolveUserUuid(
kvp.Value.OwnerID,
part.AbsolutePosition,
landData
);
kvp.Value.LastOwnerID = ResolveUserUuid(
kvp.Value.LastOwnerID,
part.AbsolutePosition,
landData
);
kvp.Value.CreatorID = ResolveUserUuid(
kvp.Value.CreatorID,
part.AbsolutePosition,
landData
);
// ..and possible group ID's
kvp.Value.GroupID = ResolveGroupUuid(kvp.Value.GroupID);
}
}
}
//Add the offsets of the region
Vector3 newPos = new Vector3(sceneObject.AbsolutePosition.X + m_offsetX,
sceneObject.AbsolutePosition.Y + m_offsetY,
sceneObject.AbsolutePosition.Z + m_offsetZ);
if (m_flipX)
newPos.X = m_scene.RegionInfo.RegionSizeX - newPos.X;
if (m_flipY)
newPos.Y = m_scene.RegionInfo.RegionSizeY - newPos.Y;
sceneObject.SetAbsolutePosition(false, newPos);
if (m_scene.SceneGraph.AddPrimToScene(sceneObject))
{
groupsToBackup.Add(sceneObject);
sceneObject.ScheduleGroupUpdate(PrimUpdateFlags.ForcedFullUpdate);
sceneObject.CreateScriptInstances(0, false, StateSource.RegionStart, UUID.Zero, true);
}
sceneObjectsLoadedCount++;
if (sceneObjectsLoadedCount%100 == 0)
MainConsole.Instance.Info("[ARCHIVER]: Loaded " + sceneObjectsLoadedCount + " objects...");
}
assetNonBinaryCollection.Clear();
assetBinaryChangeRecord.Clear();
seneObjectGroups.Clear();
}
catch (Exception e)
{
MainConsole.Instance.ErrorFormat(
"[ARCHIVER]: Aborting load with error in archive file {0}. {1}", filePath, e);
m_errorMessage += e.ToString();
m_scene.EventManager.TriggerOarFileLoaded(UUID.Zero.Guid, m_errorMessage);
return false;
}
finally
{
archive.Close();
m_loadStream.Close();
m_loadStream.Dispose();
//Re-enable scripts now that we are done
foreach (IScriptModule module in modules)
{
module.Disabled = false;
}
//Reset backup too
if (backup != null)
backup.LoadingPrims = false;
}
// finished with the ticker
MainConsole.Instance.CleanInfo("");
//Now back up the prims
foreach (ISceneEntity grp in groupsToBackup)
{
//Backup!
grp.HasGroupChanged = true;
}
if (!m_skipAssets && m_useAsync && !AssetSaverIsRunning)
m_threadpool.QueueEvent(SaveAssets, 0);
if (!m_skipAssets)
{
MainConsole.Instance.InfoFormat("[ARCHIVER]: Restored {0} assets", successfulAssetRestores);
if (failedAssetRestores > 0)
{
MainConsole.Instance.ErrorFormat("[ARCHIVER]: Failed to load {0} assets", failedAssetRestores);
m_errorMessage += String.Format("Failed to load {0} assets", failedAssetRestores);
}
}
// Reload serialized parcels
if (!m_skipTerrain)
{
MainConsole.Instance.InfoFormat ("[ARCHIVER]: Loading {0} parcels. Please wait.", landData.Count);
IParcelManagementModule parcelManagementModule = m_scene.RequestModuleInterface<IParcelManagementModule> ();
if (parcelManagementModule != null)
parcelManagementModule.IncomingLandDataFromOAR (landData, m_merge, new Vector2 (m_offsetX, m_offsetY));
MainConsole.Instance.InfoFormat ("[ARCHIVER]: Restored {0} parcels.", landData.Count);
}
//Clean it out
landData.Clear();
MainConsole.Instance.InfoFormat("[ARCHIVER]: Successfully loaded archive in " +
(DateTime.Now - start).Minutes + ":" + (DateTime.Now - start).Seconds);
m_validUserUuids.Clear();
m_validGroupUuids.Clear();
m_scene.EventManager.TriggerOarFileLoaded(UUID.Zero.Guid, m_errorMessage);
return true; // all good
}
void LoadUniverseArchive (IScene scene, string[] cmd)
{
string fileName = MainConsole.Instance.Prompt ("What file name should we load?", scene.RegionInfo.RegionName + ".abackup");
// a couple of sanity checks
string extension = Path.GetExtension (fileName);
if (extension == string.Empty)
{
fileName = fileName + ".abackup";
}
if (!File.Exists (fileName))
{
MainConsole.Instance.Info ("[Archiver]: Region archive file '" + fileName + "' not found.");
return;
}
var stream = ArchiveHelpers.GetStream (fileName);
if (stream == null)
{
MainConsole.Instance.Warn ("No file found with the specified name.");
return;
}
GZipStream m_loadStream = new GZipStream (stream, CompressionMode.Decompress);
TarArchiveReader reader = new TarArchiveReader (m_loadStream);
LoadRegionBackup (reader, scene);
GC.Collect ();
}
public void LoadModuleFromArchive(byte[] data, string filePath, TarArchiveReader.TarEntryType type,
IScene scene)
{
if (filePath.StartsWith("parcels/"))
{
if (!m_merge)
{
//Only use if we are not merging
LandData parcel = new LandData();
OSD parcelData = OSDParser.DeserializeLLSDBinary(data);
parcel.FromOSD((OSDMap) parcelData);
m_parcels.Add(parcel);
}
}
#region New Style Terrain Loading
else if (filePath.StartsWith("newstyleterrain/"))
{
ITerrainModule terrainModule = scene.RequestModuleInterface<ITerrainModule>();
terrainModule.TerrainMap = ReadTerrain(data, scene);
}
else if (filePath.StartsWith("newstylerevertterrain/"))
{
ITerrainModule terrainModule = scene.RequestModuleInterface<ITerrainModule>();
terrainModule.TerrainRevertMap = ReadTerrain(data, scene);
}
else if (filePath.StartsWith("newstylewater/"))
{
ITerrainModule terrainModule = scene.RequestModuleInterface<ITerrainModule>();
terrainModule.TerrainWaterMap = ReadTerrain(data, scene);
}
else if (filePath.StartsWith("newstylerevertwater/"))
{
ITerrainModule terrainModule = scene.RequestModuleInterface<ITerrainModule>();
terrainModule.TerrainWaterRevertMap = ReadTerrain(data, scene);
}
#endregion
#region Old Style Terrain Loading
else if (filePath.StartsWith("terrain/"))
{
ITerrainModule terrainModule = scene.RequestModuleInterface<ITerrainModule>();
MemoryStream ms = new MemoryStream(data);
terrainModule.LoadFromStream(filePath, ms, 0, 0);
ms.Close();
}
else if (filePath.StartsWith("revertterrain/"))
{
ITerrainModule terrainModule = scene.RequestModuleInterface<ITerrainModule>();
MemoryStream ms = new MemoryStream(data);
terrainModule.LoadRevertMapFromStream(filePath, ms, 0, 0);
ms.Close();
}
else if (filePath.StartsWith("water/"))
{
ITerrainModule terrainModule = scene.RequestModuleInterface<ITerrainModule>();
MemoryStream ms = new MemoryStream(data);
terrainModule.LoadWaterFromStream(filePath, ms, 0, 0);
ms.Close();
}
else if (filePath.StartsWith("revertwater/"))
{
ITerrainModule terrainModule = scene.RequestModuleInterface<ITerrainModule>();
MemoryStream ms = new MemoryStream(data);
terrainModule.LoadWaterRevertMapFromStream(filePath, ms, 0, 0);
ms.Close();
}
#endregion
else if (filePath.StartsWith("entities/"))
{
MemoryStream ms = new MemoryStream(data);
ISceneEntity sceneObject = SceneEntitySerializer.SceneObjectSerializer.FromXml2Format(ref ms, scene);
ms.Close();
m_groups.Add(sceneObject);
}
else if (filePath.StartsWith("assets/"))
{
if (m_loadAssets)
{
AssetBase asset = new AssetBase();
asset.Unpack(OSDParser.DeserializeJson(Encoding.UTF8.GetString(data)));
scene.AssetService.Store(asset);
}
}
}