aboutsummaryrefslogtreecommitdiffstatshomepage
path: root/OpenSim/Services/HypergridService
diff options
context:
space:
mode:
authorDiva Canto2010-01-24 14:30:48 -0800
committerDiva Canto2010-01-24 14:30:48 -0800
commit48b03c2c61a422c3ac9843892a2ae93b29a9f7b8 (patch)
treece3aae8c5bb0ee0c1748e4355cd616ea84b5b344 /OpenSim/Services/HypergridService
parentChange a member of the friendslist module to better reflect the client side (diff)
downloadopensim-SC_OLD-48b03c2c61a422c3ac9843892a2ae93b29a9f7b8.zip
opensim-SC_OLD-48b03c2c61a422c3ac9843892a2ae93b29a9f7b8.tar.gz
opensim-SC_OLD-48b03c2c61a422c3ac9843892a2ae93b29a9f7b8.tar.bz2
opensim-SC_OLD-48b03c2c61a422c3ac9843892a2ae93b29a9f7b8.tar.xz
Integrated the hyperlinking with the GridService.
Diffstat (limited to 'OpenSim/Services/HypergridService')
-rw-r--r--OpenSim/Services/HypergridService/HGCommands.cs318
-rw-r--r--OpenSim/Services/HypergridService/HypergridService.cs417
-rw-r--r--OpenSim/Services/HypergridService/HypergridServiceBase.cs84
3 files changed, 0 insertions, 819 deletions
diff --git a/OpenSim/Services/HypergridService/HGCommands.cs b/OpenSim/Services/HypergridService/HGCommands.cs
deleted file mode 100644
index 78ba46d..0000000
--- a/OpenSim/Services/HypergridService/HGCommands.cs
+++ /dev/null
@@ -1,318 +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
28using System;
29using System.Collections.Generic;
30using System.Reflection;
31using System.Xml;
32using log4net;
33using Nini.Config;
34using OpenSim.Framework;
35//using OpenSim.Framework.Communications;
36using OpenSim.Framework.Console;
37using OpenSim.Services.Interfaces;
38using GridRegion = OpenSim.Services.Interfaces.GridRegion;
39
40namespace OpenSim.Services.HypergridService
41{
42 public class HGCommands
43 {
44 private static readonly ILog m_log = LogManager.GetLogger(MethodBase.GetCurrentMethod().DeclaringType);
45 private HypergridService m_HypergridService;
46
47 private static uint m_autoMappingX = 0;
48 private static uint m_autoMappingY = 0;
49 private static bool m_enableAutoMapping = false;
50
51 public HGCommands(HypergridService service)
52 {
53 m_HypergridService = service;
54 }
55
56 public void HandleShow(string module, string[] cmd)
57 {
58 if (cmd.Length != 2)
59 {
60 MainConsole.Instance.Output("Syntax: show hyperlinks");
61 return;
62 }
63 List<GridRegion> regions = new List<GridRegion>(m_HypergridService.m_HyperlinkRegions.Values);
64 if (regions == null || regions.Count < 1)
65 {
66 MainConsole.Instance.Output("No hyperlinks");
67 return;
68 }
69
70 MainConsole.Instance.Output("Region Name Region UUID");
71 MainConsole.Instance.Output("Location URI");
72 MainConsole.Instance.Output("Owner ID ");
73 MainConsole.Instance.Output("-------------------------------------------------------------------------------");
74 foreach (GridRegion r in regions)
75 {
76 MainConsole.Instance.Output(String.Format("{0,-20} {1}\n{2,-20} {3}\n{4,-39} \n\n",
77 r.RegionName, r.RegionID,
78 String.Format("{0},{1}", r.RegionLocX, r.RegionLocY), "http://" + r.ExternalHostName + ":" + r.HttpPort.ToString(),
79 r.EstateOwner.ToString()));
80 }
81 return;
82 }
83 public void RunCommand(string module, string[] cmdparams)
84 {
85 List<string> args = new List<string>(cmdparams);
86 if (args.Count < 1)
87 return;
88
89 string command = args[0];
90 args.RemoveAt(0);
91
92 cmdparams = args.ToArray();
93
94 RunHGCommand(command, cmdparams);
95
96 }
97
98 private void RunHGCommand(string command, string[] cmdparams)
99 {
100 if (command.Equals("link-mapping"))
101 {
102 if (cmdparams.Length == 2)
103 {
104 try
105 {
106 m_autoMappingX = Convert.ToUInt32(cmdparams[0]);
107 m_autoMappingY = Convert.ToUInt32(cmdparams[1]);
108 m_enableAutoMapping = true;
109 }
110 catch (Exception)
111 {
112 m_autoMappingX = 0;
113 m_autoMappingY = 0;
114 m_enableAutoMapping = false;
115 }
116 }
117 }
118 else if (command.Equals("link-region"))
119 {
120 if (cmdparams.Length < 3)
121 {
122 if ((cmdparams.Length == 1) || (cmdparams.Length == 2))
123 {
124 LoadXmlLinkFile(cmdparams);
125 }
126 else
127 {
128 LinkRegionCmdUsage();
129 }
130 return;
131 }
132
133 if (cmdparams[2].Contains(":"))
134 {
135 // New format
136 int xloc, yloc;
137 string mapName;
138 try
139 {
140 xloc = Convert.ToInt32(cmdparams[0]);
141 yloc = Convert.ToInt32(cmdparams[1]);
142 mapName = cmdparams[2];
143 if (cmdparams.Length > 3)
144 for (int i = 3; i < cmdparams.Length; i++)
145 mapName += " " + cmdparams[i];
146
147 //m_log.Info(">> MapName: " + mapName);
148 }
149 catch (Exception e)
150 {
151 MainConsole.Instance.Output("[HGrid] Wrong format for link-region command: " + e.Message);
152 LinkRegionCmdUsage();
153 return;
154 }
155
156 // Convert cell coordinates given by the user to meters
157 xloc = xloc * (int)Constants.RegionSize;
158 yloc = yloc * (int)Constants.RegionSize;
159 string reason = string.Empty;
160 if (m_HypergridService.TryLinkRegionToCoords(mapName, xloc, yloc, out reason) == null)
161 MainConsole.Instance.Output("Failed to link region: " + reason);
162 MainConsole.Instance.Output("Hyperlink estalished");
163 }
164 else
165 {
166 // old format
167 GridRegion regInfo;
168 int xloc, yloc;
169 uint externalPort;
170 string externalHostName;
171 try
172 {
173 xloc = Convert.ToInt32(cmdparams[0]);
174 yloc = Convert.ToInt32(cmdparams[1]);
175 externalPort = Convert.ToUInt32(cmdparams[3]);
176 externalHostName = cmdparams[2];
177 //internalPort = Convert.ToUInt32(cmdparams[4]);
178 //remotingPort = Convert.ToUInt32(cmdparams[5]);
179 }
180 catch (Exception e)
181 {
182 MainConsole.Instance.Output("[HGrid] Wrong format for link-region command: " + e.Message);
183 LinkRegionCmdUsage();
184 return;
185 }
186
187 // Convert cell coordinates given by the user to meters
188 xloc = xloc * (int)Constants.RegionSize;
189 yloc = yloc * (int)Constants.RegionSize;
190 string reason = string.Empty;
191 if (m_HypergridService.TryCreateLink(xloc, yloc, "", externalPort, externalHostName, out regInfo, out reason))
192 {
193 if (cmdparams.Length >= 5)
194 {
195 regInfo.RegionName = "";
196 for (int i = 4; i < cmdparams.Length; i++)
197 regInfo.RegionName += cmdparams[i] + " ";
198 }
199 }
200 }
201 return;
202 }
203 else if (command.Equals("unlink-region"))
204 {
205 if (cmdparams.Length < 1)
206 {
207 UnlinkRegionCmdUsage();
208 return;
209 }
210 if (m_HypergridService.TryUnlinkRegion(cmdparams[0]))
211 MainConsole.Instance.Output("Successfully unlinked " + cmdparams[0]);
212 else
213 MainConsole.Instance.Output("Unable to unlink " + cmdparams[0] + ", region not found.");
214 }
215 }
216
217 private void LoadXmlLinkFile(string[] cmdparams)
218 {
219 //use http://www.hgurl.com/hypergrid.xml for test
220 try
221 {
222 XmlReader r = XmlReader.Create(cmdparams[0]);
223 XmlConfigSource cs = new XmlConfigSource(r);
224 string[] excludeSections = null;
225
226 if (cmdparams.Length == 2)
227 {
228 if (cmdparams[1].ToLower().StartsWith("excludelist:"))
229 {
230 string excludeString = cmdparams[1].ToLower();
231 excludeString = excludeString.Remove(0, 12);
232 char[] splitter = { ';' };
233
234 excludeSections = excludeString.Split(splitter);
235 }
236 }
237
238 for (int i = 0; i < cs.Configs.Count; i++)
239 {
240 bool skip = false;
241 if ((excludeSections != null) && (excludeSections.Length > 0))
242 {
243 for (int n = 0; n < excludeSections.Length; n++)
244 {
245 if (excludeSections[n] == cs.Configs[i].Name.ToLower())
246 {
247 skip = true;
248 break;
249 }
250 }
251 }
252 if (!skip)
253 {
254 ReadLinkFromConfig(cs.Configs[i]);
255 }
256 }
257 }
258 catch (Exception e)
259 {
260 m_log.Error(e.ToString());
261 }
262 }
263
264
265 private void ReadLinkFromConfig(IConfig config)
266 {
267 GridRegion regInfo;
268 int xloc, yloc;
269 uint externalPort;
270 string externalHostName;
271 uint realXLoc, realYLoc;
272
273 xloc = Convert.ToInt32(config.GetString("xloc", "0"));
274 yloc = Convert.ToInt32(config.GetString("yloc", "0"));
275 externalPort = Convert.ToUInt32(config.GetString("externalPort", "0"));
276 externalHostName = config.GetString("externalHostName", "");
277 realXLoc = Convert.ToUInt32(config.GetString("real-xloc", "0"));
278 realYLoc = Convert.ToUInt32(config.GetString("real-yloc", "0"));
279
280 if (m_enableAutoMapping)
281 {
282 xloc = (int)((xloc % 100) + m_autoMappingX);
283 yloc = (int)((yloc % 100) + m_autoMappingY);
284 }
285
286 if (((realXLoc == 0) && (realYLoc == 0)) ||
287 (((realXLoc - xloc < 3896) || (xloc - realXLoc < 3896)) &&
288 ((realYLoc - yloc < 3896) || (yloc - realYLoc < 3896))))
289 {
290 xloc = xloc * (int)Constants.RegionSize;
291 yloc = yloc * (int)Constants.RegionSize;
292 string reason = string.Empty;
293 if (m_HypergridService.TryCreateLink(xloc, yloc, "", externalPort,
294 externalHostName, out regInfo, out reason))
295 {
296 regInfo.RegionName = config.GetString("localName", "");
297 }
298 else
299 MainConsole.Instance.Output("Unable to link " + externalHostName + ": " + reason);
300 }
301 }
302
303
304 private void LinkRegionCmdUsage()
305 {
306 MainConsole.Instance.Output("Usage: link-region <Xloc> <Yloc> <HostName>:<HttpPort>[:<RemoteRegionName>]");
307 MainConsole.Instance.Output("Usage: link-region <Xloc> <Yloc> <HostName> <HttpPort> [<LocalName>]");
308 MainConsole.Instance.Output("Usage: link-region <URI_of_xml> [<exclude>]");
309 }
310
311 private void UnlinkRegionCmdUsage()
312 {
313 MainConsole.Instance.Output("Usage: unlink-region <HostName>:<HttpPort>");
314 MainConsole.Instance.Output("Usage: unlink-region <LocalName>");
315 }
316
317 }
318}
diff --git a/OpenSim/Services/HypergridService/HypergridService.cs b/OpenSim/Services/HypergridService/HypergridService.cs
deleted file mode 100644
index ac0f5ac..0000000
--- a/OpenSim/Services/HypergridService/HypergridService.cs
+++ /dev/null
@@ -1,417 +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
28using System;
29using System.Collections.Generic;
30using System.Net;
31using System.Reflection;
32using Nini.Config;
33using log4net;
34using OpenSim.Framework;
35using OpenSim.Framework.Console;
36using OpenSim.Data;
37using OpenSim.Server.Base;
38using OpenSim.Services.Interfaces;
39using OpenSim.Services.Connectors.Hypergrid;
40using GridRegion = OpenSim.Services.Interfaces.GridRegion;
41using OpenMetaverse;
42
43namespace OpenSim.Services.HypergridService
44{
45 public class HypergridService : HypergridServiceBase, IHypergridService
46 {
47 private static readonly ILog m_log =
48 LogManager.GetLogger(
49 MethodBase.GetCurrentMethod().DeclaringType);
50
51 private static HypergridService m_RootInstance = null;
52 protected IConfigSource m_config;
53
54 protected IPresenceService m_PresenceService = null;
55 protected IGridService m_GridService;
56 protected IAssetService m_AssetService;
57 protected HypergridServiceConnector m_HypergridConnector;
58
59 protected bool m_AllowDuplicateNames = false;
60 protected UUID m_ScopeID = UUID.Zero;
61
62 // Hyperlink regions are hyperlinks on the map
63 public readonly Dictionary<UUID, GridRegion> m_HyperlinkRegions = new Dictionary<UUID, GridRegion>();
64 protected Dictionary<UUID, ulong> m_HyperlinkHandles = new Dictionary<UUID, ulong>();
65
66 protected GridRegion m_DefaultRegion;
67 protected GridRegion DefaultRegion
68 {
69 get
70 {
71 if (m_DefaultRegion == null)
72 {
73 List<GridRegion> defs = m_GridService.GetDefaultRegions(m_ScopeID);
74 if (defs != null && defs.Count > 0)
75 m_DefaultRegion = defs[0];
76 else
77 {
78 // Best guess, may be totally off
79 m_DefaultRegion = new GridRegion(1000, 1000);
80 m_log.WarnFormat("[HYPERGRID SERVICE]: This grid does not have a default region. Assuming default coordinates at 1000, 1000.");
81 }
82 }
83 return m_DefaultRegion;
84 }
85 }
86
87 public HypergridService(IConfigSource config)
88 : base(config)
89 {
90 m_log.DebugFormat("[HYPERGRID SERVICE]: Starting...");
91
92 m_config = config;
93 IConfig gridConfig = config.Configs["HypergridService"];
94 if (gridConfig != null)
95 {
96 string gridService = gridConfig.GetString("GridService", string.Empty);
97 string presenceService = gridConfig.GetString("PresenceService", String.Empty);
98 string assetService = gridConfig.GetString("AssetService", string.Empty);
99
100 Object[] args = new Object[] { config };
101 if (gridService != string.Empty)
102 m_GridService = ServerUtils.LoadPlugin<IGridService>(gridService, args);
103
104 if (m_GridService == null)
105 throw new Exception("HypergridService cannot function without a GridService");
106
107 if (presenceService != String.Empty)
108 m_PresenceService = ServerUtils.LoadPlugin<IPresenceService>(presenceService, args);
109
110 if (assetService != string.Empty)
111 m_AssetService = ServerUtils.LoadPlugin<IAssetService>(assetService, args);
112
113 m_AllowDuplicateNames = gridConfig.GetBoolean("AllowDuplicateNames", m_AllowDuplicateNames);
114
115 string scope = gridConfig.GetString("ScopeID", string.Empty);
116 if (scope != string.Empty)
117 UUID.TryParse(scope, out m_ScopeID);
118
119 m_HypergridConnector = new HypergridServiceConnector(m_AssetService);
120
121 m_log.DebugFormat("[HYPERGRID SERVICE]: Loaded all services...");
122 }
123
124 if (m_RootInstance == null)
125 {
126 m_RootInstance = this;
127
128 HGCommands hgCommands = new HGCommands(this);
129 MainConsole.Instance.Commands.AddCommand("hypergrid", false, "link-region",
130 "link-region <Xloc> <Yloc> <HostName>:<HttpPort>[:<RemoteRegionName>] <cr>",
131 "Link a hypergrid region", hgCommands.RunCommand);
132 MainConsole.Instance.Commands.AddCommand("hypergrid", false, "unlink-region",
133 "unlink-region <local name> or <HostName>:<HttpPort> <cr>",
134 "Unlink a hypergrid region", hgCommands.RunCommand);
135 MainConsole.Instance.Commands.AddCommand("hypergrid", false, "link-mapping", "link-mapping [<x> <y>] <cr>",
136 "Set local coordinate to map HG regions to", hgCommands.RunCommand);
137 MainConsole.Instance.Commands.AddCommand("hypergrid", false, "show hyperlinks", "show hyperlinks <cr>",
138 "List the HG regions", hgCommands.HandleShow);
139 }
140 }
141
142 #region Link Region
143
144 public bool LinkRegion(string regionDescriptor, out UUID regionID, out ulong regionHandle, out string imageURL, out string reason)
145 {
146 regionID = UUID.Zero;
147 imageURL = string.Empty;
148 regionHandle = 0;
149 reason = string.Empty;
150 int xloc = random.Next(0, Int16.MaxValue) * (int)Constants.RegionSize;
151 GridRegion region = TryLinkRegionToCoords(regionDescriptor, xloc, 0, out reason);
152 if (region == null)
153 return false;
154
155 regionID = region.RegionID;
156 regionHandle = region.RegionHandle;
157 return true;
158 }
159
160 private static Random random = new Random();
161
162 // From the command line link-region
163 public GridRegion TryLinkRegionToCoords(string mapName, int xloc, int yloc, out string reason)
164 {
165 reason = string.Empty;
166 string host = "127.0.0.1";
167 string portstr;
168 string regionName = "";
169 uint port = 9000;
170 string[] parts = mapName.Split(new char[] { ':' });
171 if (parts.Length >= 1)
172 {
173 host = parts[0];
174 }
175 if (parts.Length >= 2)
176 {
177 portstr = parts[1];
178 //m_log.Debug("-- port = " + portstr);
179 if (!UInt32.TryParse(portstr, out port))
180 regionName = parts[1];
181 }
182 // always take the last one
183 if (parts.Length >= 3)
184 {
185 regionName = parts[2];
186 }
187
188 // Sanity check. Don't ever link to this sim.
189 IPAddress ipaddr = null;
190 try
191 {
192 ipaddr = Util.GetHostFromDNS(host);
193 }
194 catch { }
195
196 GridRegion regInfo;
197 bool success = TryCreateLink(xloc, yloc, regionName, port, host, out regInfo, out reason);
198 if (success)
199 {
200 regInfo.RegionName = mapName;
201 return regInfo;
202 }
203
204 return null;
205 }
206
207
208 // From the command line and the 2 above
209 public bool TryCreateLink(int xloc, int yloc,
210 string externalRegionName, uint externalPort, string externalHostName, out GridRegion regInfo, out string reason)
211 {
212 m_log.DebugFormat("[HYPERGRID SERVICE]: Link to {0}:{1}, in {2}-{3}", externalHostName, externalPort, xloc, yloc);
213
214 reason = string.Empty;
215 regInfo = new GridRegion();
216 regInfo.RegionName = externalRegionName;
217 regInfo.HttpPort = externalPort;
218 regInfo.ExternalHostName = externalHostName;
219 regInfo.RegionLocX = xloc;
220 regInfo.RegionLocY = yloc;
221
222 try
223 {
224 regInfo.InternalEndPoint = new IPEndPoint(IPAddress.Parse("0.0.0.0"), (int)0);
225 }
226 catch (Exception e)
227 {
228 m_log.Warn("[HYPERGRID SERVICE]: Wrong format for link-region: " + e.Message);
229 reason = "Internal error";
230 return false;
231 }
232
233 // Finally, link it
234 ulong handle = 0;
235 UUID regionID = UUID.Zero;
236 string imageURL = string.Empty;
237 if (!m_HypergridConnector.LinkRegion(regInfo, out regionID, out handle, out imageURL, out reason))
238 return false;
239
240 if (regionID != UUID.Zero)
241 {
242 regInfo.RegionID = regionID;
243
244 AddHyperlinkRegion(regInfo, handle);
245 m_log.Info("[HYPERGRID SERVICE]: Successfully linked to region_uuid " + regInfo.RegionID);
246
247 // Try get the map image
248 regInfo.TerrainImage = m_HypergridConnector.GetMapImage(regionID, imageURL);
249 }
250 else
251 {
252 m_log.Warn("[HYPERGRID SERVICE]: Unable to link region");
253 reason = "Remote region could not be found";
254 return false;
255 }
256
257 uint x, y;
258 if (!Check4096(regInfo, out x, out y))
259 {
260 RemoveHyperlinkRegion(regInfo.RegionID);
261 reason = "Region is too far (" + x + ", " + y + ")";
262 m_log.Info("[HYPERGRID SERVICE]: Unable to link, region is too far (" + x + ", " + y + ")");
263 return false;
264 }
265
266 m_log.Debug("[HYPERGRID SERVICE]: link region succeeded");
267 return true;
268 }
269
270 public bool TryUnlinkRegion(string mapName)
271 {
272 GridRegion regInfo = null;
273 if (mapName.Contains(":"))
274 {
275 string host = "127.0.0.1";
276 //string portstr;
277 //string regionName = "";
278 uint port = 9000;
279 string[] parts = mapName.Split(new char[] { ':' });
280 if (parts.Length >= 1)
281 {
282 host = parts[0];
283 }
284
285 foreach (GridRegion r in m_HyperlinkRegions.Values)
286 if (host.Equals(r.ExternalHostName) && (port == r.HttpPort))
287 regInfo = r;
288 }
289 else
290 {
291 foreach (GridRegion r in m_HyperlinkRegions.Values)
292 if (r.RegionName.Equals(mapName))
293 regInfo = r;
294 }
295 if (regInfo != null)
296 {
297 RemoveHyperlinkRegion(regInfo.RegionID);
298 return true;
299 }
300 else
301 {
302 m_log.InfoFormat("[HYPERGRID SERVICE]: Region {0} not found", mapName);
303 return false;
304 }
305 }
306
307 /// <summary>
308 /// Cope with this viewer limitation.
309 /// </summary>
310 /// <param name="regInfo"></param>
311 /// <returns></returns>
312 public bool Check4096(GridRegion regInfo, out uint x, out uint y)
313 {
314 GridRegion defRegion = DefaultRegion;
315
316 ulong realHandle = m_HyperlinkHandles[regInfo.RegionID];
317 uint ux = 0, uy = 0;
318 Utils.LongToUInts(realHandle, out ux, out uy);
319 x = ux / Constants.RegionSize;
320 y = uy / Constants.RegionSize;
321
322 if ((Math.Abs((int)defRegion.RegionLocX - ux) >= 4096 * Constants.RegionSize) ||
323 (Math.Abs((int)defRegion.RegionLocY - uy) >= 4096 * Constants.RegionSize))
324 {
325 return false;
326 }
327 return true;
328 }
329
330 private void AddHyperlinkRegion(GridRegion regionInfo, ulong regionHandle)
331 {
332 m_HyperlinkRegions[regionInfo.RegionID] = regionInfo;
333 m_HyperlinkHandles[regionInfo.RegionID] = regionHandle;
334 }
335
336 private void RemoveHyperlinkRegion(UUID regionID)
337 {
338 // Try the hyperlink collection
339 if (m_HyperlinkRegions.ContainsKey(regionID))
340 {
341 m_HyperlinkRegions.Remove(regionID);
342 m_HyperlinkHandles.Remove(regionID);
343 }
344 }
345
346 #endregion
347
348 #region Get Hyperlinks
349
350 public GridRegion GetHyperlinkRegion(GridRegion gatekeeper, UUID regionID)
351 {
352 if (m_HyperlinkRegions.ContainsKey(regionID))
353 return m_HypergridConnector.GetHyperlinkRegion(gatekeeper, regionID);
354 else
355 return gatekeeper;
356 }
357
358 #endregion
359
360 #region GetRegionBy X
361
362 public GridRegion GetRegionByUUID(UUID regionID)
363 {
364 if (m_HyperlinkRegions.ContainsKey(regionID))
365 return m_HyperlinkRegions[regionID];
366
367 return null;
368 }
369
370 public GridRegion GetRegionByPosition(int x, int y)
371 {
372 foreach (GridRegion r in m_HyperlinkRegions.Values)
373 if (r.RegionLocX == x && r.RegionLocY == y)
374 return r;
375
376 return null;
377 }
378
379 public GridRegion GetRegionByName(string name)
380 {
381 foreach (GridRegion r in m_HyperlinkRegions.Values)
382 if (r.RegionName.ToLower() == name.ToLower())
383 return r;
384
385 return null;
386 }
387
388 public List<GridRegion> GetRegionsByName(string name)
389 {
390 List<GridRegion> regions = new List<GridRegion>();
391
392 foreach (GridRegion r in m_HyperlinkRegions.Values)
393 if ((r.RegionName != null) && r.RegionName.ToLower().StartsWith(name.ToLower()))
394 regions.Add(r);
395
396 return regions;
397
398 }
399
400 public List<GridRegion> GetRegionRange(int xmin, int xmax, int ymin, int ymax)
401 {
402 List<GridRegion> regions = new List<GridRegion>();
403
404 foreach (GridRegion r in m_HyperlinkRegions.Values)
405 if ((r.RegionLocX > xmin) && (r.RegionLocX < xmax) &&
406 (r.RegionLocY > ymin) && (r.RegionLocY < ymax))
407 regions.Add(r);
408
409 return regions;
410 }
411
412 #endregion
413
414
415
416 }
417}
diff --git a/OpenSim/Services/HypergridService/HypergridServiceBase.cs b/OpenSim/Services/HypergridService/HypergridServiceBase.cs
deleted file mode 100644
index 4f91f64..0000000
--- a/OpenSim/Services/HypergridService/HypergridServiceBase.cs
+++ /dev/null
@@ -1,84 +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
28using System;
29using System.Reflection;
30using Nini.Config;
31using OpenSim.Framework;
32using OpenSim.Data;
33using OpenSim.Services.Interfaces;
34using OpenSim.Services.Base;
35
36namespace OpenSim.Services.HypergridService
37{
38 public class HypergridServiceBase : ServiceBase
39 {
40 protected IRegionData m_Database = null;
41
42 public HypergridServiceBase(IConfigSource config)
43 : base(config)
44 {
45 string dllName = String.Empty;
46 string connString = String.Empty;
47 string realm = "TBD";
48
49 //
50 // Try reading the [DatabaseService] section, if it exists
51 //
52 IConfig dbConfig = config.Configs["DatabaseService"];
53 if (dbConfig != null)
54 {
55 if (dllName == String.Empty)
56 dllName = dbConfig.GetString("StorageProvider", String.Empty);
57 if (connString == String.Empty)
58 connString = dbConfig.GetString("ConnectionString", String.Empty);
59 }
60
61 //
62 // [HypergridService] section overrides [DatabaseService], if it exists
63 //
64 IConfig gridConfig = config.Configs["HypergridService"];
65 if (gridConfig != null)
66 {
67 dllName = gridConfig.GetString("StorageProvider", dllName);
68 connString = gridConfig.GetString("ConnectionString", connString);
69 realm = gridConfig.GetString("Realm", realm);
70 }
71
72 ////
73 //// We tried, but this doesn't exist. We can't proceed.
74 ////
75 //if (dllName.Equals(String.Empty))
76 // throw new Exception("No StorageProvider configured");
77
78 //m_Database = LoadPlugin<IRegionData>(dllName, new Object[] { connString, realm });
79 //if (m_Database == null)
80 // throw new Exception("Could not find a storage interface in the given module");
81
82 }
83 }
84}