MapImageServiceModule.cs 12 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313
  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. using System;
  28. using System.Collections.Generic;
  29. using System.Reflection;
  30. using System.Net;
  31. using System.IO;
  32. using System.Timers;
  33. using System.Drawing;
  34. using System.Drawing.Imaging;
  35. using log4net;
  36. using Mono.Addins;
  37. using Nini.Config;
  38. using OpenSim.Framework;
  39. using OpenSim.Region.Framework.Interfaces;
  40. using OpenSim.Region.Framework.Scenes;
  41. using OpenSim.Services.Interfaces;
  42. using OpenSim.Server.Base;
  43. using OpenMetaverse;
  44. using OpenMetaverse.StructuredData;
  45. namespace OpenSim.Region.CoreModules.ServiceConnectorsOut.MapImage
  46. {
  47. /// <summary>
  48. /// </summary>
  49. /// <remarks>
  50. /// </remarks>
  51. [Extension(Path = "/OpenSim/RegionModules", NodeName = "RegionModule", Id = "MapImageServiceModule")]
  52. public class MapImageServiceModule : IMapImageUploadModule, ISharedRegionModule
  53. {
  54. private static readonly ILog m_log =
  55. LogManager.GetLogger(MethodBase.GetCurrentMethod().DeclaringType);
  56. private static string LogHeader = "[MAP IMAGE SERVICE MODULE]:";
  57. private bool m_enabled = false;
  58. private IMapImageService m_MapService;
  59. private Dictionary<UUID, Scene> m_scenes = new Dictionary<UUID, Scene>();
  60. private int m_refreshtime = 0;
  61. private int m_lastrefresh = 0;
  62. private System.Timers.Timer m_refreshTimer;
  63. #region ISharedRegionModule
  64. public Type ReplaceableInterface { get { return null; } }
  65. public string Name { get { return "MapImageServiceModule"; } }
  66. public void RegionLoaded(Scene scene) { }
  67. public void Close() { }
  68. public void PostInitialise() { }
  69. ///<summary>
  70. ///
  71. ///</summary>
  72. public void Initialise(IConfigSource source)
  73. {
  74. IConfig moduleConfig = source.Configs["Modules"];
  75. if (moduleConfig != null)
  76. {
  77. string name = moduleConfig.GetString("MapImageService", "");
  78. if (name != Name)
  79. return;
  80. }
  81. IConfig config = source.Configs["MapImageService"];
  82. if (config == null)
  83. return;
  84. int refreshminutes = Convert.ToInt32(config.GetString("RefreshTime"));
  85. if (refreshminutes < 0)
  86. {
  87. m_log.WarnFormat("[MAP IMAGE SERVICE MODULE]: Negative refresh time given in config. Module disabled.");
  88. return;
  89. }
  90. string service = config.GetString("LocalServiceModule", string.Empty);
  91. if (service == string.Empty)
  92. {
  93. m_log.WarnFormat("[MAP IMAGE SERVICE MODULE]: No service dll given in config. Unable to proceed.");
  94. return;
  95. }
  96. Object[] args = new Object[] { source };
  97. m_MapService = ServerUtils.LoadPlugin<IMapImageService>(service, args);
  98. if (m_MapService == null)
  99. {
  100. m_log.WarnFormat("[MAP IMAGE SERVICE MODULE]: Unable to load LocalServiceModule from {0}. MapService module disabled. Please fix the configuration.", service);
  101. return;
  102. }
  103. // we don't want the timer if the interval is zero, but we still want this module enables
  104. if(refreshminutes > 0)
  105. {
  106. m_refreshtime = refreshminutes * 60 * 1000; // convert from minutes to ms
  107. m_refreshTimer = new System.Timers.Timer();
  108. m_refreshTimer.Enabled = true;
  109. m_refreshTimer.AutoReset = true;
  110. m_refreshTimer.Interval = m_refreshtime;
  111. m_refreshTimer.Elapsed += new ElapsedEventHandler(HandleMaptileRefresh);
  112. m_log.InfoFormat("[MAP IMAGE SERVICE MODULE]: enabled with refresh time {0} min and service object {1}",
  113. refreshminutes, service);
  114. }
  115. else
  116. {
  117. m_log.InfoFormat("[MAP IMAGE SERVICE MODULE]: enabled with no refresh and service object {0}", service);
  118. }
  119. m_enabled = true;
  120. }
  121. ///<summary>
  122. ///
  123. ///</summary>
  124. public void AddRegion(Scene scene)
  125. {
  126. if (!m_enabled)
  127. return;
  128. // Every shared region module has to maintain an indepedent list of
  129. // currently running regions
  130. lock (m_scenes)
  131. m_scenes[scene.RegionInfo.RegionID] = scene;
  132. // v2 Map generation on startup is now handled by scene to allow bmp to be shared with
  133. // v1 service and not generate map tiles twice as was previous behavior
  134. //scene.EventManager.OnRegionReadyStatusChange += s => { if (s.Ready) UploadMapTile(s); };
  135. scene.RegisterModuleInterface<IMapImageUploadModule>(this);
  136. }
  137. ///<summary>
  138. ///
  139. ///</summary>
  140. public void RemoveRegion(Scene scene)
  141. {
  142. if (! m_enabled)
  143. return;
  144. lock (m_scenes)
  145. m_scenes.Remove(scene.RegionInfo.RegionID);
  146. }
  147. #endregion ISharedRegionModule
  148. ///<summary>
  149. ///
  150. ///</summary>
  151. private void HandleMaptileRefresh(object sender, EventArgs ea)
  152. {
  153. // this approach is a bit convoluted becase we want to wait for the
  154. // first upload to happen on startup but after all the objects are
  155. // loaded and initialized
  156. if (m_lastrefresh > 0 && Util.EnvironmentTickCountSubtract(m_lastrefresh) < m_refreshtime)
  157. return;
  158. m_log.DebugFormat("[MAP IMAGE SERVICE MODULE]: map refresh!");
  159. lock (m_scenes)
  160. {
  161. foreach (IScene scene in m_scenes.Values)
  162. {
  163. try
  164. {
  165. UploadMapTile(scene);
  166. }
  167. catch (Exception ex)
  168. {
  169. m_log.WarnFormat("[MAP IMAGE SERVICE MODULE]: something bad happened {0}", ex.Message);
  170. }
  171. }
  172. }
  173. m_lastrefresh = Util.EnvironmentTickCount();
  174. }
  175. public void UploadMapTile(IScene scene, Bitmap mapTile)
  176. {
  177. if (mapTile == null)
  178. {
  179. m_log.WarnFormat("{0} Cannot upload null image", LogHeader);
  180. return;
  181. }
  182. // mapTile.Save( // DEBUG DEBUG
  183. // String.Format("maptiles/raw-{0}-{1}-{2}.jpg", regionName, scene.RegionInfo.RegionLocX, scene.RegionInfo.RegionLocY),
  184. // ImageFormat.Jpeg);
  185. // If the region/maptile is legacy sized, just upload the one tile like it has always been done
  186. if (mapTile.Width == Constants.RegionSize && mapTile.Height == Constants.RegionSize)
  187. {
  188. m_log.DebugFormat("{0} Upload maptile for {1}", LogHeader, scene.Name);
  189. ConvertAndUploadMaptile(scene, mapTile,
  190. scene.RegionInfo.RegionLocX, scene.RegionInfo.RegionLocY,
  191. scene.RegionInfo.RegionName);
  192. }
  193. else
  194. {
  195. m_log.DebugFormat("{0} Upload {1} maptiles for {2}", LogHeader,
  196. (mapTile.Width * mapTile.Height) / (Constants.RegionSize * Constants.RegionSize),
  197. scene.Name);
  198. // For larger regions (varregion) we must cut the region image into legacy sized
  199. // pieces since that is how the maptile system works.
  200. // Note the assumption that varregions are always a multiple of legacy size.
  201. for (uint xx = 0; xx < mapTile.Width; xx += Constants.RegionSize)
  202. {
  203. for (uint yy = 0; yy < mapTile.Height; yy += Constants.RegionSize)
  204. {
  205. // Images are addressed from the upper left corner so have to do funny
  206. // math to pick out the sub-tile since regions are numbered from
  207. // the lower left.
  208. Rectangle rect = new Rectangle(
  209. (int)xx,
  210. mapTile.Height - (int)yy - (int)Constants.RegionSize,
  211. (int)Constants.RegionSize, (int)Constants.RegionSize);
  212. using (Bitmap subMapTile = mapTile.Clone(rect, mapTile.PixelFormat))
  213. {
  214. if(!ConvertAndUploadMaptile(scene, subMapTile,
  215. scene.RegionInfo.RegionLocX + (xx / Constants.RegionSize),
  216. scene.RegionInfo.RegionLocY + (yy / Constants.RegionSize),
  217. scene.Name))
  218. {
  219. m_log.DebugFormat("{0} Upload maptileS for {1} aborted!", LogHeader, scene.Name);
  220. return; // abort rest;
  221. }
  222. }
  223. }
  224. }
  225. }
  226. }
  227. ///<summary>
  228. ///
  229. ///</summary>
  230. public void UploadMapTile(IScene scene)
  231. {
  232. m_log.DebugFormat("{0}: upload maptile for {1}", LogHeader, scene.RegionInfo.RegionName);
  233. // Create a JPG map tile and upload it to the AddMapTile API
  234. IMapImageGenerator tileGenerator = scene.RequestModuleInterface<IMapImageGenerator>();
  235. if (tileGenerator == null)
  236. {
  237. m_log.WarnFormat("{0} Cannot upload map tile without an ImageGenerator", LogHeader);
  238. return;
  239. }
  240. using (Bitmap mapTile = tileGenerator.CreateMapTile())
  241. {
  242. // XXX: The MapImageModule will return a null if the user has chosen not to create map tiles and there
  243. // is no static map tile.
  244. if (mapTile == null)
  245. return;
  246. UploadMapTile(scene, mapTile);
  247. }
  248. }
  249. private bool ConvertAndUploadMaptile(IScene scene, Image tileImage, uint locX, uint locY, string regionName)
  250. {
  251. byte[] jpgData = Utils.EmptyBytes;
  252. using (MemoryStream stream = new MemoryStream())
  253. {
  254. tileImage.Save(stream, ImageFormat.Jpeg);
  255. jpgData = stream.ToArray();
  256. }
  257. if (jpgData == Utils.EmptyBytes)
  258. {
  259. m_log.WarnFormat("{0} Tile image generation failed for region {1}", LogHeader, regionName);
  260. return false;
  261. }
  262. string reason = string.Empty;
  263. if (!m_MapService.AddMapTile((int)locX, (int)locY, jpgData, scene.RegionInfo.ScopeID, out reason))
  264. {
  265. m_log.DebugFormat("{0} Unable to upload tile image for {1} at {2}-{3}: {4}", LogHeader,
  266. regionName, locX, locY, reason);
  267. return false;
  268. }
  269. return true;
  270. }
  271. }
  272. }