6 files changed, 406 insertions, 169 deletions

diff --git a/OpenSim/Region/CoreModules/World/Archiver/ArchiveReadRequest.cs b/OpenSim/Region/CoreModules/World/Archiver/ArchiveReadRequest.cs
index c810242..9c6706f 100644
--- a/OpenSim/Region/CoreModules/World/Archiver/ArchiveReadRequest.cs
+++ b/OpenSim/Region/CoreModules/World/Archiver/ArchiveReadRequest.cs
@@ -36,6 +36,7 @@ using System.Xml;
 using log4net;
 using OpenMetaverse;
 using OpenSim.Framework;
+using OpenSim.Framework.Monitoring;
 using OpenSim.Framework.Serialization;
 using OpenSim.Framework.Serialization.External;
 using OpenSim.Region.CoreModules.World.Terrain;
@@ -96,14 +97,42 @@ namespace OpenSim.Region.CoreModules.World.Archiver
 
         /// <value>
         /// Should the archive being loaded be merged with what is already on the region?
+        /// Merging usually suppresses terrain and parcel loading
         /// </value>
         protected bool m_merge;
 
         /// <value>
+        /// If true, force the loading of terrain from the oar file
+        /// </value>
+        protected bool m_forceTerrain;
+
+        /// <value>
+        /// If true, force the loading of parcels from the oar file
+        /// </value>
+        protected bool m_forceParcels;
+
+        /// <value>
         /// Should we ignore any assets when reloading the archive?
         /// </value>
         protected bool m_skipAssets;
 
+        /// <value>
+        /// Displacement added to each object as it is added to the world
+        /// </value>
+        protected Vector3 m_displacement = Vector3.Zero;
+
+        /// <value>
+        /// Rotation (in radians) to apply to the objects as they are loaded.
+        /// </value>
+        protected float m_rotation = 0f;
+
+        /// <value>
+        /// Center around which to apply the rotation relative to the origional oar position
+        /// </value>
+        protected Vector3 m_rotationCenter = new Vector3(Constants.RegionSize / 2f, Constants.RegionSize / 2f, 0f);
+
+        protected bool m_noObjects = false;
+
         /// <summary>
         /// Used to cache lookups for valid uuids.
         /// </summary>
@@ -132,10 +161,22 @@ namespace OpenSim.Region.CoreModules.World.Archiver
         private IAssetService m_assetService = null;
 
 
-        public ArchiveReadRequest(Scene scene, string loadPath, bool merge, bool skipAssets, Guid requestId)
+        private UUID m_defaultUser;
+
+        public ArchiveReadRequest(Scene scene, string loadPath, Guid requestId, Dictionary<string,object>options)
         {
             m_rootScene = scene;
 
+            if (options.ContainsKey("default-user"))
+            {
+                m_defaultUser = (UUID)options["default-user"];
+                m_log.InfoFormat("Using User {0} as default user", m_defaultUser.ToString());
+            }
+            else 
+            {
+                m_defaultUser = scene.RegionInfo.EstateSettings.EstateOwner;
+            }
+
             m_loadPath = loadPath;
             try
             {
@@ -150,26 +191,36 @@ namespace OpenSim.Region.CoreModules.World.Archiver
             }
         
             m_errorMessage = String.Empty;
-            m_merge = merge;
-            m_skipAssets = skipAssets;
+            m_merge = options.ContainsKey("merge");
+            m_forceTerrain = options.ContainsKey("force-terrain");
+            m_forceParcels = options.ContainsKey("force-parcels");
+            m_noObjects = options.ContainsKey("no-objects");
+            m_skipAssets = options.ContainsKey("skipAssets");
             m_requestId = requestId;
+            m_displacement = options.ContainsKey("displacement") ? (Vector3)options["displacement"] : Vector3.Zero;
+            m_rotation = options.ContainsKey("rotation") ? (float)options["rotation"] : 0f;
+            m_rotationCenter = options.ContainsKey("rotation-center") ? (Vector3)options["rotation-center"] 
+                                : new Vector3(scene.RegionInfo.RegionSizeX / 2f, scene.RegionInfo.RegionSizeY / 2f, 0f);
 
-            // Zero can never be a valid user id
+            // Zero can never be a valid user or group id
             m_validUserUuids[UUID.Zero] = false;
+            m_validGroupUuids[UUID.Zero] = false;
 
             m_groupsModule = m_rootScene.RequestModuleInterface<IGroupsModule>();
             m_assetService = m_rootScene.AssetService;
         }
 
-        public ArchiveReadRequest(Scene scene, Stream loadStream, bool merge, bool skipAssets, Guid requestId)
+        public ArchiveReadRequest(Scene scene, Stream loadStream, Guid requestId, Dictionary<string, object>options)
         {
             m_rootScene = scene;
             m_loadPath = null;
             m_loadStream = loadStream;
-            m_merge = merge;
-            m_skipAssets = skipAssets;
+            m_skipAssets = options.ContainsKey("skipAssets");
+            m_merge = options.ContainsKey("merge");
             m_requestId = requestId;
 
+            m_defaultUser = scene.RegionInfo.EstateSettings.EstateOwner;
+     
             // Zero can never be a valid user id
             m_validUserUuids[UUID.Zero] = false;
 
@@ -229,7 +280,7 @@ namespace OpenSim.Region.CoreModules.World.Archiver
 
                     // Process the file
 
-                    if (filePath.StartsWith(ArchiveConstants.OBJECTS_PATH))
+                    if (filePath.StartsWith(ArchiveConstants.OBJECTS_PATH) && !m_noObjects)
                     {
                         sceneContext.SerialisedSceneObjects.Add(Encoding.UTF8.GetString(data));
                     }
@@ -243,7 +294,7 @@ namespace OpenSim.Region.CoreModules.World.Archiver
                         if ((successfulAssetRestores + failedAssetRestores) % 250 == 0)
                             m_log.Debug("[ARCHIVER]: Loaded " + successfulAssetRestores + " assets and failed to load " + failedAssetRestores + " assets...");
                     }
-                    else if (!m_merge && filePath.StartsWith(ArchiveConstants.TERRAINS_PATH))
+                    else if (filePath.StartsWith(ArchiveConstants.TERRAINS_PATH) && (!m_merge || m_forceTerrain))
                     {
                         LoadTerrain(scene, filePath, data);
                     }
@@ -251,7 +302,7 @@ namespace OpenSim.Region.CoreModules.World.Archiver
                     {
                         LoadRegionSettings(scene, filePath, data, dearchivedScenes);
                     } 
-                    else if (!m_merge && filePath.StartsWith(ArchiveConstants.LANDDATA_PATH))
+                    else if (filePath.StartsWith(ArchiveConstants.LANDDATA_PATH) && (!m_merge || m_forceParcels))
                     {
                         sceneContext.SerialisedParcels.Add(Encoding.UTF8.GetString(data));
                     } 
@@ -321,7 +372,7 @@ namespace OpenSim.Region.CoreModules.World.Archiver
             // Start the scripts. We delayed this because we want the OAR to finish loading ASAP, so
             // that users can enter the scene. If we allow the scripts to start in the loop above
             // then they significantly increase the time until the OAR finishes loading.
-            Util.FireAndForget(delegate(object o)
+            WorkManager.RunInThread(o =>
             {
                 Thread.Sleep(15000);
                 m_log.Info("[ARCHIVER]: Starting scripts in scene objects");
@@ -336,7 +387,7 @@ namespace OpenSim.Region.CoreModules.World.Archiver
 
                     sceneContext.SceneObjects.Clear();
                 }
-            });
+            }, null, string.Format("ReadArchiveStartScripts (request {0})", m_requestId));
 
             m_log.InfoFormat("[ARCHIVER]: Successfully loaded archive");
 
@@ -422,6 +473,8 @@ namespace OpenSim.Region.CoreModules.World.Archiver
             // Reload serialized prims
             m_log.InfoFormat("[ARCHIVER]: Loading {0} scene objects.  Please wait.", serialisedSceneObjects.Count);
 
+            OpenMetaverse.Quaternion rot = OpenMetaverse.Quaternion.CreateFromAxisAngle(0, 0, 1, m_rotation);
+
             UUID oldTelehubUUID = scene.RegionInfo.RegionSettings.TelehubObject;
 
             IRegionSerialiserModule serialiser = scene.RequestModuleInterface<IRegionSerialiserModule>();
@@ -445,6 +498,32 @@ namespace OpenSim.Region.CoreModules.World.Archiver
 
                 SceneObjectGroup sceneObject = serialiser.DeserializeGroupFromXml2(serialisedSceneObject);
 
+                // Happily this does not do much to the object since it hasn't been added to the scene yet
+                if (!sceneObject.IsAttachment)
+                {
+                    if (m_displacement != Vector3.Zero || m_rotation != 0f)
+                    {
+                        Vector3 pos = sceneObject.AbsolutePosition;
+                        if (m_rotation != 0f)
+                        {
+                            // Rotate the object
+                            sceneObject.RootPart.RotationOffset = rot * sceneObject.GroupRotation;
+                            // Get object position relative to rotation axis
+                            Vector3 offset = pos - m_rotationCenter;
+                            // Rotate the object position
+                            offset *= rot;
+                            // Restore the object position back to relative to the region
+                            pos = m_rotationCenter + offset;
+                        }
+                        if (m_displacement != Vector3.Zero)
+                        {
+                            pos += m_displacement;
+                        }
+                        sceneObject.AbsolutePosition = pos;
+                    }
+                }
+
+
                 bool isTelehub = (sceneObject.UUID == oldTelehubUUID) && (oldTelehubUUID != UUID.Zero);
 
                 // For now, give all incoming scene objects new uuids.  This will allow scenes to be cloned
@@ -460,58 +539,7 @@ namespace OpenSim.Region.CoreModules.World.Archiver
                     oldTelehubUUID = UUID.Zero;
                 }
 
-                // Try to retain the original creator/owner/lastowner if their uuid is present on this grid
-                // or creator data is present.  Otherwise, use the estate owner instead.
-                foreach (SceneObjectPart part in sceneObject.Parts)
-                {
-                    if (part.CreatorData == null || part.CreatorData == string.Empty)
-                    {
-                        if (!ResolveUserUuid(scene, part.CreatorID))
-                            part.CreatorID = scene.RegionInfo.EstateSettings.EstateOwner;
-                    }
-                    if (UserManager != null)
-                        UserManager.AddUser(part.CreatorID, part.CreatorData);
-
-                    if (!ResolveUserUuid(scene, part.OwnerID))
-                        part.OwnerID = scene.RegionInfo.EstateSettings.EstateOwner;
-
-                    if (!ResolveUserUuid(scene, part.LastOwnerID))
-                        part.LastOwnerID = scene.RegionInfo.EstateSettings.EstateOwner;
-
-                    if (!ResolveGroupUuid(part.GroupID))
-                        part.GroupID = UUID.Zero;
-
-                    // 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)
-                        {
-                            if (!ResolveUserUuid(scene, kvp.Value.OwnerID))
-                            {
-                                kvp.Value.OwnerID = scene.RegionInfo.EstateSettings.EstateOwner;
-                            }
-
-                            if (kvp.Value.CreatorData == null || kvp.Value.CreatorData == string.Empty)
-                            {
-                                if (!ResolveUserUuid(scene, kvp.Value.CreatorID))
-                                    kvp.Value.CreatorID = scene.RegionInfo.EstateSettings.EstateOwner;
-                            }
-
-                            if (UserManager != null)
-                                UserManager.AddUser(kvp.Value.CreatorID, kvp.Value.CreatorData);
-
-                            if (!ResolveGroupUuid(kvp.Value.GroupID))
-                                kvp.Value.GroupID = UUID.Zero;
-                        }
-                    }
-                }
+                ModifySceneObject(scene, sceneObject);
 
                 if (scene.AddRestoredSceneObject(sceneObject, true, false))
                 {
@@ -535,6 +563,67 @@ namespace OpenSim.Region.CoreModules.World.Archiver
                 scene.RegionInfo.RegionSettings.ClearSpawnPoints();
             }
         }
+
+        /// <summary>
+        /// Optionally modify a loaded SceneObjectGroup. Currently this just ensures that the
+        /// User IDs and Group IDs are valid, but other manipulations could be done as well.
+        /// </summary>
+        private void ModifySceneObject(Scene scene, SceneObjectGroup sceneObject)
+        {
+            // Try to retain the original creator/owner/lastowner if their uuid is present on this grid
+            // or creator data is present.  Otherwise, use the estate owner instead.
+            foreach (SceneObjectPart part in sceneObject.Parts)
+            {
+                if (string.IsNullOrEmpty(part.CreatorData))
+                {
+                    if (!ResolveUserUuid(scene, part.CreatorID))
+                        part.CreatorID = m_defaultUser;
+                }
+                if (UserManager != null)
+                    UserManager.AddUser(part.CreatorID, part.CreatorData);
+
+                if (!(ResolveUserUuid(scene, part.OwnerID) || ResolveGroupUuid(part.OwnerID)))
+                    part.OwnerID = m_defaultUser;
+
+                if (!(ResolveUserUuid(scene, part.LastOwnerID) || ResolveGroupUuid(part.LastOwnerID)))
+                    part.LastOwnerID = m_defaultUser;
+
+                if (!ResolveGroupUuid(part.GroupID))
+                    part.GroupID = UUID.Zero;
+
+                // 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)
+                    {
+                        if (!(ResolveUserUuid(scene, kvp.Value.OwnerID) || ResolveGroupUuid(kvp.Value.OwnerID)))
+                        {
+                            kvp.Value.OwnerID = m_defaultUser;
+                        }
+
+                        if (string.IsNullOrEmpty(kvp.Value.CreatorData))
+                        {
+                            if (!ResolveUserUuid(scene, kvp.Value.CreatorID))
+                                kvp.Value.CreatorID = m_defaultUser;
+                        }
+
+                        if (UserManager != null)
+                            UserManager.AddUser(kvp.Value.CreatorID, kvp.Value.CreatorData);
+
+                        if (!ResolveGroupUuid(kvp.Value.GroupID))
+                            kvp.Value.GroupID = UUID.Zero;
+                    }
+                }
+            }
+        }
+
         
         /// <summary>
         /// Load serialized parcels.
@@ -549,15 +638,29 @@ namespace OpenSim.Region.CoreModules.World.Archiver
             foreach (string serialisedParcel in serialisedParcels)
             {
                 LandData parcel = LandDataSerializer.Deserialize(serialisedParcel);
+
+                if (m_displacement != Vector3.Zero)
+                {
+                    Vector3 parcelDisp = new Vector3(m_displacement.X, m_displacement.Y, 0f);
+                    parcel.AABBMin += parcelDisp;
+                    parcel.AABBMax += parcelDisp;
+                }
                 
                 // Validate User and Group UUID's
 
+                if (!ResolveGroupUuid(parcel.GroupID))
+                    parcel.GroupID = UUID.Zero;
+
                 if (parcel.IsGroupOwned)
                 {
-                    if (!ResolveGroupUuid(parcel.GroupID))
+                    if (parcel.GroupID != UUID.Zero)
+                    {
+                        // In group-owned parcels, OwnerID=GroupID. This should already be the case, but let's make sure.
+                        parcel.OwnerID = parcel.GroupID;
+                    }
+                    else
                     {
                         parcel.OwnerID = m_rootScene.RegionInfo.EstateSettings.EstateOwner;
-                        parcel.GroupID = UUID.Zero;
                         parcel.IsGroupOwned = false;
                     }
                 }
@@ -565,9 +668,6 @@ namespace OpenSim.Region.CoreModules.World.Archiver
                 {
                     if (!ResolveUserUuid(scene, parcel.OwnerID))
                         parcel.OwnerID = m_rootScene.RegionInfo.EstateSettings.EstateOwner;
-
-                    if (!ResolveGroupUuid(parcel.GroupID))
-                        parcel.GroupID = UUID.Zero;
                 }
 
                 List<LandAccessEntry> accessList = new List<LandAccessEntry>();
@@ -604,13 +704,18 @@ namespace OpenSim.Region.CoreModules.World.Archiver
         /// <returns></returns>
         private bool ResolveUserUuid(Scene scene, UUID uuid)
         {
-            if (!m_validUserUuids.ContainsKey(uuid))
+            lock (m_validUserUuids)
             {
-                UserAccount account = scene.UserAccountService.GetUserAccount(scene.RegionInfo.ScopeID, uuid);
-                m_validUserUuids.Add(uuid, account != null);
-            }
+                if (!m_validUserUuids.ContainsKey(uuid))
+                {
+                    // Note: we call GetUserAccount() inside the lock because this UserID is likely
+                    // to occur many times, and we only want to query the users service once.
+                    UserAccount account = scene.UserAccountService.GetUserAccount(scene.RegionInfo.ScopeID, uuid);
+                    m_validUserUuids.Add(uuid, account != null);
+                }
 
-            return m_validUserUuids[uuid];
+                return m_validUserUuids[uuid];
+            }
         }
 
         /// <summary>
@@ -620,22 +725,26 @@ namespace OpenSim.Region.CoreModules.World.Archiver
         /// <returns></returns>
         private bool ResolveGroupUuid(UUID uuid)
         {
-            if (uuid == UUID.Zero)
-                return true;    // this means the object has no group
-
-            if (!m_validGroupUuids.ContainsKey(uuid))
+            lock (m_validGroupUuids)
             {
-                bool exists;
-                
-                if (m_groupsModule == null)
-                    exists = false;
-                else
-                    exists = (m_groupsModule.GetGroupRecord(uuid) != null);
+                if (!m_validGroupUuids.ContainsKey(uuid))
+                {
+                    bool exists;
+                    if (m_groupsModule == null)
+                    {
+                        exists = false;
+                    }
+                    else
+                    {
+                        // Note: we call GetGroupRecord() inside the lock because this GroupID is likely
+                        // to occur many times, and we only want to query the groups service once.
+                        exists = (m_groupsModule.GetGroupRecord(uuid) != null);
+                    }
+                    m_validGroupUuids.Add(uuid, exists);
+                }
 
-                m_validGroupUuids.Add(uuid, exists);
+                return m_validGroupUuids[uuid];
             }
-
-            return m_validGroupUuids[uuid];
         }
 
         /// Load an asset
@@ -672,7 +781,21 @@ namespace OpenSim.Region.CoreModules.World.Archiver
                 sbyte assetType = ArchiveConstants.EXTENSION_TO_ASSET_TYPE[extension];
 
                 if (assetType == (sbyte)AssetType.Unknown)
+                {
                     m_log.WarnFormat("[ARCHIVER]: Importing {0} byte asset {1} with unknown type", data.Length, uuid);
+                }
+                else if (assetType == (sbyte)AssetType.Object)
+                {
+                    data = SceneObjectSerializer.ModifySerializedObject(UUID.Parse(uuid), data,
+                        sog =>
+                        {
+                            ModifySceneObject(m_rootScene, sog);
+                            return true;
+                        });
+                    
+                    if (data == null)
+                        return false;
+                }
 
                 //m_log.DebugFormat("[ARCHIVER]: Importing asset {0}, type {1}", uuid, assetType);
 
@@ -796,9 +919,18 @@ namespace OpenSim.Region.CoreModules.World.Archiver
         {
             ITerrainModule terrainModule = scene.RequestModuleInterface<ITerrainModule>();
 
-            MemoryStream ms = new MemoryStream(data);
-            terrainModule.LoadFromStream(terrainPath, ms);
-            ms.Close();
+            using (MemoryStream ms = new MemoryStream(data))
+            {
+                if (m_displacement != Vector3.Zero || m_rotation != 0f)
+                {
+                    Vector2 rotationCenter = new Vector2(m_rotationCenter.X, m_rotationCenter.Y);
+                    terrainModule.LoadFromStream(terrainPath, m_displacement, m_rotation, rotationCenter, ms);
+                }
+                else
+                {
+                    terrainModule.LoadFromStream(terrainPath, ms);
+                }
+            }
 
             m_log.DebugFormat("[ARCHIVER]: Restored terrain {0}", terrainPath);
 
@@ -887,4 +1019,4 @@ namespace OpenSim.Region.CoreModules.World.Archiver
             return dearchivedScenes;
         }
     }
-}
\ No newline at end of file
+}
diff --git a/OpenSim/Region/CoreModules/World/Archiver/ArchiveWriteRequest.cs b/OpenSim/Region/CoreModules/World/Archiver/ArchiveWriteRequest.cs
index 7bdd65c..cb2c7f1 100644
--- a/OpenSim/Region/CoreModules/World/Archiver/ArchiveWriteRequest.cs
+++ b/OpenSim/Region/CoreModules/World/Archiver/ArchiveWriteRequest.cs
@@ -36,6 +36,7 @@ using System.Xml;
 using log4net;
 using OpenMetaverse;
 using OpenSim.Framework;
+using OpenSim.Framework.Monitoring;
 using OpenSim.Framework.Serialization;
 using OpenSim.Region.CoreModules.World.Terrain;
 using OpenSim.Region.Framework.Interfaces;
@@ -43,7 +44,9 @@ using OpenSim.Region.Framework.Scenes;
 using Ionic.Zlib;
 using GZipStream = Ionic.Zlib.GZipStream;
 using CompressionMode = Ionic.Zlib.CompressionMode;
+using CompressionLevel = Ionic.Zlib.CompressionLevel;
 using OpenSim.Framework.Serialization.External;
+using PermissionMask = OpenSim.Framework.PermissionMask;
 
 namespace OpenSim.Region.CoreModules.World.Archiver
 {
@@ -78,7 +81,7 @@ namespace OpenSim.Region.CoreModules.World.Archiver
         /// Determines which objects will be included in the archive, according to their permissions.
         /// Default is null, meaning no permission checks.
         /// </summary>
-        public string CheckPermissions { get; set; }
+        public string FilterContent { get; set; }
 
         protected Scene m_rootScene;
         protected Stream m_saveStream;
@@ -129,7 +132,7 @@ namespace OpenSim.Region.CoreModules.World.Archiver
 
             MultiRegionFormat = false;
             SaveAssets = true;
-            CheckPermissions = null;
+            FilterContent = null;
         }
 
         /// <summary>
@@ -148,7 +151,7 @@ namespace OpenSim.Region.CoreModules.World.Archiver
 
             Object temp;
             if (options.TryGetValue("checkPermissions", out temp))
-                CheckPermissions = (string)temp;
+                FilterContent = (string)temp;
 
 
             // Find the regions to archive
@@ -177,7 +180,7 @@ namespace OpenSim.Region.CoreModules.World.Archiver
 
                 // Archive the regions
 
-                Dictionary<UUID, AssetType> assetUuids = new Dictionary<UUID, AssetType>();
+                Dictionary<UUID, sbyte> assetUuids = new Dictionary<UUID, sbyte>();
 
                 scenesGroup.ForEachScene(delegate(Scene scene)
                 {
@@ -198,7 +201,7 @@ namespace OpenSim.Region.CoreModules.World.Archiver
                             m_rootScene.AssetService, m_rootScene.UserAccountService,
                             m_rootScene.RegionInfo.ScopeID, options, ReceivedAllAssets);
 
-                    Util.FireAndForget(o => ar.Execute());
+                    WorkManager.RunInThread(o => ar.Execute(), null, "Archive Assets Request");
 
                     // CloseArchive() will be called from ReceivedAllAssets()
                 }
@@ -215,9 +218,9 @@ namespace OpenSim.Region.CoreModules.World.Archiver
             }
         }
 
-        private void ArchiveOneRegion(Scene scene, string regionDir, Dictionary<UUID, AssetType> assetUuids)
+        private void ArchiveOneRegion(Scene scene, string regionDir, Dictionary<UUID, sbyte> assetUuids)
         {
-            m_log.InfoFormat("[ARCHIVER]: Writing region {0}", scene.RegionInfo.RegionName);
+            m_log.InfoFormat("[ARCHIVER]: Writing region {0}", scene.Name);
 
             EntityBase[] entities = scene.GetEntities();
             List<SceneObjectGroup> sceneObjects = new List<SceneObjectGroup>();
@@ -236,7 +239,7 @@ namespace OpenSim.Region.CoreModules.World.Archiver
 
                     if (!sceneObject.IsDeleted && !sceneObject.IsAttachment)
                     {
-                        if (!CanUserArchiveObject(scene.RegionInfo.EstateSettings.EstateOwner, sceneObject, CheckPermissions, permissionsModule))
+                        if (!CanUserArchiveObject(scene.RegionInfo.EstateSettings.EstateOwner, sceneObject, FilterContent, permissionsModule))
                         {
                             // The user isn't allowed to copy/transfer this object, so it will not be included in the OAR.
                             ++numObjectsSkippedPermissions;
@@ -251,13 +254,13 @@ namespace OpenSim.Region.CoreModules.World.Archiver
 
             if (SaveAssets)
             {
-                UuidGatherer assetGatherer = new UuidGatherer(scene.AssetService);
+                UuidGatherer assetGatherer = new UuidGatherer(scene.AssetService, assetUuids);
                 int prevAssets = assetUuids.Count;
                     
                 foreach (SceneObjectGroup sceneObject in sceneObjects)
-                {
-                    assetGatherer.GatherAssetUuids(sceneObject, assetUuids);
-                }
+                    assetGatherer.AddForInspection(sceneObject);
+
+                assetGatherer.GatherAll();
 
                 m_log.DebugFormat(
                     "[ARCHIVER]: {0} scene objects to serialize requiring save of {1} assets",
@@ -275,16 +278,16 @@ namespace OpenSim.Region.CoreModules.World.Archiver
             RegionSettings regionSettings = scene.RegionInfo.RegionSettings;
     
             if (regionSettings.TerrainTexture1 != RegionSettings.DEFAULT_TERRAIN_TEXTURE_1)
-                assetUuids[regionSettings.TerrainTexture1] = AssetType.Texture;
+                assetUuids[regionSettings.TerrainTexture1] = (sbyte)AssetType.Texture;
                 
             if (regionSettings.TerrainTexture2 != RegionSettings.DEFAULT_TERRAIN_TEXTURE_2)
-                assetUuids[regionSettings.TerrainTexture2] = AssetType.Texture;
+                assetUuids[regionSettings.TerrainTexture2] = (sbyte)AssetType.Texture;
                 
             if (regionSettings.TerrainTexture3 != RegionSettings.DEFAULT_TERRAIN_TEXTURE_3)
-                assetUuids[regionSettings.TerrainTexture3] = AssetType.Texture;
+                assetUuids[regionSettings.TerrainTexture3] = (sbyte)AssetType.Texture;
                 
             if (regionSettings.TerrainTexture4 != RegionSettings.DEFAULT_TERRAIN_TEXTURE_4)
-                assetUuids[regionSettings.TerrainTexture4] = AssetType.Texture;
+                assetUuids[regionSettings.TerrainTexture4] = (sbyte)AssetType.Texture;
 
             Save(scene, sceneObjects, regionDir);
         }
@@ -294,12 +297,12 @@ namespace OpenSim.Region.CoreModules.World.Archiver
         /// </summary>
         /// <param name="user">The user</param>
         /// <param name="objGroup">The object group</param>
-        /// <param name="checkPermissions">Which permissions to check: "C" = Copy, "T" = Transfer</param>
+        /// <param name="filterContent">Which permissions to check: "C" = Copy, "T" = Transfer</param>
         /// <param name="permissionsModule">The scene's permissions module</param>
         /// <returns>Whether the user is allowed to export the object to an OAR</returns>
-        private bool CanUserArchiveObject(UUID user, SceneObjectGroup objGroup, string checkPermissions, IPermissionsModule permissionsModule)
+        private bool CanUserArchiveObject(UUID user, SceneObjectGroup objGroup, string filterContent, IPermissionsModule permissionsModule)
         {
-            if (checkPermissions == null)
+            if (filterContent == null)
                 return true;
 
             if (permissionsModule == null)
@@ -341,9 +344,9 @@ namespace OpenSim.Region.CoreModules.World.Archiver
                     canTransfer |= (obj.EveryoneMask & (uint)PermissionMask.Copy) != 0;
 
                 bool partPermitted = true;
-                if (checkPermissions.Contains("C") && !canCopy)
+                if (filterContent.Contains("C") && !canCopy)
                     partPermitted = false;
-                if (checkPermissions.Contains("T") && !canTransfer)
+                if (filterContent.Contains("T") && !canTransfer)
                     partPermitted = false;
 
                 // If the user is the Creator of the object then it can always be included in the OAR
@@ -532,7 +535,7 @@ namespace OpenSim.Region.CoreModules.World.Archiver
             if (isMegaregion)
                 size = rcMod.GetSizeOfMegaregion(scene.RegionInfo.RegionID);
             else
-                size = new Vector2((float)Constants.RegionSize, (float)Constants.RegionSize);
+                size = new Vector2((float)scene.RegionInfo.RegionSizeX, (float)scene.RegionInfo.RegionSizeY);
     
             xtw.WriteElementString("is_megaregion", isMegaregion.ToString());
             xtw.WriteElementString("size_in_meters", string.Format("{0},{1}", size.X, size.Y));
@@ -568,10 +571,11 @@ namespace OpenSim.Region.CoreModules.World.Archiver
             string terrainPath = String.Format("{0}{1}{2}.r32",
                 regionDir, ArchiveConstants.TERRAINS_PATH, scene.RegionInfo.RegionName);
 
-            MemoryStream ms = new MemoryStream();
-            scene.RequestModuleInterface<ITerrainModule>().SaveToStream(terrainPath, ms);
-            m_archiveWriter.WriteFile(terrainPath, ms.ToArray());
-            ms.Close();
+            using (MemoryStream ms = new MemoryStream())
+            {
+                scene.RequestModuleInterface<ITerrainModule>().SaveToStream(terrainPath, ms);
+                m_archiveWriter.WriteFile(terrainPath, ms.ToArray());
+            }
 
             m_log.InfoFormat("[ARCHIVER]: Adding scene objects to archive.");
 
@@ -587,19 +591,29 @@ namespace OpenSim.Region.CoreModules.World.Archiver
             }
         }
         
-        protected void ReceivedAllAssets(
-            ICollection<UUID> assetsFoundUuids, ICollection<UUID> assetsNotFoundUuids)
+        protected void ReceivedAllAssets(ICollection<UUID> assetsFoundUuids, ICollection<UUID> assetsNotFoundUuids, bool timedOut)
         {
-            foreach (UUID uuid in assetsNotFoundUuids)
+            string errorMessage;
+            
+            if (timedOut)
             {
-                m_log.DebugFormat("[ARCHIVER]: Could not find asset {0}", uuid);
+                errorMessage = "Loading assets timed out";
             }
+            else
+            {
+                foreach (UUID uuid in assetsNotFoundUuids)
+                {
+                    m_log.DebugFormat("[ARCHIVER]: Could not find asset {0}", uuid);
+                }
 
-            //            m_log.InfoFormat(
-            //                "[ARCHIVER]: Received {0} of {1} assets requested",
-            //                assetsFoundUuids.Count, assetsFoundUuids.Count + assetsNotFoundUuids.Count);
+                //            m_log.InfoFormat(
+                //                "[ARCHIVER]: Received {0} of {1} assets requested",
+                //                assetsFoundUuids.Count, assetsFoundUuids.Count + assetsNotFoundUuids.Count);
 
-            CloseArchive(String.Empty);
+                errorMessage = String.Empty;
+            }
+            
+            CloseArchive(errorMessage);
         }
         
         /// <summary>
@@ -626,4 +640,4 @@ namespace OpenSim.Region.CoreModules.World.Archiver
             m_rootScene.EventManager.TriggerOarFileSaved(m_requestId, errorMessage);
         }
     }
-}
\ No newline at end of file
+}
diff --git a/OpenSim/Region/CoreModules/World/Archiver/ArchiverModule.cs b/OpenSim/Region/CoreModules/World/Archiver/ArchiverModule.cs
index 1be6386..6a09caf 100644
--- a/OpenSim/Region/CoreModules/World/Archiver/ArchiverModule.cs
+++ b/OpenSim/Region/CoreModules/World/Archiver/ArchiverModule.cs
@@ -33,11 +33,14 @@ using log4net;
 using NDesk.Options;
 using Nini.Config;
 using Mono.Addins;
+
 using OpenSim.Framework;
 using OpenSim.Framework.Console;
 using OpenSim.Region.Framework.Interfaces;
 using OpenSim.Region.Framework.Scenes;
 
+using OpenMetaverse;
+
 namespace OpenSim.Region.CoreModules.World.Archiver
 {
     /// <summary>
@@ -101,9 +104,62 @@ namespace OpenSim.Region.CoreModules.World.Archiver
         {
             bool mergeOar = false;
             bool skipAssets = false;
+            bool forceTerrain = false;
+            bool forceParcels = false;
+            bool noObjects = false;
+            Vector3 displacement = new Vector3(0f, 0f, 0f);
+            String defaultUser = "";
+            float rotation = 0f;
+            Vector3 rotationCenter = new Vector3(Constants.RegionSize / 2f, Constants.RegionSize / 2f, 0);
             
-            OptionSet options = new OptionSet().Add("m|merge", delegate (string v) { mergeOar = v != null; });
-            options.Add("s|skip-assets", delegate (string v) { skipAssets = v != null; });
+            OptionSet options = new OptionSet();
+            options.Add("m|merge", delegate (string v) { mergeOar = (v != null); });
+            options.Add("s|skip-assets", delegate (string v) { skipAssets = (v != null); });
+            options.Add("force-terrain", delegate (string v) { forceTerrain = (v != null); });
+            options.Add("forceterrain", delegate (string v) { forceTerrain = (v != null); });   // downward compatibility
+            options.Add("force-parcels", delegate (string v) { forceParcels = (v != null); });
+            options.Add("forceparcels", delegate (string v) { forceParcels = (v != null); });   // downward compatibility
+            options.Add("no-objects", delegate (string v) { noObjects = (v != null); });
+            options.Add("default-user=", delegate(string v) { defaultUser = (v == null) ? "" : v; });
+            options.Add("displacement=", delegate (string v) {
+                try
+                {
+                    displacement = v == null ? Vector3.Zero : Vector3.Parse(v);
+                }
+                catch
+                {
+                    m_log.ErrorFormat("[ARCHIVER MODULE] failure parsing displacement");
+                    m_log.ErrorFormat("[ARCHIVER MODULE]    Must be represented as vector3: --displacement \"<128,128,0>\"");
+                    return;
+                }
+            });
+            options.Add("rotation=", delegate(string v)
+            {
+                try
+                {
+                    rotation = v == null ? 0f : float.Parse(v);
+                }
+                catch
+                {
+                    m_log.ErrorFormat("[ARCHIVER MODULE] failure parsing rotation");
+                    m_log.ErrorFormat("[ARCHIVER MODULE]    Must be an angle in degrees between -360 and +360: --rotation 45");
+                    return;
+                }
+                // Convert to radians for internals
+                rotation = Util.Clamp<float>(rotation, -359f, 359f) / 180f * (float)Math.PI;
+            });
+            options.Add("rotation-center=", delegate (string v) {
+                try
+                {
+                    rotationCenter = v == null ? Vector3.Zero : Vector3.Parse(v);
+                }
+                catch
+                {
+                    m_log.ErrorFormat("[ARCHIVER MODULE] failure parsing rotation displacement");
+                    m_log.ErrorFormat("[ARCHIVER MODULE]    Must be represented as vector3: --rotation-center \"<128,128,0>\"");
+                    return;
+                }
+            });
 
             // Send a message to the region ready module
             /* bluewall* Disable this for the time being
@@ -122,13 +178,44 @@ namespace OpenSim.Region.CoreModules.World.Archiver
 //            foreach (string param in mainParams)
 //                m_log.DebugFormat("GOT PARAM [{0}]", param);
 
+            Dictionary<string, object> archiveOptions = new Dictionary<string, object>();
+            if (mergeOar) archiveOptions.Add("merge", null);
+            if (skipAssets) archiveOptions.Add("skipAssets", null);
+            if (forceTerrain) archiveOptions.Add("force-terrain", null);
+            if (forceParcels) archiveOptions.Add("force-parcels", null);
+            if (noObjects) archiveOptions.Add("no-objects", null);
+            if (defaultUser != "")
+            {
+                UUID defaultUserUUID = UUID.Zero;
+                try
+                {
+                    defaultUserUUID = Scene.UserManagementModule.GetUserIdByName(defaultUser);
+                }
+                catch
+                {
+                    m_log.ErrorFormat("[ARCHIVER MODULE] default user must be in format \"First Last\"", defaultUser);
+                }
+                if (defaultUserUUID == UUID.Zero)
+                {
+                    m_log.ErrorFormat("[ARCHIVER MODULE] cannot find specified default user {0}", defaultUser);
+                    return;
+                }
+                else
+                {
+                    archiveOptions.Add("default-user", defaultUserUUID);
+                }
+            }
+            archiveOptions.Add("displacement", displacement);
+            archiveOptions.Add("rotation", rotation);
+            archiveOptions.Add("rotation-center", rotationCenter);
+
             if (mainParams.Count > 2)
             {
-                DearchiveRegion(mainParams[2], mergeOar, skipAssets, Guid.Empty);
+                DearchiveRegion(mainParams[2], Guid.Empty, archiveOptions);
             }
             else
             {
-                DearchiveRegion(DEFAULT_OAR_BACKUP_FILENAME, mergeOar, skipAssets, Guid.Empty);
+                DearchiveRegion(DEFAULT_OAR_BACKUP_FILENAME, Guid.Empty, archiveOptions);
             }
         }
 
@@ -198,25 +285,27 @@ namespace OpenSim.Region.CoreModules.World.Archiver
 
         public void DearchiveRegion(string loadPath)
         {
-            DearchiveRegion(loadPath, false, false, Guid.Empty);
+            Dictionary<string, object> archiveOptions = new Dictionary<string, object>();
+            DearchiveRegion(loadPath, Guid.Empty, archiveOptions);
         }
         
-        public void DearchiveRegion(string loadPath, bool merge, bool skipAssets, Guid requestId)
+        public void DearchiveRegion(string loadPath, Guid requestId, Dictionary<string,object> options)
         {
             m_log.InfoFormat(
                 "[ARCHIVER]: Loading archive to region {0} from {1}", Scene.RegionInfo.RegionName, loadPath);
             
-            new ArchiveReadRequest(Scene, loadPath, merge, skipAssets, requestId).DearchiveRegion();
+            new ArchiveReadRequest(Scene, loadPath, requestId, options).DearchiveRegion();
         }
         
         public void DearchiveRegion(Stream loadStream)
         {
-            DearchiveRegion(loadStream, false, false, Guid.Empty);
+            Dictionary<string, object> archiveOptions = new Dictionary<string, object>();
+            DearchiveRegion(loadStream, Guid.Empty, archiveOptions);
         }
         
-        public void DearchiveRegion(Stream loadStream, bool merge, bool skipAssets, Guid requestId)
+        public void DearchiveRegion(Stream loadStream, Guid requestId, Dictionary<string, object> options)
         {
-            new ArchiveReadRequest(Scene, loadStream, merge, skipAssets, requestId).DearchiveRegion();
+            new ArchiveReadRequest(Scene, loadStream, requestId, options).DearchiveRegion();
         }
     }
 }
diff --git a/OpenSim/Region/CoreModules/World/Archiver/AssetsArchiver.cs b/OpenSim/Region/CoreModules/World/Archiver/AssetsArchiver.cs
index 95d109c..a8eae56 100644
--- a/OpenSim/Region/CoreModules/World/Archiver/AssetsArchiver.cs
+++ b/OpenSim/Region/CoreModules/World/Archiver/AssetsArchiver.cs
@@ -145,17 +145,10 @@ namespace OpenSim.Region.CoreModules.World.Archiver
             m_assetsWritten++;
 
             //m_log.DebugFormat("[ARCHIVER]: Added asset {0}", m_assetsWritten);
-            
+
             if (m_assetsWritten % LOG_ASSET_LOAD_NOTIFICATION_INTERVAL == 0)
                 m_log.InfoFormat("[ARCHIVER]: Added {0} assets to archive", m_assetsWritten);
         }
 
-        /// <summary>
-        /// Only call this if you need to force a close on the underlying writer.
-        /// </summary>
-        public void ForceClose()
-        {
-            m_archiveWriter.Close();
-        }
     }
 }
diff --git a/OpenSim/Region/CoreModules/World/Archiver/AssetsRequest.cs b/OpenSim/Region/CoreModules/World/Archiver/AssetsRequest.cs
index 103eb47..db66c83 100644
--- a/OpenSim/Region/CoreModules/World/Archiver/AssetsRequest.cs
+++ b/OpenSim/Region/CoreModules/World/Archiver/AssetsRequest.cs
@@ -33,6 +33,7 @@ using System.Timers;
 using log4net;
 using OpenMetaverse;
 using OpenSim.Framework;
+using OpenSim.Framework.Monitoring;
 using OpenSim.Framework.Serialization;
 using OpenSim.Framework.Serialization.External;
 using OpenSim.Services.Interfaces;
@@ -50,7 +51,7 @@ namespace OpenSim.Region.CoreModules.World.Archiver
         /// Method called when all the necessary assets for an archive request have been received.
         /// </summary>
         public delegate void AssetsRequestCallback(
-            ICollection<UUID> assetsFoundUuids, ICollection<UUID> assetsNotFoundUuids);
+            ICollection<UUID> assetsFoundUuids, ICollection<UUID> assetsNotFoundUuids, bool timedOut);
 
         enum RequestState
         {
@@ -81,7 +82,7 @@ namespace OpenSim.Region.CoreModules.World.Archiver
         /// <value>
         /// uuids to request
         /// </value>
-        protected IDictionary<UUID, AssetType> m_uuids;
+        protected IDictionary<UUID, sbyte> m_uuids;
 
         /// <value>
         /// Callback used when all the assets requested have been received.
@@ -115,7 +116,7 @@ namespace OpenSim.Region.CoreModules.World.Archiver
         protected Dictionary<string, object> m_options;
 
         protected internal AssetsRequest(
-            AssetsArchiver assetsArchiver, IDictionary<UUID, AssetType> uuids, 
+            AssetsArchiver assetsArchiver, IDictionary<UUID, sbyte> uuids, 
             IAssetService assetService, IUserAccountService userService, 
             UUID scope, Dictionary<string, object> options, 
             AssetsRequestCallback assetsRequestCallback)
@@ -143,19 +144,21 @@ namespace OpenSim.Region.CoreModules.World.Archiver
             m_requestState = RequestState.Running;
             
             m_log.DebugFormat("[ARCHIVER]: AssetsRequest executed looking for {0} possible assets", m_repliesRequired);
-            
+
             // We can stop here if there are no assets to fetch
             if (m_repliesRequired == 0)
             {
                 m_requestState = RequestState.Completed;
-                PerformAssetsRequestCallback(null);
+                PerformAssetsRequestCallback(false);
                 return;
             }
 
             m_requestCallbackTimer.Enabled = true;
 
-            foreach (KeyValuePair<UUID, AssetType> kvp in m_uuids)
+            foreach (KeyValuePair<UUID, sbyte> kvp in m_uuids)
             {
+//                m_log.DebugFormat("[ARCHIVER]: Requesting asset {0}", kvp.Key);
+
 //                m_assetService.Get(kvp.Key.ToString(), kvp.Value, PreAssetRequestCallback);
                 AssetBase asset = m_assetService.Get(kvp.Key.ToString());
                 PreAssetRequestCallback(kvp.Key.ToString(), kvp.Value, asset);
@@ -164,7 +167,7 @@ namespace OpenSim.Region.CoreModules.World.Archiver
 
         protected void OnRequestCallbackTimeout(object source, ElapsedEventArgs args)
         {
-            bool close = true;
+            bool timedOut = true;
 
             try
             {
@@ -174,7 +177,7 @@ namespace OpenSim.Region.CoreModules.World.Archiver
                     // the final request came in (assuming that such a thing is possible)
                     if (m_requestState == RequestState.Completed)
                     {
-                        close = false;
+                        timedOut = false;
                         return;
                     }
                     
@@ -223,8 +226,8 @@ namespace OpenSim.Region.CoreModules.World.Archiver
             }
             finally
             {
-                if (close)
-                    m_assetsArchiver.ForceClose();
+                if (timedOut)
+                    WorkManager.RunInThread(PerformAssetsRequestCallback, true, "Archive Assets Request Callback");
             }
         }
 
@@ -233,9 +236,8 @@ namespace OpenSim.Region.CoreModules.World.Archiver
             // Check for broken asset types and fix them with the AssetType gleaned by UuidGatherer
             if (fetchedAsset != null && fetchedAsset.Type == (sbyte)AssetType.Unknown)
             {
-                AssetType type = (AssetType)assetType;
-                m_log.InfoFormat("[ARCHIVER]: Rewriting broken asset type for {0} to {1}", fetchedAsset.ID, type);
-                fetchedAsset.Type = (sbyte)type;
+                m_log.InfoFormat("[ARCHIVER]: Rewriting broken asset type for {0} to {1}", fetchedAsset.ID,  SLUtil.AssetTypeFromCode((sbyte)assetType));
+                fetchedAsset.Type = (sbyte)assetType;
             }
 
             AssetRequestCallback(fetchedAssetID, this, fetchedAsset);
@@ -294,7 +296,7 @@ namespace OpenSim.Region.CoreModules.World.Archiver
                         
                         // We want to stop using the asset cache thread asap 
                         // as we now need to do the work of producing the rest of the archive
-                        Util.FireAndForget(PerformAssetsRequestCallback);
+                        WorkManager.RunInThread(PerformAssetsRequestCallback, false, "Archive Assets Request Callback");
                     }
                     else
                     {
@@ -315,9 +317,11 @@ namespace OpenSim.Region.CoreModules.World.Archiver
         {
             Culture.SetCurrentCulture();
 
+            Boolean timedOut = (Boolean)o;
+
             try
             {
-                m_assetsRequestCallback(m_foundAssetUuids, m_notFoundAssetUuids);
+                m_assetsRequestCallback(m_foundAssetUuids, m_notFoundAssetUuids, timedOut);
             }
             catch (Exception e)
             {
@@ -331,7 +335,7 @@ namespace OpenSim.Region.CoreModules.World.Archiver
             if (asset.Type == (sbyte)AssetType.Object && asset.Data != null && m_options.ContainsKey("home"))
             {
                 //m_log.DebugFormat("[ARCHIVER]: Rewriting object data for {0}", asset.ID);
-                string xml = ExternalRepresentationUtils.RewriteSOP(Utils.BytesToString(asset.Data), m_options["home"].ToString(), m_userAccountService, m_scopeID);
+                string xml = ExternalRepresentationUtils.RewriteSOP(Utils.BytesToString(asset.Data), string.Empty, m_options["home"].ToString(), m_userAccountService, m_scopeID);
                 asset.Data = Utils.StringToBytes(xml);
             }
             return asset;
diff --git a/OpenSim/Region/CoreModules/World/Archiver/Tests/ArchiverTests.cs b/OpenSim/Region/CoreModules/World/Archiver/Tests/ArchiverTests.cs
index eec1cec..9f197f5 100644
--- a/OpenSim/Region/CoreModules/World/Archiver/Tests/ArchiverTests.cs
+++ b/OpenSim/Region/CoreModules/World/Archiver/Tests/ArchiverTests.cs
@@ -45,7 +45,6 @@ using OpenSim.Region.Framework.Scenes;
 using OpenSim.Region.Framework.Scenes.Serialization;
 using OpenSim.Region.OptionalModules.Avatar.XmlRpcGroups;
 using OpenSim.Tests.Common;
-using OpenSim.Tests.Common.Mock;
 using ArchiveConstants = OpenSim.Framework.Serialization.ArchiveConstants;
 using TarArchiveReader = OpenSim.Framework.Serialization.TarArchiveReader;
 using TarArchiveWriter = OpenSim.Framework.Serialization.TarArchiveWriter;
@@ -224,8 +223,9 @@ namespace OpenSim.Region.CoreModules.World.Archiver.Tests
 
             byte[] data = tar.ReadEntry(out filePath, out tarEntryType);
             Assert.That(filePath, Is.EqualTo(ArchiveConstants.CONTROL_FILE_PATH));
-            
-            ArchiveReadRequest arr = new ArchiveReadRequest(m_scene, (Stream)null, false, false, Guid.Empty);
+
+            Dictionary<string, object> archiveOptions = new Dictionary<string, object>();
+            ArchiveReadRequest arr = new ArchiveReadRequest(m_scene, (Stream)null, Guid.Empty, archiveOptions);
             arr.LoadControlFile(filePath, data, new DearchiveScenesInfo());
             
             Assert.That(arr.ControlFileLoaded, Is.True);        
@@ -308,8 +308,9 @@ namespace OpenSim.Region.CoreModules.World.Archiver.Tests
 
             byte[] data = tar.ReadEntry(out filePath, out tarEntryType);
             Assert.That(filePath, Is.EqualTo(ArchiveConstants.CONTROL_FILE_PATH));
-            
-            ArchiveReadRequest arr = new ArchiveReadRequest(m_scene, (Stream)null, false, false, Guid.Empty);
+
+            Dictionary<string, object> archiveOptions = new Dictionary<string, object>();
+            ArchiveReadRequest arr = new ArchiveReadRequest(m_scene, (Stream)null, Guid.Empty, archiveOptions);
             arr.LoadControlFile(filePath, data, new DearchiveScenesInfo());
             
             Assert.That(arr.ControlFileLoaded, Is.True);        
@@ -577,13 +578,14 @@ namespace OpenSim.Region.CoreModules.World.Archiver.Tests
                 ArchiveConstants.CONTROL_FILE_PATH,
                 new ArchiveWriteRequest(m_scene, (Stream)null, Guid.Empty).CreateControlFile(new ArchiveScenesGroup()));
 
-            LandObject lo = new LandObject(groupID, true, null);
+            LandObject lo = new LandObject(groupID, true, m_scene);
             lo.SetLandBitmap(lo.BasicFullRegionLandBitmap());
             LandData ld = lo.LandData;
             ld.GlobalID = landID;
 
             string ldPath = ArchiveConstants.CreateOarLandDataPath(ld);
-            tar.WriteFile(ldPath, LandDataSerializer.Serialize(ld, null));
+            Dictionary<string, object> options = new Dictionary<string, object>();
+            tar.WriteFile(ldPath, LandDataSerializer.Serialize(ld, options));
             tar.Close();
 
             oarStream = new MemoryStream(oarStream.ToArray());
@@ -752,7 +754,9 @@ namespace OpenSim.Region.CoreModules.World.Archiver.Tests
                 byte[] archive = archiveWriteStream.ToArray();
                 MemoryStream archiveReadStream = new MemoryStream(archive);
 
-                m_archiverModule.DearchiveRegion(archiveReadStream, true, false, Guid.Empty);
+                Dictionary<string, object> archiveOptions = new Dictionary<string, object>();
+                archiveOptions.Add("merge", null);
+                m_archiverModule.DearchiveRegion(archiveReadStream, Guid.Empty, archiveOptions);
 
                 SceneObjectPart object1Existing = m_scene.GetSceneObjectPart(part1.Name);
                 Assert.That(object1Existing, Is.Not.Null, "object1 was not present after merge");
@@ -860,7 +864,8 @@ namespace OpenSim.Region.CoreModules.World.Archiver.Tests
             byte[] data = tar.ReadEntry(out filePath, out tarEntryType);
             Assert.That(filePath, Is.EqualTo(ArchiveConstants.CONTROL_FILE_PATH));
 
-            ArchiveReadRequest arr = new ArchiveReadRequest(m_scene, (Stream)null, false, false, Guid.Empty);
+            Dictionary<string, object> archiveOptions = new Dictionary<string, object>();
+            ArchiveReadRequest arr = new ArchiveReadRequest(m_scene, (Stream)null, Guid.Empty, archiveOptions);
             arr.LoadControlFile(filePath, data, new DearchiveScenesInfo());
 
             Assert.That(arr.ControlFileLoaded, Is.True);