diff options
Diffstat (limited to 'OpenSim/Region/CoreModules/World/Archiver/ArchiveWriteRequestPreparation.cs')
-rw-r--r-- | OpenSim/Region/CoreModules/World/Archiver/ArchiveWriteRequestPreparation.cs | 438 |
1 files changed, 0 insertions, 438 deletions
diff --git a/OpenSim/Region/CoreModules/World/Archiver/ArchiveWriteRequestPreparation.cs b/OpenSim/Region/CoreModules/World/Archiver/ArchiveWriteRequestPreparation.cs deleted file mode 100644 index 4edaaca..0000000 --- a/OpenSim/Region/CoreModules/World/Archiver/ArchiveWriteRequestPreparation.cs +++ /dev/null | |||
@@ -1,438 +0,0 @@ | |||
1 | /* | ||
2 | * Copyright (c) Contributors, http://opensimulator.org/ | ||
3 | * See CONTRIBUTORS.TXT for a full list of copyright holders. | ||
4 | * | ||
5 | * Redistribution and use in source and binary forms, with or without | ||
6 | * modification, are permitted provided that the following conditions are met: | ||
7 | * * Redistributions of source code must retain the above copyright | ||
8 | * notice, this list of conditions and the following disclaimer. | ||
9 | * * Redistributions in binary form must reproduce the above copyright | ||
10 | * notice, this list of conditions and the following disclaimer in the | ||
11 | * documentation and/or other materials provided with the distribution. | ||
12 | * * Neither the name of the OpenSimulator Project nor the | ||
13 | * names of its contributors may be used to endorse or promote products | ||
14 | * derived from this software without specific prior written permission. | ||
15 | * | ||
16 | * THIS SOFTWARE IS PROVIDED BY THE DEVELOPERS ``AS IS'' AND ANY | ||
17 | * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED | ||
18 | * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE | ||
19 | * DISCLAIMED. IN NO EVENT SHALL THE CONTRIBUTORS BE LIABLE FOR ANY | ||
20 | * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES | ||
21 | * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; | ||
22 | * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND | ||
23 | * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT | ||
24 | * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS | ||
25 | * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. | ||
26 | */ | ||
27 | |||
28 | using System; | ||
29 | using System.Collections.Generic; | ||
30 | using System.IO; | ||
31 | using System.IO.Compression; | ||
32 | using System.Reflection; | ||
33 | using System.Text.RegularExpressions; | ||
34 | using System.Threading; | ||
35 | using System.Xml; | ||
36 | using log4net; | ||
37 | using OpenMetaverse; | ||
38 | using OpenSim.Framework; | ||
39 | using OpenSim.Framework.Serialization; | ||
40 | using OpenSim.Region.CoreModules.World.Terrain; | ||
41 | using OpenSim.Region.Framework.Interfaces; | ||
42 | using OpenSim.Region.Framework.Scenes; | ||
43 | using Ionic.Zlib; | ||
44 | using GZipStream = Ionic.Zlib.GZipStream; | ||
45 | using CompressionMode = Ionic.Zlib.CompressionMode; | ||
46 | |||
47 | namespace OpenSim.Region.CoreModules.World.Archiver | ||
48 | { | ||
49 | /// <summary> | ||
50 | /// Prepare to write out an archive. | ||
51 | /// </summary> | ||
52 | public class ArchiveWriteRequestPreparation | ||
53 | { | ||
54 | private static readonly ILog m_log = LogManager.GetLogger(MethodBase.GetCurrentMethod().DeclaringType); | ||
55 | |||
56 | /// <summary> | ||
57 | /// The minimum major version of OAR that we can write. | ||
58 | /// </summary> | ||
59 | public static int MIN_MAJOR_VERSION = 0; | ||
60 | |||
61 | /// <summary> | ||
62 | /// The maximum major version of OAR that we can write. | ||
63 | /// </summary> | ||
64 | public static int MAX_MAJOR_VERSION = 0; | ||
65 | |||
66 | /// <summary> | ||
67 | /// Determine whether this archive will save assets. Default is true. | ||
68 | /// </summary> | ||
69 | public bool SaveAssets { get; set; } | ||
70 | |||
71 | protected ArchiverModule m_module; | ||
72 | protected Scene m_scene; | ||
73 | protected Stream m_saveStream; | ||
74 | protected Guid m_requestId; | ||
75 | |||
76 | /// <summary> | ||
77 | /// Constructor | ||
78 | /// </summary> | ||
79 | /// <param name="module">Calling module</param> | ||
80 | /// <param name="savePath">The path to which to save data.</param> | ||
81 | /// <param name="requestId">The id associated with this request</param> | ||
82 | /// <exception cref="System.IO.IOException"> | ||
83 | /// If there was a problem opening a stream for the file specified by the savePath | ||
84 | /// </exception> | ||
85 | public ArchiveWriteRequestPreparation(ArchiverModule module, string savePath, Guid requestId) : this(module, requestId) | ||
86 | { | ||
87 | try | ||
88 | { | ||
89 | m_saveStream = new GZipStream(new FileStream(savePath, FileMode.Create), CompressionMode.Compress, CompressionLevel.BestCompression); | ||
90 | } | ||
91 | catch (EntryPointNotFoundException e) | ||
92 | { | ||
93 | m_log.ErrorFormat( | ||
94 | "[ARCHIVER]: Mismatch between Mono and zlib1g library version when trying to create compression stream." | ||
95 | + "If you've manually installed Mono, have you appropriately updated zlib1g as well?"); | ||
96 | m_log.ErrorFormat("{0} {1}", e.Message, e.StackTrace); | ||
97 | } | ||
98 | } | ||
99 | |||
100 | /// <summary> | ||
101 | /// Constructor. | ||
102 | /// </summary> | ||
103 | /// <param name="module">Calling module</param> | ||
104 | /// <param name="saveStream">The stream to which to save data.</param> | ||
105 | /// <param name="requestId">The id associated with this request</param> | ||
106 | public ArchiveWriteRequestPreparation(ArchiverModule module, Stream saveStream, Guid requestId) : this(module, requestId) | ||
107 | { | ||
108 | m_saveStream = saveStream; | ||
109 | } | ||
110 | |||
111 | protected ArchiveWriteRequestPreparation(ArchiverModule module, Guid requestId) | ||
112 | { | ||
113 | m_module = module; | ||
114 | |||
115 | // FIXME: This is only here for regression test purposes since they do not supply a module. Need to fix | ||
116 | // this. | ||
117 | if (m_module != null) | ||
118 | m_scene = m_module.Scene; | ||
119 | |||
120 | m_requestId = requestId; | ||
121 | |||
122 | SaveAssets = true; | ||
123 | } | ||
124 | |||
125 | /// <summary> | ||
126 | /// Archive the region requested. | ||
127 | /// </summary> | ||
128 | /// <exception cref="System.IO.IOException">if there was an io problem with creating the file</exception> | ||
129 | public void ArchiveRegion(Dictionary<string, object> options) | ||
130 | { | ||
131 | if (options.ContainsKey("noassets") && (bool)options["noassets"]) | ||
132 | SaveAssets = false; | ||
133 | |||
134 | try | ||
135 | { | ||
136 | Dictionary<UUID, AssetType> assetUuids = new Dictionary<UUID, AssetType>(); | ||
137 | |||
138 | EntityBase[] entities = m_scene.GetEntities(); | ||
139 | List<SceneObjectGroup> sceneObjects = new List<SceneObjectGroup>(); | ||
140 | |||
141 | string checkPermissions = null; | ||
142 | int numObjectsSkippedPermissions = 0; | ||
143 | Object temp; | ||
144 | if (options.TryGetValue("checkPermissions", out temp)) | ||
145 | checkPermissions = (string)temp; | ||
146 | |||
147 | // Filter entities so that we only have scene objects. | ||
148 | // FIXME: Would be nicer to have this as a proper list in SceneGraph, since lots of methods | ||
149 | // end up having to do this | ||
150 | foreach (EntityBase entity in entities) | ||
151 | { | ||
152 | if (entity is SceneObjectGroup) | ||
153 | { | ||
154 | SceneObjectGroup sceneObject = (SceneObjectGroup)entity; | ||
155 | |||
156 | if (!sceneObject.IsDeleted && !sceneObject.IsAttachment) | ||
157 | { | ||
158 | if (!CanUserArchiveObject(m_scene.RegionInfo.EstateSettings.EstateOwner, sceneObject, checkPermissions)) | ||
159 | { | ||
160 | // The user isn't allowed to copy/transfer this object, so it will not be included in the OAR. | ||
161 | ++numObjectsSkippedPermissions; | ||
162 | } | ||
163 | else | ||
164 | { | ||
165 | sceneObjects.Add(sceneObject); | ||
166 | } | ||
167 | } | ||
168 | } | ||
169 | } | ||
170 | |||
171 | if (SaveAssets) | ||
172 | { | ||
173 | UuidGatherer assetGatherer = new UuidGatherer(m_scene.AssetService); | ||
174 | |||
175 | foreach (SceneObjectGroup sceneObject in sceneObjects) | ||
176 | { | ||
177 | assetGatherer.GatherAssetUuids(sceneObject, assetUuids); | ||
178 | } | ||
179 | |||
180 | m_log.DebugFormat( | ||
181 | "[ARCHIVER]: {0} scene objects to serialize requiring save of {1} assets", | ||
182 | sceneObjects.Count, assetUuids.Count); | ||
183 | } | ||
184 | else | ||
185 | { | ||
186 | m_log.DebugFormat("[ARCHIVER]: Not saving assets since --noassets was specified"); | ||
187 | } | ||
188 | |||
189 | if (numObjectsSkippedPermissions > 0) | ||
190 | { | ||
191 | m_log.DebugFormat( | ||
192 | "[ARCHIVER]: {0} scene objects skipped due to lack of permissions", | ||
193 | numObjectsSkippedPermissions); | ||
194 | } | ||
195 | |||
196 | // Make sure that we also request terrain texture assets | ||
197 | RegionSettings regionSettings = m_scene.RegionInfo.RegionSettings; | ||
198 | |||
199 | if (regionSettings.TerrainTexture1 != RegionSettings.DEFAULT_TERRAIN_TEXTURE_1) | ||
200 | assetUuids[regionSettings.TerrainTexture1] = AssetType.Texture; | ||
201 | |||
202 | if (regionSettings.TerrainTexture2 != RegionSettings.DEFAULT_TERRAIN_TEXTURE_2) | ||
203 | assetUuids[regionSettings.TerrainTexture2] = AssetType.Texture; | ||
204 | |||
205 | if (regionSettings.TerrainTexture3 != RegionSettings.DEFAULT_TERRAIN_TEXTURE_3) | ||
206 | assetUuids[regionSettings.TerrainTexture3] = AssetType.Texture; | ||
207 | |||
208 | if (regionSettings.TerrainTexture4 != RegionSettings.DEFAULT_TERRAIN_TEXTURE_4) | ||
209 | assetUuids[regionSettings.TerrainTexture4] = AssetType.Texture; | ||
210 | |||
211 | TarArchiveWriter archiveWriter = new TarArchiveWriter(m_saveStream); | ||
212 | |||
213 | // Asynchronously request all the assets required to perform this archive operation | ||
214 | ArchiveWriteRequestExecution awre | ||
215 | = new ArchiveWriteRequestExecution( | ||
216 | sceneObjects, | ||
217 | m_scene.RequestModuleInterface<ITerrainModule>(), | ||
218 | m_scene.RequestModuleInterface<IRegionSerialiserModule>(), | ||
219 | m_scene, | ||
220 | archiveWriter, | ||
221 | m_requestId, | ||
222 | options); | ||
223 | |||
224 | m_log.InfoFormat("[ARCHIVER]: Creating archive file. This may take some time."); | ||
225 | |||
226 | // Write out control file. This has to be done first so that subsequent loaders will see this file first | ||
227 | // XXX: I know this is a weak way of doing it since external non-OAR aware tar executables will not do this | ||
228 | archiveWriter.WriteFile(ArchiveConstants.CONTROL_FILE_PATH, CreateControlFile(options)); | ||
229 | m_log.InfoFormat("[ARCHIVER]: Added control file to archive."); | ||
230 | |||
231 | if (SaveAssets) | ||
232 | { | ||
233 | AssetsRequest ar | ||
234 | = new AssetsRequest( | ||
235 | new AssetsArchiver(archiveWriter), assetUuids, | ||
236 | m_scene.AssetService, m_scene.UserAccountService, | ||
237 | m_scene.RegionInfo.ScopeID, options, awre.ReceivedAllAssets); | ||
238 | |||
239 | Util.FireAndForget(o => ar.Execute()); | ||
240 | } | ||
241 | else | ||
242 | { | ||
243 | awre.ReceivedAllAssets(new List<UUID>(), new List<UUID>()); | ||
244 | } | ||
245 | } | ||
246 | catch (Exception) | ||
247 | { | ||
248 | m_saveStream.Close(); | ||
249 | throw; | ||
250 | } | ||
251 | } | ||
252 | |||
253 | /// <summary> | ||
254 | /// Checks whether the user has permission to export an object group to an OAR. | ||
255 | /// </summary> | ||
256 | /// <param name="user">The user</param> | ||
257 | /// <param name="objGroup">The object group</param> | ||
258 | /// <param name="checkPermissions">Which permissions to check: "C" = Copy, "T" = Transfer</param> | ||
259 | /// <returns>Whether the user is allowed to export the object to an OAR</returns> | ||
260 | private bool CanUserArchiveObject(UUID user, SceneObjectGroup objGroup, string checkPermissions) | ||
261 | { | ||
262 | if (checkPermissions == null) | ||
263 | return true; | ||
264 | |||
265 | IPermissionsModule module = m_scene.RequestModuleInterface<IPermissionsModule>(); | ||
266 | if (module == null) | ||
267 | return true; // this shouldn't happen | ||
268 | |||
269 | // Check whether the user is permitted to export all of the parts in the SOG. If any | ||
270 | // part can't be exported then the entire SOG can't be exported. | ||
271 | |||
272 | bool permitted = true; | ||
273 | //int primNumber = 1; | ||
274 | |||
275 | foreach (SceneObjectPart obj in objGroup.Parts) | ||
276 | { | ||
277 | uint perm; | ||
278 | PermissionClass permissionClass = module.GetPermissionClass(user, obj); | ||
279 | switch (permissionClass) | ||
280 | { | ||
281 | case PermissionClass.Owner: | ||
282 | perm = obj.BaseMask; | ||
283 | break; | ||
284 | case PermissionClass.Group: | ||
285 | perm = obj.GroupMask | obj.EveryoneMask; | ||
286 | break; | ||
287 | case PermissionClass.Everyone: | ||
288 | default: | ||
289 | perm = obj.EveryoneMask; | ||
290 | break; | ||
291 | } | ||
292 | |||
293 | bool canCopy = (perm & (uint)PermissionMask.Copy) != 0; | ||
294 | bool canTransfer = (perm & (uint)PermissionMask.Transfer) != 0; | ||
295 | |||
296 | // Special case: if Everyone can copy the object then this implies it can also be | ||
297 | // Transferred. | ||
298 | // However, if the user is the Owner then we don't check EveryoneMask, because it seems that the mask | ||
299 | // always (incorrectly) includes the Copy bit set in this case. But that's a mistake: the viewer | ||
300 | // does NOT show that the object has Everyone-Copy permissions, and doesn't allow it to be copied. | ||
301 | if (permissionClass != PermissionClass.Owner) | ||
302 | canTransfer |= (obj.EveryoneMask & (uint)PermissionMask.Copy) != 0; | ||
303 | |||
304 | bool partPermitted = true; | ||
305 | if (checkPermissions.Contains("C") && !canCopy) | ||
306 | partPermitted = false; | ||
307 | if (checkPermissions.Contains("T") && !canTransfer) | ||
308 | partPermitted = false; | ||
309 | |||
310 | // If the user is the Creator of the object then it can always be included in the OAR | ||
311 | bool creator = (obj.CreatorID.Guid == user.Guid); | ||
312 | if (creator) | ||
313 | partPermitted = true; | ||
314 | |||
315 | //string name = (objGroup.PrimCount == 1) ? objGroup.Name : string.Format("{0} ({1}/{2})", obj.Name, primNumber, objGroup.PrimCount); | ||
316 | //m_log.DebugFormat("[ARCHIVER]: Object permissions: {0}: Base={1:X4}, Owner={2:X4}, Everyone={3:X4}, permissionClass={4}, checkPermissions={5}, canCopy={6}, canTransfer={7}, creator={8}, permitted={9}", | ||
317 | // name, obj.BaseMask, obj.OwnerMask, obj.EveryoneMask, | ||
318 | // permissionClass, checkPermissions, canCopy, canTransfer, creator, partPermitted); | ||
319 | |||
320 | if (!partPermitted) | ||
321 | { | ||
322 | permitted = false; | ||
323 | break; | ||
324 | } | ||
325 | |||
326 | //++primNumber; | ||
327 | } | ||
328 | |||
329 | return permitted; | ||
330 | } | ||
331 | |||
332 | /// <summary> | ||
333 | /// Create the control file for the most up to date archive | ||
334 | /// </summary> | ||
335 | /// <returns></returns> | ||
336 | public string CreateControlFile(Dictionary<string, object> options) | ||
337 | { | ||
338 | int majorVersion = MAX_MAJOR_VERSION, minorVersion = 8; | ||
339 | // | ||
340 | // if (options.ContainsKey("version")) | ||
341 | // { | ||
342 | // string[] parts = options["version"].ToString().Split('.'); | ||
343 | // if (parts.Length >= 1) | ||
344 | // { | ||
345 | // majorVersion = Int32.Parse(parts[0]); | ||
346 | // | ||
347 | // if (parts.Length >= 2) | ||
348 | // minorVersion = Int32.Parse(parts[1]); | ||
349 | // } | ||
350 | // } | ||
351 | // | ||
352 | // if (majorVersion < MIN_MAJOR_VERSION || majorVersion > MAX_MAJOR_VERSION) | ||
353 | // { | ||
354 | // throw new Exception( | ||
355 | // string.Format( | ||
356 | // "OAR version number for save must be between {0} and {1}", | ||
357 | // MIN_MAJOR_VERSION, MAX_MAJOR_VERSION)); | ||
358 | // } | ||
359 | // else if (majorVersion == MAX_MAJOR_VERSION) | ||
360 | // { | ||
361 | // // Force 1.0 | ||
362 | // minorVersion = 0; | ||
363 | // } | ||
364 | // else if (majorVersion == MIN_MAJOR_VERSION) | ||
365 | // { | ||
366 | // // Force 0.4 | ||
367 | // minorVersion = 4; | ||
368 | // } | ||
369 | |||
370 | m_log.InfoFormat("[ARCHIVER]: Creating version {0}.{1} OAR", majorVersion, minorVersion); | ||
371 | //if (majorVersion == 1) | ||
372 | //{ | ||
373 | // m_log.WarnFormat("[ARCHIVER]: Please be aware that version 1.0 OARs are not compatible with OpenSim 0.7.0.2 and earlier. Please use the --version=0 option if you want to produce a compatible OAR"); | ||
374 | //} | ||
375 | |||
376 | String s; | ||
377 | |||
378 | using (StringWriter sw = new StringWriter()) | ||
379 | { | ||
380 | using (XmlTextWriter xtw = new XmlTextWriter(sw)) | ||
381 | { | ||
382 | xtw.Formatting = Formatting.Indented; | ||
383 | xtw.WriteStartDocument(); | ||
384 | xtw.WriteStartElement("archive"); | ||
385 | xtw.WriteAttributeString("major_version", majorVersion.ToString()); | ||
386 | xtw.WriteAttributeString("minor_version", minorVersion.ToString()); | ||
387 | |||
388 | xtw.WriteStartElement("creation_info"); | ||
389 | DateTime now = DateTime.UtcNow; | ||
390 | TimeSpan t = now - new DateTime(1970, 1, 1); | ||
391 | xtw.WriteElementString("datetime", ((int)t.TotalSeconds).ToString()); | ||
392 | xtw.WriteElementString("id", UUID.Random().ToString()); | ||
393 | xtw.WriteEndElement(); | ||
394 | |||
395 | xtw.WriteStartElement("region_info"); | ||
396 | |||
397 | bool isMegaregion; | ||
398 | Vector2 size; | ||
399 | IRegionCombinerModule rcMod = null; | ||
400 | |||
401 | // FIXME: This is only here for regression test purposes since they do not supply a module. Need to fix | ||
402 | // this, possibly by doing control file creation somewhere else. | ||
403 | if (m_module != null) | ||
404 | rcMod = m_module.RegionCombinerModule; | ||
405 | |||
406 | if (rcMod != null) | ||
407 | isMegaregion = rcMod.IsRootForMegaregion(m_scene.RegionInfo.RegionID); | ||
408 | else | ||
409 | isMegaregion = false; | ||
410 | |||
411 | if (isMegaregion) | ||
412 | size = rcMod.GetSizeOfMegaregion(m_scene.RegionInfo.RegionID); | ||
413 | else | ||
414 | size = new Vector2((float)Constants.RegionSize, (float)Constants.RegionSize); | ||
415 | |||
416 | xtw.WriteElementString("is_megaregion", isMegaregion.ToString()); | ||
417 | xtw.WriteElementString("size_in_meters", string.Format("{0},{1}", size.X, size.Y)); | ||
418 | |||
419 | xtw.WriteEndElement(); | ||
420 | |||
421 | xtw.WriteElementString("assets_included", SaveAssets.ToString()); | ||
422 | |||
423 | xtw.WriteEndElement(); | ||
424 | |||
425 | xtw.Flush(); | ||
426 | } | ||
427 | |||
428 | s = sw.ToString(); | ||
429 | } | ||
430 | |||
431 | // if (m_scene != null) | ||
432 | // Console.WriteLine( | ||
433 | // "[ARCHIVE WRITE REQUEST PREPARATION]: Control file for {0} is: {1}", m_scene.RegionInfo.RegionName, s); | ||
434 | |||
435 | return s; | ||
436 | } | ||
437 | } | ||
438 | } | ||