aboutsummaryrefslogtreecommitdiffstatshomepage
path: root/OpenSim/Grid/GridServer.Modules
diff options
context:
space:
mode:
authorDiva Canto2010-01-10 20:17:37 -0800
committerDiva Canto2010-01-10 20:17:37 -0800
commit5cf6d6fa79dada85bd56530551409809d338b7d2 (patch)
tree24f89393fc9b25f138caed27919800230dafe70d /OpenSim/Grid/GridServer.Modules
parentOpenSim.Region.Communications.* is no more. Thanks to everyone who contribute... (diff)
downloadopensim-SC_OLD-5cf6d6fa79dada85bd56530551409809d338b7d2.zip
opensim-SC_OLD-5cf6d6fa79dada85bd56530551409809d338b7d2.tar.gz
opensim-SC_OLD-5cf6d6fa79dada85bd56530551409809d338b7d2.tar.bz2
opensim-SC_OLD-5cf6d6fa79dada85bd56530551409809d338b7d2.tar.xz
All grid servers deleted, including user server. They served us well.
Diffstat (limited to 'OpenSim/Grid/GridServer.Modules')
-rw-r--r--OpenSim/Grid/GridServer.Modules/GridDBService.cs284
-rw-r--r--OpenSim/Grid/GridServer.Modules/GridMessagingModule.cs164
-rw-r--r--OpenSim/Grid/GridServer.Modules/GridRestModule.cs282
-rw-r--r--OpenSim/Grid/GridServer.Modules/GridServerPlugin.cs176
-rw-r--r--OpenSim/Grid/GridServer.Modules/GridXmlRpcModule.cs900
-rw-r--r--OpenSim/Grid/GridServer.Modules/Resources/GridServer.Modules.addin.xml11
6 files changed, 0 insertions, 1817 deletions
diff --git a/OpenSim/Grid/GridServer.Modules/GridDBService.cs b/OpenSim/Grid/GridServer.Modules/GridDBService.cs
deleted file mode 100644
index fd5a09a..0000000
--- a/OpenSim/Grid/GridServer.Modules/GridDBService.cs
+++ /dev/null
@@ -1,284 +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;
30using System.Collections.Generic;
31using System.IO;
32using System.Reflection;
33using System.Xml;
34using log4net;
35using Nwc.XmlRpc;
36using OpenMetaverse;
37using OpenSim.Data;
38using OpenSim.Framework;
39using OpenSim.Framework.Communications;
40using OpenSim.Framework.Servers;
41
42
43namespace OpenSim.Grid.GridServer.Modules
44{
45 public class GridDBService : IRegionProfileService
46 {
47 private static readonly ILog m_log = LogManager.GetLogger(MethodBase.GetCurrentMethod().DeclaringType);
48
49 private List<IGridDataPlugin> _plugins = new List<IGridDataPlugin>();
50 private List<ILogDataPlugin> _logplugins = new List<ILogDataPlugin>();
51
52 /// <summary>
53 /// Adds a list of grid and log data plugins, as described by
54 /// `provider' and `connect', to `_plugins' and `_logplugins',
55 /// respectively.
56 /// </summary>
57 /// <param name="provider">
58 /// The filename of the inventory server plugin DLL.
59 /// </param>
60 /// <param name="connect">
61 /// The connection string for the storage backend.
62 /// </param>
63 public void AddPlugin(string provider, string connect)
64 {
65 _plugins = DataPluginFactory.LoadDataPlugins<IGridDataPlugin>(provider, connect);
66 _logplugins = DataPluginFactory.LoadDataPlugins<ILogDataPlugin>(provider, connect);
67 }
68
69 public int GetNumberOfPlugins()
70 {
71 return _plugins.Count;
72 }
73
74 /// <summary>
75 /// Logs a piece of information to the database
76 /// </summary>
77 /// <param name="target">What you were operating on (in grid server, this will likely be the region UUIDs)</param>
78 /// <param name="method">Which method is being called?</param>
79 /// <param name="args">What arguments are being passed?</param>
80 /// <param name="priority">How high priority is this? 1 = Max, 6 = Verbose</param>
81 /// <param name="message">The message to log</param>
82 private void logToDB(string target, string method, string args, int priority, string message)
83 {
84 foreach (ILogDataPlugin plugin in _logplugins)
85 {
86 try
87 {
88 plugin.saveLog("Gridserver", target, method, args, priority, message);
89 }
90 catch (Exception)
91 {
92 m_log.Warn("[storage]: Unable to write log via " + plugin.Name);
93 }
94 }
95 }
96
97 /// <summary>
98 /// Returns a region by argument
99 /// </summary>
100 /// <param name="uuid">A UUID key of the region to return</param>
101 /// <returns>A SimProfileData for the region</returns>
102 public RegionProfileData GetRegion(UUID uuid)
103 {
104 foreach (IGridDataPlugin plugin in _plugins)
105 {
106 try
107 {
108 return plugin.GetProfileByUUID(uuid);
109 }
110 catch (Exception e)
111 {
112 m_log.Warn("[storage]: GetRegion - " + e.Message);
113 }
114 }
115 return null;
116 }
117
118 /// <summary>
119 /// Returns a region by argument
120 /// </summary>
121 /// <param name="uuid">A regionHandle of the region to return</param>
122 /// <returns>A SimProfileData for the region</returns>
123 public RegionProfileData GetRegion(ulong handle)
124 {
125 foreach (IGridDataPlugin plugin in _plugins)
126 {
127 try
128 {
129 return plugin.GetProfileByHandle(handle);
130 }
131 catch (Exception ex)
132 {
133 m_log.Debug("[storage]: " + ex.Message);
134 m_log.Warn("[storage]: Unable to find region " + handle.ToString() + " via " + plugin.Name);
135 }
136 }
137 return null;
138 }
139
140 /// <summary>
141 /// Returns a region by argument
142 /// </summary>
143 /// <param name="regionName">A partial regionName of the region to return</param>
144 /// <returns>A SimProfileData for the region</returns>
145 public RegionProfileData GetRegion(string regionName)
146 {
147 foreach (IGridDataPlugin plugin in _plugins)
148 {
149 try
150 {
151 return plugin.GetProfileByString(regionName);
152 }
153 catch
154 {
155 m_log.Warn("[storage]: Unable to find region " + regionName + " via " + plugin.Name);
156 }
157 }
158 return null;
159 }
160
161 public List<RegionProfileData> GetRegions(uint xmin, uint ymin, uint xmax, uint ymax)
162 {
163 List<RegionProfileData> regions = new List<RegionProfileData>();
164
165 foreach (IGridDataPlugin plugin in _plugins)
166 {
167 try
168 {
169 regions.AddRange(plugin.GetProfilesInRange(xmin, ymin, xmax, ymax));
170 }
171 catch
172 {
173 m_log.Warn("[storage]: Unable to query regionblock via " + plugin.Name);
174 }
175 }
176
177 return regions;
178 }
179
180 public List<RegionProfileData> GetRegions(string name, int maxNum)
181 {
182 List<RegionProfileData> regions = new List<RegionProfileData>();
183 foreach (IGridDataPlugin plugin in _plugins)
184 {
185 try
186 {
187 int num = maxNum - regions.Count;
188 List<RegionProfileData> profiles = plugin.GetRegionsByName(name, (uint)num);
189 if (profiles != null) regions.AddRange(profiles);
190 }
191 catch
192 {
193 m_log.Warn("[storage]: Unable to query regionblock via " + plugin.Name);
194 }
195 }
196
197 return regions;
198 }
199
200 public DataResponse AddUpdateRegion(RegionProfileData sim, RegionProfileData existingSim)
201 {
202 DataResponse insertResponse = DataResponse.RESPONSE_ERROR;
203 foreach (IGridDataPlugin plugin in _plugins)
204 {
205 try
206 {
207 if (existingSim == null)
208 {
209 insertResponse = plugin.StoreProfile(sim);
210 }
211 else
212 {
213 insertResponse = plugin.StoreProfile(sim);
214 }
215 }
216 catch (Exception e)
217 {
218 m_log.Warn("[LOGIN END]: " +
219 "Unable to login region " + sim.ToString() + " via " + plugin.Name);
220 m_log.Warn("[LOGIN END]: " + e.ToString());
221 }
222 }
223 return insertResponse;
224 }
225
226 public DataResponse DeleteRegion(string uuid)
227 {
228 DataResponse insertResponse = DataResponse.RESPONSE_ERROR;
229 foreach (IGridDataPlugin plugin in _plugins)
230 {
231 //OpenSim.Data.MySQL.MySQLGridData dbengine = new OpenSim.Data.MySQL.MySQLGridData();
232 try
233 {
234 //Nice are we not using multiple databases?
235 //MySQLGridData mysqldata = (MySQLGridData)(plugin);
236
237 //DataResponse insertResponse = mysqldata.DeleteProfile(TheSim);
238 insertResponse = plugin.DeleteProfile(uuid);
239 }
240 catch (Exception)
241 {
242 m_log.Error("storage Unable to delete region " + uuid + " via " + plugin.Name);
243 //MainLog.Instance.Warn("storage", e.ToString());
244 insertResponse = DataResponse.RESPONSE_ERROR;
245 }
246 }
247 return insertResponse;
248 }
249
250 public string CheckReservations(RegionProfileData theSim, XmlNode authkeynode)
251 {
252 foreach (IGridDataPlugin plugin in _plugins)
253 {
254 try
255 {
256 //Check reservations
257 ReservationData reserveData =
258 plugin.GetReservationAtPoint(theSim.regionLocX, theSim.regionLocY);
259 if ((reserveData != null && reserveData.gridRecvKey == theSim.regionRecvKey) ||
260 (reserveData == null && authkeynode.InnerText != theSim.regionRecvKey))
261 {
262 plugin.StoreProfile(theSim);
263 m_log.Info("[grid]: New sim added to grid (" + theSim.regionName + ")");
264 logToDB(theSim.ToString(), "RestSetSimMethod", String.Empty, 5,
265 "Region successfully updated and connected to grid.");
266 }
267 else
268 {
269 m_log.Warn("[grid]: " +
270 "Unable to update region (RestSetSimMethod): Incorrect reservation auth key.");
271 // Wanted: " + reserveData.gridRecvKey + ", Got: " + theSim.regionRecvKey + ".");
272 return "Unable to update region (RestSetSimMethod): Incorrect auth key.";
273 }
274 }
275 catch (Exception e)
276 {
277 m_log.Warn("[GRID]: GetRegionPlugin Handle " + plugin.Name + " unable to add new sim: " +
278 e.ToString());
279 }
280 }
281 return "OK";
282 }
283 }
284}
diff --git a/OpenSim/Grid/GridServer.Modules/GridMessagingModule.cs b/OpenSim/Grid/GridServer.Modules/GridMessagingModule.cs
deleted file mode 100644
index 796c2e3..0000000
--- a/OpenSim/Grid/GridServer.Modules/GridMessagingModule.cs
+++ /dev/null
@@ -1,164 +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;
30using System.Collections.Generic;
31using System.Net;
32using System.Reflection;
33using System.Text;
34using Nwc.XmlRpc;
35using log4net;
36using OpenSim.Data;
37using OpenSim.Framework.Servers;
38using OpenSim.Framework.Servers.HttpServer;
39using OpenSim.Framework;
40using OpenSim.Grid.Framework;
41
42namespace OpenSim.Grid.GridServer.Modules
43{
44 public class GridMessagingModule : IMessagingServerDiscovery
45 {
46 //private static readonly ILog m_log = LogManager.GetLogger(MethodBase.GetCurrentMethod().DeclaringType);
47
48 protected IRegionProfileService m_gridDBService;
49 protected IGridServiceCore m_gridCore;
50
51 protected GridConfig m_config;
52
53 /// <value>
54 /// Used to notify old regions as to which OpenSim version to upgrade to
55 /// </value>
56 //private string m_opensimVersion;
57
58 protected BaseHttpServer m_httpServer;
59
60 // This is here so that the grid server can hand out MessageServer settings to regions on registration
61 private List<MessageServerInfo> m_messageServers = new List<MessageServerInfo>();
62
63 public GridMessagingModule()
64 {
65 }
66
67 public void Initialise(string opensimVersion, IRegionProfileService gridDBService, IGridServiceCore gridCore, GridConfig config)
68 {
69 //m_opensimVersion = opensimVersion;
70 m_gridDBService = gridDBService;
71 m_gridCore = gridCore;
72 m_config = config;
73
74 m_gridCore.RegisterInterface<IMessagingServerDiscovery>(this);
75
76 RegisterHandlers();
77 }
78
79 public void PostInitialise()
80 {
81
82 }
83
84 public void RegisterHandlers()
85 {
86 //have these in separate method as some servers restart the http server and reregister all the handlers.
87 m_httpServer = m_gridCore.GetHttpServer();
88
89 // Message Server ---> Grid Server
90 m_httpServer.AddXmlRPCHandler("register_messageserver", XmlRPCRegisterMessageServer);
91 m_httpServer.AddXmlRPCHandler("deregister_messageserver", XmlRPCDeRegisterMessageServer);
92 }
93
94 public List<MessageServerInfo> GetMessageServersList()
95 {
96 lock (m_messageServers)
97 {
98 return new List<MessageServerInfo>(m_messageServers);
99 }
100 }
101
102 public XmlRpcResponse XmlRPCRegisterMessageServer(XmlRpcRequest request, IPEndPoint remoteClient)
103 {
104 XmlRpcResponse response = new XmlRpcResponse();
105 Hashtable requestData = (Hashtable)request.Params[0];
106 Hashtable responseData = new Hashtable();
107
108 if (requestData.Contains("uri"))
109 {
110 string URI = (string)requestData["URI"];
111 string sendkey = (string)requestData["sendkey"];
112 string recvkey = (string)requestData["recvkey"];
113 MessageServerInfo m = new MessageServerInfo();
114 m.URI = URI;
115 m.sendkey = sendkey;
116 m.recvkey = recvkey;
117 RegisterMessageServer(m);
118 responseData["responsestring"] = "TRUE";
119 response.Value = responseData;
120 }
121 return response;
122 }
123
124 public XmlRpcResponse XmlRPCDeRegisterMessageServer(XmlRpcRequest request, IPEndPoint remoteClient)
125 {
126 XmlRpcResponse response = new XmlRpcResponse();
127 Hashtable requestData = (Hashtable)request.Params[0];
128 Hashtable responseData = new Hashtable();
129
130 if (requestData.Contains("uri"))
131 {
132 string URI = (string)requestData["uri"];
133 string sendkey = (string)requestData["sendkey"];
134 string recvkey = (string)requestData["recvkey"];
135 MessageServerInfo m = new MessageServerInfo();
136 m.URI = URI;
137 m.sendkey = sendkey;
138 m.recvkey = recvkey;
139 DeRegisterMessageServer(m);
140 responseData["responsestring"] = "TRUE";
141 response.Value = responseData;
142 }
143 return response;
144 }
145
146 public void RegisterMessageServer(MessageServerInfo m)
147 {
148 lock (m_messageServers)
149 {
150 if (!m_messageServers.Contains(m))
151 m_messageServers.Add(m);
152 }
153 }
154
155 public void DeRegisterMessageServer(MessageServerInfo m)
156 {
157 lock (m_messageServers)
158 {
159 if (m_messageServers.Contains(m))
160 m_messageServers.Remove(m);
161 }
162 }
163 }
164}
diff --git a/OpenSim/Grid/GridServer.Modules/GridRestModule.cs b/OpenSim/Grid/GridServer.Modules/GridRestModule.cs
deleted file mode 100644
index e4c19ca..0000000
--- a/OpenSim/Grid/GridServer.Modules/GridRestModule.cs
+++ /dev/null
@@ -1,282 +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;
30using System.Collections.Generic;
31using System.IO;
32using System.Reflection;
33using System.Xml;
34using log4net;
35using OpenMetaverse;
36using OpenSim.Data;
37using OpenSim.Framework;
38using OpenSim.Framework.Communications;
39using OpenSim.Framework.Servers.HttpServer;
40using OpenSim.Grid.Framework;
41
42namespace OpenSim.Grid.GridServer.Modules
43{
44 public class GridRestModule
45 {
46 private static readonly ILog m_log = LogManager.GetLogger(MethodBase.GetCurrentMethod().DeclaringType);
47
48 private GridDBService m_gridDBService;
49 private IGridServiceCore m_gridCore;
50
51 protected GridConfig m_config;
52
53 /// <value>
54 /// Used to notify old regions as to which OpenSim version to upgrade to
55 /// </value>
56 //private string m_opensimVersion;
57
58 protected BaseHttpServer m_httpServer;
59
60 /// <summary>
61 /// Constructor
62 /// </summary>
63 /// <param name="opensimVersion">
64 /// Used to notify old regions as to which OpenSim version to upgrade to
65 /// </param>
66 public GridRestModule()
67 {
68 }
69
70 public void Initialise(string opensimVersion, GridDBService gridDBService, IGridServiceCore gridCore, GridConfig config)
71 {
72 //m_opensimVersion = opensimVersion;
73 m_gridDBService = gridDBService;
74 m_gridCore = gridCore;
75 m_config = config;
76 RegisterHandlers();
77 }
78
79 public void PostInitialise()
80 {
81
82 }
83
84 public void RegisterHandlers()
85 {
86 //have these in separate method as some servers restart the http server and reregister all the handlers.
87 m_httpServer = m_gridCore.GetHttpServer();
88
89 m_httpServer.AddStreamHandler(new RestStreamHandler("GET", "/sims/", RestGetSimMethod));
90 m_httpServer.AddStreamHandler(new RestStreamHandler("POST", "/sims/", RestSetSimMethod));
91
92 m_httpServer.AddStreamHandler(new RestStreamHandler("GET", "/regions/", RestGetRegionMethod));
93 m_httpServer.AddStreamHandler(new RestStreamHandler("POST", "/regions/", RestSetRegionMethod));
94 }
95
96 /// <summary>
97 /// Performs a REST Get Operation
98 /// </summary>
99 /// <param name="request"></param>
100 /// <param name="path"></param>
101 /// <param name="param"></param>
102 /// <param name="httpRequest">HTTP request header object</param>
103 /// <param name="httpResponse">HTTP response header object</param>
104 /// <returns></returns>
105 public string RestGetRegionMethod(string request, string path, string param,
106 OSHttpRequest httpRequest, OSHttpResponse httpResponse)
107 {
108 return RestGetSimMethod(String.Empty, "/sims/", param, httpRequest, httpResponse);
109 }
110
111 /// <summary>
112 /// Performs a REST Set Operation
113 /// </summary>
114 /// <param name="request"></param>
115 /// <param name="path"></param>
116 /// <param name="param"></param>
117 /// <param name="httpRequest">HTTP request header object</param>
118 /// <param name="httpResponse">HTTP response header object</param>
119 /// <returns></returns>
120 public string RestSetRegionMethod(string request, string path, string param,
121 OSHttpRequest httpRequest, OSHttpResponse httpResponse)
122 {
123 return RestSetSimMethod(String.Empty, "/sims/", param, httpRequest, httpResponse);
124 }
125
126 /// <summary>
127 /// Returns information about a sim via a REST Request
128 /// </summary>
129 /// <param name="request"></param>
130 /// <param name="path"></param>
131 /// <param name="param">A string representing the sim's UUID</param>
132 /// <param name="httpRequest">HTTP request header object</param>
133 /// <param name="httpResponse">HTTP response header object</param>
134 /// <returns>Information about the sim in XML</returns>
135 public string RestGetSimMethod(string request, string path, string param,
136 OSHttpRequest httpRequest, OSHttpResponse httpResponse)
137 {
138 string respstring = String.Empty;
139
140 RegionProfileData TheSim;
141
142 UUID UUID;
143 if (UUID.TryParse(param, out UUID))
144 {
145 TheSim = m_gridDBService.GetRegion(UUID);
146
147 if (!(TheSim == null))
148 {
149 respstring = "<Root>";
150 respstring += "<authkey>" + TheSim.regionSendKey + "</authkey>";
151 respstring += "<sim>";
152 respstring += "<uuid>" + TheSim.UUID.ToString() + "</uuid>";
153 respstring += "<regionname>" + TheSim.regionName + "</regionname>";
154 respstring += "<sim_ip>" + TheSim.serverIP + "</sim_ip>";
155 respstring += "<sim_port>" + TheSim.serverPort.ToString() + "</sim_port>";
156 respstring += "<region_locx>" + TheSim.regionLocX.ToString() + "</region_locx>";
157 respstring += "<region_locy>" + TheSim.regionLocY.ToString() + "</region_locy>";
158 respstring += "<estate_id>1</estate_id>";
159 respstring += "</sim>";
160 respstring += "</Root>";
161 }
162 }
163 else
164 {
165 respstring = "<Root>";
166 respstring += "<error>Param must be a UUID</error>";
167 respstring += "</Root>";
168 }
169
170 return respstring;
171 }
172
173 /// <summary>
174 /// Creates or updates a sim via a REST Method Request
175 /// BROKEN with SQL Update
176 /// </summary>
177 /// <param name="request"></param>
178 /// <param name="path"></param>
179 /// <param name="param"></param>
180 /// <param name="httpRequest">HTTP request header object</param>
181 /// <param name="httpResponse">HTTP response header object</param>
182 /// <returns>"OK" or an error</returns>
183 public string RestSetSimMethod(string request, string path, string param,
184 OSHttpRequest httpRequest, OSHttpResponse httpResponse)
185 {
186 m_log.Info("Processing region update via REST method");
187 RegionProfileData theSim;
188 theSim = m_gridDBService.GetRegion(new UUID(param));
189 if (theSim == null)
190 {
191 theSim = new RegionProfileData();
192 UUID UUID = new UUID(param);
193 theSim.UUID = UUID;
194 theSim.regionRecvKey = m_config.SimRecvKey;
195 }
196
197 XmlDocument doc = new XmlDocument();
198 doc.LoadXml(request);
199 XmlNode rootnode = doc.FirstChild;
200 XmlNode authkeynode = rootnode.ChildNodes[0];
201 if (authkeynode.Name != "authkey")
202 {
203 return "ERROR! bad XML - expected authkey tag";
204 }
205
206 XmlNode simnode = rootnode.ChildNodes[1];
207 if (simnode.Name != "sim")
208 {
209 return "ERROR! bad XML - expected sim tag";
210 }
211
212 //theSim.regionSendKey = Cfg;
213 theSim.regionRecvKey = m_config.SimRecvKey;
214 theSim.regionSendKey = m_config.SimSendKey;
215 theSim.regionSecret = m_config.SimRecvKey;
216 theSim.regionDataURI = String.Empty;
217 theSim.regionAssetURI = m_config.DefaultAssetServer;
218 theSim.regionAssetRecvKey = m_config.AssetRecvKey;
219 theSim.regionAssetSendKey = m_config.AssetSendKey;
220 theSim.regionUserURI = m_config.DefaultUserServer;
221 theSim.regionUserSendKey = m_config.UserSendKey;
222 theSim.regionUserRecvKey = m_config.UserRecvKey;
223
224 for (int i = 0; i < simnode.ChildNodes.Count; i++)
225 {
226 switch (simnode.ChildNodes[i].Name)
227 {
228 case "regionname":
229 theSim.regionName = simnode.ChildNodes[i].InnerText;
230 break;
231
232 case "sim_ip":
233 theSim.serverIP = simnode.ChildNodes[i].InnerText;
234 break;
235
236 case "sim_port":
237 theSim.serverPort = Convert.ToUInt32(simnode.ChildNodes[i].InnerText);
238 break;
239
240 case "region_locx":
241 theSim.regionLocX = Convert.ToUInt32((string)simnode.ChildNodes[i].InnerText);
242 theSim.regionHandle = Utils.UIntsToLong((theSim.regionLocX * Constants.RegionSize), (theSim.regionLocY * Constants.RegionSize));
243 break;
244
245 case "region_locy":
246 theSim.regionLocY = Convert.ToUInt32((string)simnode.ChildNodes[i].InnerText);
247 theSim.regionHandle = Utils.UIntsToLong((theSim.regionLocX * Constants.RegionSize), (theSim.regionLocY * Constants.RegionSize));
248 break;
249 }
250 }
251
252 theSim.serverURI = "http://" + theSim.serverIP + ":" + theSim.serverPort + "/";
253 bool requirePublic = false;
254 bool requireValid = true;
255
256 if (requirePublic &&
257 (theSim.serverIP.StartsWith("172.16") || theSim.serverIP.StartsWith("192.168") ||
258 theSim.serverIP.StartsWith("10.") || theSim.serverIP.StartsWith("0.") ||
259 theSim.serverIP.StartsWith("255.")))
260 {
261 return "ERROR! Servers must register with public addresses.";
262 }
263
264 if (requireValid && (theSim.serverIP.StartsWith("0.") || theSim.serverIP.StartsWith("255.")))
265 {
266 return "ERROR! 0.*.*.* / 255.*.*.* Addresses are invalid, please check your server config and try again";
267 }
268
269 try
270 {
271 m_log.Info("[DATA]: " +
272 "Updating / adding via " + m_gridDBService.GetNumberOfPlugins() + " storage provider(s) registered.");
273
274 return m_gridDBService.CheckReservations(theSim, authkeynode);
275 }
276 catch (Exception e)
277 {
278 return "ERROR! Could not save to database! (" + e.ToString() + ")";
279 }
280 }
281 }
282}
diff --git a/OpenSim/Grid/GridServer.Modules/GridServerPlugin.cs b/OpenSim/Grid/GridServer.Modules/GridServerPlugin.cs
deleted file mode 100644
index f1acaf9..0000000
--- a/OpenSim/Grid/GridServer.Modules/GridServerPlugin.cs
+++ /dev/null
@@ -1,176 +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.Text;
32using log4net;
33using OpenSim.Framework;
34using OpenSim.Framework.Console;
35using OpenSim.Grid.Framework;
36using OpenSim.Grid;
37
38namespace OpenSim.Grid.GridServer.Modules
39{
40 public class GridServerPlugin : IGridPlugin
41 {
42 private static readonly ILog m_log = LogManager.GetLogger(MethodBase.GetCurrentMethod().DeclaringType);
43
44 protected GridXmlRpcModule m_gridXmlRpcModule;
45 protected GridMessagingModule m_gridMessageModule;
46 protected GridRestModule m_gridRestModule;
47
48 protected GridDBService m_gridDBService;
49
50 protected string m_version;
51
52 protected GridConfig m_config;
53
54 protected IGridServiceCore m_core;
55
56 protected CommandConsole m_console;
57
58 #region IGridPlugin Members
59
60 public void Initialise(GridServerBase gridServer)
61 {
62 m_core = gridServer;
63 m_config = gridServer.Config;
64 m_version = gridServer.Version;
65 m_console = MainConsole.Instance;
66
67 AddConsoleCommands();
68
69 SetupGridServices();
70 }
71
72 public void PostInitialise()
73 {
74
75 }
76
77 #endregion
78
79 #region IPlugin Members
80
81 public string Version
82 {
83 get { return "0.0"; }
84 }
85
86 public string Name
87 {
88 get { return "GridServerPlugin"; }
89 }
90
91 public void Initialise()
92 {
93 }
94
95 #endregion
96
97 protected virtual void SetupGridServices()
98 {
99 // m_log.Info("[DATA]: Connecting to Storage Server");
100 m_gridDBService = new GridDBService();
101 m_gridDBService.AddPlugin(m_config.DatabaseProvider, m_config.DatabaseConnect);
102
103 //Register the database access service so modules can fetch it
104 // RegisterInterface<GridDBService>(m_gridDBService);
105
106 m_gridMessageModule = new GridMessagingModule();
107 m_gridMessageModule.Initialise(m_version, m_gridDBService, m_core, m_config);
108
109 m_gridXmlRpcModule = new GridXmlRpcModule();
110 m_gridXmlRpcModule.Initialise(m_version, m_gridDBService, m_core, m_config);
111
112 m_gridRestModule = new GridRestModule();
113 m_gridRestModule.Initialise(m_version, m_gridDBService, m_core, m_config);
114
115 m_gridMessageModule.PostInitialise();
116 m_gridXmlRpcModule.PostInitialise();
117 m_gridRestModule.PostInitialise();
118 }
119
120 #region Console Command Handlers
121
122 protected virtual void AddConsoleCommands()
123 {
124 m_console.Commands.AddCommand("gridserver", false,
125 "enable registration",
126 "enable registration",
127 "Enable new regions to register", HandleRegistration);
128
129 m_console.Commands.AddCommand("gridserver", false,
130 "disable registration",
131 "disable registration",
132 "Disable registering new regions", HandleRegistration);
133
134 m_console.Commands.AddCommand("gridserver", false, "show status",
135 "show status",
136 "Show registration status", HandleShowStatus);
137 }
138
139 private void HandleRegistration(string module, string[] cmd)
140 {
141 switch (cmd[0])
142 {
143 case "enable":
144 m_config.AllowRegionRegistration = true;
145 m_log.Info("Region registration enabled");
146 break;
147 case "disable":
148 m_config.AllowRegionRegistration = false;
149 m_log.Info("Region registration disabled");
150 break;
151 }
152 }
153
154 private void HandleShowStatus(string module, string[] cmd)
155 {
156 if (m_config.AllowRegionRegistration)
157 {
158 m_log.Info("Region registration enabled.");
159 }
160 else
161 {
162 m_log.Info("Region registration disabled.");
163 }
164 }
165
166 #endregion
167
168 #region IDisposable Members
169
170 public void Dispose()
171 {
172 }
173
174 #endregion
175 }
176}
diff --git a/OpenSim/Grid/GridServer.Modules/GridXmlRpcModule.cs b/OpenSim/Grid/GridServer.Modules/GridXmlRpcModule.cs
deleted file mode 100644
index 854e66a..0000000
--- a/OpenSim/Grid/GridServer.Modules/GridXmlRpcModule.cs
+++ /dev/null
@@ -1,900 +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;
30using System.Collections.Generic;
31using System.IO;
32using System.Net;
33using System.Reflection;
34using System.Xml;
35using log4net;
36using Nwc.XmlRpc;
37using OpenMetaverse;
38using OpenSim.Data;
39using OpenSim.Framework;
40using OpenSim.Framework.Communications;
41using OpenSim.Framework.Servers;
42using OpenSim.Framework.Servers.HttpServer;
43using OpenSim.Grid.Framework;
44
45namespace OpenSim.Grid.GridServer.Modules
46{
47 public class GridXmlRpcModule
48 {
49 private static readonly ILog m_log = LogManager.GetLogger(MethodBase.GetCurrentMethod().DeclaringType);
50
51 private IRegionProfileService m_gridDBService;
52 private IGridServiceCore m_gridCore;
53
54 protected GridConfig m_config;
55
56 protected IMessagingServerDiscovery m_messagingServerMapper;
57 /// <value>
58 /// Used to notify old regions as to which OpenSim version to upgrade to
59 /// </value>
60 private string m_opensimVersion;
61
62 protected BaseHttpServer m_httpServer;
63
64 /// <summary>
65 /// Constructor
66 /// </summary>
67 /// <param name="opensimVersion">
68 /// Used to notify old regions as to which OpenSim version to upgrade to
69 /// </param>
70 public GridXmlRpcModule()
71 {
72 }
73
74 public void Initialise(string opensimVersion, IRegionProfileService gridDBService, IGridServiceCore gridCore, GridConfig config)
75 {
76 m_opensimVersion = opensimVersion;
77 m_gridDBService = gridDBService;
78 m_gridCore = gridCore;
79 m_config = config;
80 RegisterHandlers();
81 }
82
83 public void PostInitialise()
84 {
85 IMessagingServerDiscovery messagingModule;
86 if (m_gridCore.TryGet<IMessagingServerDiscovery>(out messagingModule))
87 {
88 m_messagingServerMapper = messagingModule;
89 }
90 }
91
92 public void RegisterHandlers()
93 {
94 //have these in separate method as some servers restart the http server and reregister all the handlers.
95 m_httpServer = m_gridCore.GetHttpServer();
96
97 m_httpServer.AddXmlRPCHandler("simulator_login", XmlRpcSimulatorLoginMethod);
98 m_httpServer.AddXmlRPCHandler("simulator_data_request", XmlRpcSimulatorDataRequestMethod);
99 m_httpServer.AddXmlRPCHandler("simulator_after_region_moved", XmlRpcDeleteRegionMethod);
100 m_httpServer.AddXmlRPCHandler("map_block", XmlRpcMapBlockMethod);
101 m_httpServer.AddXmlRPCHandler("search_for_region_by_name", XmlRpcSearchForRegionMethod);
102 }
103
104 /// <summary>
105 /// Returns a XML String containing a list of the neighbouring regions
106 /// </summary>
107 /// <param name="reqhandle">The regionhandle for the center sim</param>
108 /// <returns>An XML string containing neighbour entities</returns>
109 public string GetXMLNeighbours(ulong reqhandle)
110 {
111 string response = String.Empty;
112 RegionProfileData central_region = m_gridDBService.GetRegion(reqhandle);
113 RegionProfileData neighbour;
114 for (int x = -1; x < 2; x++)
115 {
116 for (int y = -1; y < 2; y++)
117 {
118 if (
119 m_gridDBService.GetRegion(
120 Util.UIntsToLong((uint)((central_region.regionLocX + x) * Constants.RegionSize),
121 (uint)(central_region.regionLocY + y) * Constants.RegionSize)) != null)
122 {
123 neighbour =
124 m_gridDBService.GetRegion(
125 Util.UIntsToLong((uint)((central_region.regionLocX + x) * Constants.RegionSize),
126 (uint)(central_region.regionLocY + y) * Constants.RegionSize));
127
128 response += "<neighbour>";
129 response += "<sim_ip>" + neighbour.serverIP + "</sim_ip>";
130 response += "<sim_port>" + neighbour.serverPort.ToString() + "</sim_port>";
131 response += "<locx>" + neighbour.regionLocX.ToString() + "</locx>";
132 response += "<locy>" + neighbour.regionLocY.ToString() + "</locy>";
133 response += "<regionhandle>" + neighbour.regionHandle.ToString() + "</regionhandle>";
134 response += "</neighbour>";
135 }
136 }
137 }
138 return response;
139 }
140
141 /// <summary>
142 /// Checks that it's valid to replace the existing region data with new data
143 ///
144 /// Currently, this means ensure that the keys passed in by the new region
145 /// match those in the original region. (XXX Is this correct? Shouldn't we simply check
146 /// against the keys in the current configuration?)
147 /// </summary>
148 /// <param name="sim"></param>
149 /// <returns></returns>
150 protected virtual void ValidateOverwriteKeys(RegionProfileData sim, RegionProfileData existingSim)
151 {
152 if (!(existingSim.regionRecvKey == sim.regionRecvKey && existingSim.regionSendKey == sim.regionSendKey))
153 {
154 throw new LoginException(
155 String.Format(
156 "Authentication failed when trying to login existing region {0} at location {1} {2} currently occupied by {3}"
157 + " with the region's send key {4} (expected {5}) and the region's receive key {6} (expected {7})",
158 sim.regionName, sim.regionLocX, sim.regionLocY, existingSim.regionName,
159 sim.regionSendKey, existingSim.regionSendKey, sim.regionRecvKey, existingSim.regionRecvKey),
160 "The keys required to login your region did not match the grid server keys. Please check your grid send and receive keys.");
161 }
162 }
163
164 /// <summary>
165 /// Checks that the new region data is valid.
166 ///
167 /// Currently, this means checking that the keys passed in by the new region
168 /// match those in the grid server's configuration.
169 /// </summary>
170 ///
171 /// <param name="sim"></param>
172 /// <exception cref="LoginException">Thrown if region login failed</exception>
173 protected virtual void ValidateNewRegionKeys(RegionProfileData sim)
174 {
175 if (!(sim.regionRecvKey == m_config.SimSendKey && sim.regionSendKey == m_config.SimRecvKey))
176 {
177 throw new LoginException(
178 String.Format(
179 "Authentication failed when trying to login new region {0} at location {1} {2}"
180 + " with the region's send key {3} (expected {4}) and the region's receive key {5} (expected {6})",
181 sim.regionName, sim.regionLocX, sim.regionLocY,
182 sim.regionSendKey, m_config.SimRecvKey, sim.regionRecvKey, m_config.SimSendKey),
183 "The keys required to login your region did not match your existing region keys. Please check your grid send and receive keys.");
184 }
185 }
186
187 /// <summary>
188 /// Check that a region's http uri is externally contactable.
189 /// </summary>
190 /// <param name="sim"></param>
191 /// <exception cref="LoginException">Thrown if the region is not contactable</exception>
192 protected virtual void ValidateRegionContactable(RegionProfileData sim)
193 {
194 string regionStatusUrl = String.Format("{0}{1}", sim.httpServerURI, "simstatus/");
195 string regionStatusResponse;
196
197 RestClient rc = new RestClient(regionStatusUrl);
198 rc.RequestMethod = "GET";
199
200 m_log.DebugFormat("[LOGIN]: Contacting {0} for status of region {1}", regionStatusUrl, sim.regionName);
201
202 try
203 {
204 Stream rs = rc.Request();
205 StreamReader sr = new StreamReader(rs);
206 regionStatusResponse = sr.ReadToEnd();
207 sr.Close();
208 }
209 catch (Exception e)
210 {
211 throw new LoginException(
212 String.Format("Region status request to {0} failed", regionStatusUrl),
213 String.Format(
214 "The grid service could not contact the http url {0} at your region. Please make sure this url is reachable by the grid service",
215 regionStatusUrl),
216 e);
217 }
218
219 if (!regionStatusResponse.Equals("OK"))
220 {
221 throw new LoginException(
222 String.Format(
223 "Region {0} at {1} returned status response {2} rather than {3}",
224 sim.regionName, regionStatusUrl, regionStatusResponse, "OK"),
225 String.Format(
226 "When the grid service asked for the status of your region, it received the response {0} rather than {1}. Please check your status",
227 regionStatusResponse, "OK"));
228 }
229 }
230
231 /// <summary>
232 /// Construct an XMLRPC error response
233 /// </summary>
234 /// <param name="error"></param>
235 /// <returns></returns>
236 public static XmlRpcResponse ErrorResponse(string error)
237 {
238 XmlRpcResponse errorResponse = new XmlRpcResponse();
239 Hashtable errorResponseData = new Hashtable();
240 errorResponse.Value = errorResponseData;
241 errorResponseData["error"] = error;
242 return errorResponse;
243 }
244
245 /// <summary>
246 /// Performed when a region connects to the grid server initially.
247 /// </summary>
248 /// <param name="request">The XML RPC Request</param>
249 /// <returns>Startup parameters</returns>
250 public XmlRpcResponse XmlRpcSimulatorLoginMethod(XmlRpcRequest request, IPEndPoint remoteClient)
251 {
252 RegionProfileData sim;
253 RegionProfileData existingSim;
254
255 Hashtable requestData = (Hashtable)request.Params[0];
256 UUID uuid;
257
258 if (!requestData.ContainsKey("UUID") || !UUID.TryParse((string)requestData["UUID"], out uuid))
259 {
260 m_log.Debug("[LOGIN PRELUDE]: Region connected without a UUID, sending back error response.");
261 return ErrorResponse("No UUID passed to grid server - unable to connect you");
262 }
263
264 try
265 {
266 sim = RegionFromRequest(requestData);
267 }
268 catch (FormatException e)
269 {
270 m_log.Debug("[LOGIN PRELUDE]: Invalid login parameters, sending back error response.");
271 return ErrorResponse("Wrong format in login parameters. Please verify parameters." + e.ToString());
272 }
273
274 m_log.InfoFormat("[LOGIN BEGIN]: Received login request from simulator: {0}", sim.regionName);
275
276 if (!m_config.AllowRegionRegistration)
277 {
278 m_log.DebugFormat(
279 "[LOGIN END]: Disabled region registration blocked login request from simulator: {0}",
280 sim.regionName);
281
282 return ErrorResponse("This grid is currently not accepting region registrations.");
283 }
284
285 int majorInterfaceVersion = 0;
286 if (requestData.ContainsKey("major_interface_version"))
287 int.TryParse((string)requestData["major_interface_version"], out majorInterfaceVersion);
288
289 if (majorInterfaceVersion != VersionInfo.MajorInterfaceVersion)
290 {
291 return ErrorResponse(
292 String.Format(
293 "Your region service implements OGS1 interface version {0}"
294 + " but this grid requires that the region implement OGS1 interface version {1} to connect."
295 + " Try changing to OpenSimulator {2}",
296 majorInterfaceVersion, VersionInfo.MajorInterfaceVersion, m_opensimVersion));
297 }
298
299 existingSim = m_gridDBService.GetRegion(sim.regionHandle);
300
301 if (existingSim == null || existingSim.UUID == sim.UUID || sim.UUID != sim.originUUID)
302 {
303 try
304 {
305 if (existingSim == null)
306 {
307 ValidateNewRegionKeys(sim);
308 }
309 else
310 {
311 ValidateOverwriteKeys(sim, existingSim);
312 }
313
314 ValidateRegionContactable(sim);
315 }
316 catch (LoginException e)
317 {
318 string logMsg = e.Message;
319 if (e.InnerException != null)
320 logMsg += ", " + e.InnerException.Message;
321
322 m_log.WarnFormat("[LOGIN END]: {0}", logMsg);
323
324 return e.XmlRpcErrorResponse;
325 }
326
327 DataResponse insertResponse = m_gridDBService.AddUpdateRegion(sim, existingSim);
328
329 switch (insertResponse)
330 {
331 case DataResponse.RESPONSE_OK:
332 m_log.Info("[LOGIN END]: " + (existingSim == null ? "New" : "Existing") + " sim login successful: " + sim.regionName);
333 break;
334 case DataResponse.RESPONSE_ERROR:
335 m_log.Warn("[LOGIN END]: Sim login failed (Error): " + sim.regionName);
336 break;
337 case DataResponse.RESPONSE_INVALIDCREDENTIALS:
338 m_log.Warn("[LOGIN END]: " +
339 "Sim login failed (Invalid Credentials): " + sim.regionName);
340 break;
341 case DataResponse.RESPONSE_AUTHREQUIRED:
342 m_log.Warn("[LOGIN END]: " +
343 "Sim login failed (Authentication Required): " +
344 sim.regionName);
345 break;
346 }
347
348 XmlRpcResponse response = CreateLoginResponse(sim);
349
350 return response;
351 }
352 else
353 {
354 m_log.Warn("[LOGIN END]: Failed to login region " + sim.regionName + " at location " + sim.regionLocX + " " + sim.regionLocY + " currently occupied by " + existingSim.regionName);
355 return ErrorResponse("Another region already exists at that location. Please try another.");
356 }
357 }
358
359 /// <summary>
360 /// Construct a successful response to a simulator's login attempt.
361 /// </summary>
362 /// <param name="sim"></param>
363 /// <returns></returns>
364 private XmlRpcResponse CreateLoginResponse(RegionProfileData sim)
365 {
366 XmlRpcResponse response = new XmlRpcResponse();
367 Hashtable responseData = new Hashtable();
368 response.Value = responseData;
369
370 ArrayList SimNeighboursData = GetSimNeighboursData(sim);
371
372 responseData["UUID"] = sim.UUID.ToString();
373 responseData["region_locx"] = sim.regionLocX.ToString();
374 responseData["region_locy"] = sim.regionLocY.ToString();
375 responseData["regionname"] = sim.regionName;
376 responseData["estate_id"] = "1";
377 responseData["neighbours"] = SimNeighboursData;
378
379 responseData["sim_ip"] = sim.serverIP;
380 responseData["sim_port"] = sim.serverPort.ToString();
381 responseData["asset_url"] = sim.regionAssetURI;
382 responseData["asset_sendkey"] = sim.regionAssetSendKey;
383 responseData["asset_recvkey"] = sim.regionAssetRecvKey;
384 responseData["user_url"] = sim.regionUserURI;
385 responseData["user_sendkey"] = sim.regionUserSendKey;
386 responseData["user_recvkey"] = sim.regionUserRecvKey;
387 responseData["authkey"] = sim.regionSecret;
388
389 // New! If set, use as URL to local sim storage (ie http://remotehost/region.Yap)
390 responseData["data_uri"] = sim.regionDataURI;
391
392 responseData["allow_forceful_banlines"] = m_config.AllowForcefulBanlines;
393
394 // Instead of sending a multitude of message servers to the registering sim
395 // we should probably be sending a single one and parhaps it's backup
396 // that has responsibility over routing it's messages.
397
398 // The Sim won't be contacting us again about any of the message server stuff during it's time up.
399
400 responseData["messageserver_count"] = 0;
401
402 // IGridMessagingModule messagingModule;
403 // if (m_gridCore.TryGet<IGridMessagingModule>(out messagingModule))
404 //{
405 if (m_messagingServerMapper != null)
406 {
407 List<MessageServerInfo> messageServers = m_messagingServerMapper.GetMessageServersList();
408 responseData["messageserver_count"] = messageServers.Count;
409
410 for (int i = 0; i < messageServers.Count; i++)
411 {
412 responseData["messageserver_uri" + i] = messageServers[i].URI;
413 responseData["messageserver_sendkey" + i] = messageServers[i].sendkey;
414 responseData["messageserver_recvkey" + i] = messageServers[i].recvkey;
415 }
416 }
417 return response;
418 }
419
420 private ArrayList GetSimNeighboursData(RegionProfileData sim)
421 {
422 ArrayList SimNeighboursData = new ArrayList();
423
424 RegionProfileData neighbour;
425 Hashtable NeighbourBlock;
426
427 //First use the fast method. (not implemented in SQLLite)
428 List<RegionProfileData> neighbours = m_gridDBService.GetRegions(sim.regionLocX - 1, sim.regionLocY - 1, sim.regionLocX + 1, sim.regionLocY + 1);
429
430 if (neighbours.Count > 0)
431 {
432 foreach (RegionProfileData aSim in neighbours)
433 {
434 NeighbourBlock = new Hashtable();
435 NeighbourBlock["sim_ip"] = aSim.serverIP;
436 NeighbourBlock["sim_port"] = aSim.serverPort.ToString();
437 NeighbourBlock["region_locx"] = aSim.regionLocX.ToString();
438 NeighbourBlock["region_locy"] = aSim.regionLocY.ToString();
439 NeighbourBlock["UUID"] = aSim.ToString();
440 NeighbourBlock["regionHandle"] = aSim.regionHandle.ToString();
441
442 if (aSim.UUID != sim.UUID)
443 {
444 SimNeighboursData.Add(NeighbourBlock);
445 }
446 }
447 }
448 else
449 {
450 for (int x = -1; x < 2; x++)
451 {
452 for (int y = -1; y < 2; y++)
453 {
454 if (
455 m_gridDBService.GetRegion(
456 Utils.UIntsToLong((uint)((sim.regionLocX + x) * Constants.RegionSize),
457 (uint)(sim.regionLocY + y) * Constants.RegionSize)) != null)
458 {
459 neighbour =
460 m_gridDBService.GetRegion(
461 Utils.UIntsToLong((uint)((sim.regionLocX + x) * Constants.RegionSize),
462 (uint)(sim.regionLocY + y) * Constants.RegionSize));
463
464 NeighbourBlock = new Hashtable();
465 NeighbourBlock["sim_ip"] = neighbour.serverIP;
466 NeighbourBlock["sim_port"] = neighbour.serverPort.ToString();
467 NeighbourBlock["region_locx"] = neighbour.regionLocX.ToString();
468 NeighbourBlock["region_locy"] = neighbour.regionLocY.ToString();
469 NeighbourBlock["UUID"] = neighbour.UUID.ToString();
470 NeighbourBlock["regionHandle"] = neighbour.regionHandle.ToString();
471
472 if (neighbour.UUID != sim.UUID) SimNeighboursData.Add(NeighbourBlock);
473 }
474 }
475 }
476 }
477 return SimNeighboursData;
478 }
479
480 /// <summary>
481 /// Loads the grid's own RegionProfileData object with data from the XMLRPC simulator_login request from a region
482 /// </summary>
483 /// <param name="requestData"></param>
484 /// <returns></returns>
485 private RegionProfileData RegionFromRequest(Hashtable requestData)
486 {
487 RegionProfileData sim;
488 sim = new RegionProfileData();
489
490 sim.UUID = new UUID((string)requestData["UUID"]);
491 sim.originUUID = new UUID((string)requestData["originUUID"]);
492
493 sim.regionRecvKey = String.Empty;
494 sim.regionSendKey = String.Empty;
495
496 if (requestData.ContainsKey("region_secret"))
497 {
498 string regionsecret = (string)requestData["region_secret"];
499 if (regionsecret.Length > 0)
500 sim.regionSecret = regionsecret;
501 else
502 sim.regionSecret = m_config.SimRecvKey;
503
504 }
505 else
506 {
507 sim.regionSecret = m_config.SimRecvKey;
508 }
509
510 sim.regionDataURI = String.Empty;
511 sim.regionAssetURI = m_config.DefaultAssetServer;
512 sim.regionAssetRecvKey = m_config.AssetRecvKey;
513 sim.regionAssetSendKey = m_config.AssetSendKey;
514 sim.regionUserURI = m_config.DefaultUserServer;
515 sim.regionUserSendKey = m_config.UserSendKey;
516 sim.regionUserRecvKey = m_config.UserRecvKey;
517
518 sim.serverIP = (string)requestData["sim_ip"];
519 sim.serverPort = Convert.ToUInt32((string)requestData["sim_port"]);
520 sim.httpPort = Convert.ToUInt32((string)requestData["http_port"]);
521 sim.remotingPort = Convert.ToUInt32((string)requestData["remoting_port"]);
522 sim.regionLocX = Convert.ToUInt32((string)requestData["region_locx"]);
523 sim.regionLocY = Convert.ToUInt32((string)requestData["region_locy"]);
524 sim.regionLocZ = 0;
525
526 UUID textureID;
527 if (UUID.TryParse((string)requestData["map-image-id"], out textureID))
528 {
529 sim.regionMapTextureID = textureID;
530 }
531
532 // part of an initial brutish effort to provide accurate information (as per the xml region spec)
533 // wrt the ownership of a given region
534 // the (very bad) assumption is that this value is being read and handled inconsistently or
535 // not at all. Current strategy is to put the code in place to support the validity of this information
536 // and to roll forward debugging any issues from that point
537 //
538 // this particular section of the mod attempts to receive a value from the region's xml file by way of
539 // OSG1GridServices for the region's owner
540 sim.owner_uuid = (UUID)(string)requestData["master_avatar_uuid"];
541
542 try
543 {
544 sim.regionRecvKey = (string)requestData["recvkey"];
545 sim.regionSendKey = (string)requestData["authkey"];
546 }
547 catch (KeyNotFoundException) { }
548
549 sim.regionHandle = Utils.UIntsToLong((sim.regionLocX * Constants.RegionSize), (sim.regionLocY * Constants.RegionSize));
550 sim.serverURI = (string)requestData["server_uri"];
551
552 sim.httpServerURI = "http://" + sim.serverIP + ":" + sim.httpPort + "/";
553
554 sim.regionName = (string)requestData["sim_name"];
555
556
557 try
558 {
559
560 sim.maturity = Convert.ToUInt32((string)requestData["maturity"]);
561 }
562 catch (KeyNotFoundException)
563 {
564 //older region not providing this key - so default to Mature
565 sim.maturity = 1;
566 }
567
568 return sim;
569 }
570
571 /// <summary>
572 /// Returns an XML RPC response to a simulator profile request
573 /// Performed after moving a region.
574 /// </summary>
575 /// <param name="request"></param>
576 /// <returns></returns>
577 /// <param name="request">The XMLRPC Request</param>
578 /// <returns>Processing parameters</returns>
579 public XmlRpcResponse XmlRpcDeleteRegionMethod(XmlRpcRequest request, IPEndPoint remoteClient)
580 {
581 XmlRpcResponse response = new XmlRpcResponse();
582 Hashtable responseData = new Hashtable();
583 response.Value = responseData;
584
585 //RegionProfileData TheSim = null;
586 string uuid;
587 Hashtable requestData = (Hashtable)request.Params[0];
588
589 if (requestData.ContainsKey("UUID"))
590 {
591 //TheSim = GetRegion(new UUID((string) requestData["UUID"]));
592 uuid = requestData["UUID"].ToString();
593 m_log.InfoFormat("[LOGOUT]: Logging out region: {0}", uuid);
594 // logToDB((new LLUUID((string)requestData["UUID"])).ToString(),"XmlRpcDeleteRegionMethod","", 5,"Attempting delete with UUID.");
595 }
596 else
597 {
598 responseData["error"] = "No UUID or region_handle passed to grid server - unable to delete";
599 return response;
600 }
601
602 DataResponse insertResponse = m_gridDBService.DeleteRegion(uuid);
603
604 string insertResp = "";
605 switch (insertResponse)
606 {
607 case DataResponse.RESPONSE_OK:
608 //MainLog.Instance.Verbose("grid", "Deleting region successful: " + uuid);
609 insertResp = "Deleting region successful: " + uuid;
610 break;
611 case DataResponse.RESPONSE_ERROR:
612 //MainLog.Instance.Warn("storage", "Deleting region failed (Error): " + uuid);
613 insertResp = "Deleting region failed (Error): " + uuid;
614 break;
615 case DataResponse.RESPONSE_INVALIDCREDENTIALS:
616 //MainLog.Instance.Warn("storage", "Deleting region failed (Invalid Credentials): " + uuid);
617 insertResp = "Deleting region (Invalid Credentials): " + uuid;
618 break;
619 case DataResponse.RESPONSE_AUTHREQUIRED:
620 //MainLog.Instance.Warn("storage", "Deleting region failed (Authentication Required): " + uuid);
621 insertResp = "Deleting region (Authentication Required): " + uuid;
622 break;
623 }
624
625 responseData["status"] = insertResp;
626
627 return response;
628 }
629
630 /// <summary>
631 /// Returns an XML RPC response to a simulator profile request
632 /// </summary>
633 /// <param name="request"></param>
634 /// <returns></returns>
635 public XmlRpcResponse XmlRpcSimulatorDataRequestMethod(XmlRpcRequest request, IPEndPoint remoteClient)
636 {
637 Hashtable requestData = (Hashtable)request.Params[0];
638 Hashtable responseData = new Hashtable();
639 RegionProfileData simData = null;
640 if (requestData.ContainsKey("region_UUID"))
641 {
642 UUID regionID = new UUID((string)requestData["region_UUID"]);
643 simData = m_gridDBService.GetRegion(regionID);
644 if (simData == null)
645 {
646 m_log.WarnFormat("[DATA] didn't find region for regionID {0} from {1}",
647 regionID, request.Params.Count > 1 ? request.Params[1] : "unknwon source");
648 }
649 }
650 else if (requestData.ContainsKey("region_handle"))
651 {
652 //CFK: The if/else below this makes this message redundant.
653 //CFK: m_log.Info("requesting data for region " + (string) requestData["region_handle"]);
654 ulong regionHandle = Convert.ToUInt64((string)requestData["region_handle"]);
655 simData = m_gridDBService.GetRegion(regionHandle);
656 if (simData == null)
657 {
658 m_log.WarnFormat("[DATA] didn't find region for regionHandle {0} from {1}",
659 regionHandle, request.Params.Count > 1 ? request.Params[1] : "unknwon source");
660 }
661 }
662 else if (requestData.ContainsKey("region_name_search"))
663 {
664 string regionName = (string)requestData["region_name_search"];
665 simData = m_gridDBService.GetRegion(regionName);
666 if (simData == null)
667 {
668 m_log.WarnFormat("[DATA] didn't find region for regionName {0} from {1}",
669 regionName, request.Params.Count > 1 ? request.Params[1] : "unknwon source");
670 }
671 }
672 else m_log.Warn("[DATA] regionlookup without regionID, regionHandle or regionHame");
673
674 if (simData == null)
675 {
676 //Sim does not exist
677 responseData["error"] = "Sim does not exist";
678 }
679 else
680 {
681 m_log.Info("[DATA]: found " + (string)simData.regionName + " regionHandle = " +
682 (string)requestData["region_handle"]);
683 responseData["sim_ip"] = simData.serverIP;
684 responseData["sim_port"] = simData.serverPort.ToString();
685 responseData["server_uri"] = simData.serverURI;
686 responseData["http_port"] = simData.httpPort.ToString();
687 responseData["remoting_port"] = simData.remotingPort.ToString();
688 responseData["region_locx"] = simData.regionLocX.ToString();
689 responseData["region_locy"] = simData.regionLocY.ToString();
690 responseData["region_UUID"] = simData.UUID.Guid.ToString();
691 responseData["region_name"] = simData.regionName;
692 responseData["regionHandle"] = simData.regionHandle.ToString();
693 }
694
695 XmlRpcResponse response = new XmlRpcResponse();
696 response.Value = responseData;
697 return response;
698 }
699
700 public XmlRpcResponse XmlRpcMapBlockMethod(XmlRpcRequest request, IPEndPoint remoteClient)
701 {
702 int xmin = 980, ymin = 980, xmax = 1020, ymax = 1020;
703
704 Hashtable requestData = (Hashtable)request.Params[0];
705 if (requestData.ContainsKey("xmin"))
706 {
707 xmin = (Int32)requestData["xmin"];
708 }
709 if (requestData.ContainsKey("ymin"))
710 {
711 ymin = (Int32)requestData["ymin"];
712 }
713 if (requestData.ContainsKey("xmax"))
714 {
715 xmax = (Int32)requestData["xmax"];
716 }
717 if (requestData.ContainsKey("ymax"))
718 {
719 ymax = (Int32)requestData["ymax"];
720 }
721 //CFK: The second log is more meaningful and either standard or fast generally occurs.
722 //CFK: m_log.Info("[MAP]: World map request for range (" + xmin + "," + ymin + ")..(" + xmax + "," + ymax + ")");
723
724 XmlRpcResponse response = new XmlRpcResponse();
725 Hashtable responseData = new Hashtable();
726 response.Value = responseData;
727 IList simProfileList = new ArrayList();
728
729 bool fastMode = (m_config.DatabaseProvider == "OpenSim.Data.MySQL.dll" || m_config.DatabaseProvider == "OpenSim.Data.MSSQL.dll");
730
731 if (fastMode)
732 {
733 List<RegionProfileData> neighbours = m_gridDBService.GetRegions((uint)xmin, (uint)ymin, (uint)xmax, (uint)ymax);
734
735 foreach (RegionProfileData aSim in neighbours)
736 {
737 Hashtable simProfileBlock = new Hashtable();
738 simProfileBlock["x"] = aSim.regionLocX.ToString();
739 simProfileBlock["y"] = aSim.regionLocY.ToString();
740 //m_log.DebugFormat("[MAP]: Sending neighbour info for {0},{1}", aSim.regionLocX, aSim.regionLocY);
741 simProfileBlock["name"] = aSim.regionName;
742 simProfileBlock["access"] = aSim.AccessLevel.ToString();
743 simProfileBlock["region-flags"] = 512;
744 simProfileBlock["water-height"] = 0;
745 simProfileBlock["agents"] = 1;
746 simProfileBlock["map-image-id"] = aSim.regionMapTextureID.ToString();
747
748 // For Sugilite compatibility
749 simProfileBlock["regionhandle"] = aSim.regionHandle.ToString();
750 simProfileBlock["sim_ip"] = aSim.serverIP;
751 simProfileBlock["sim_port"] = aSim.serverPort.ToString();
752 simProfileBlock["sim_uri"] = aSim.serverURI.ToString();
753 simProfileBlock["uuid"] = aSim.UUID.ToString();
754 simProfileBlock["remoting_port"] = aSim.remotingPort.ToString();
755 simProfileBlock["http_port"] = aSim.httpPort.ToString();
756
757 simProfileList.Add(simProfileBlock);
758 }
759 m_log.Info("[MAP]: Fast map " + simProfileList.Count.ToString() +
760 " regions @ (" + xmin + "," + ymin + ")..(" + xmax + "," + ymax + ")");
761 }
762 else
763 {
764 RegionProfileData simProfile;
765 for (int x = xmin; x < xmax + 1; x++)
766 {
767 for (int y = ymin; y < ymax + 1; y++)
768 {
769 ulong regHandle = Utils.UIntsToLong((uint)(x * Constants.RegionSize), (uint)(y * Constants.RegionSize));
770 simProfile = m_gridDBService.GetRegion(regHandle);
771 if (simProfile != null)
772 {
773 Hashtable simProfileBlock = new Hashtable();
774 simProfileBlock["x"] = x;
775 simProfileBlock["y"] = y;
776 simProfileBlock["name"] = simProfile.regionName;
777 simProfileBlock["access"] = simProfile.AccessLevel.ToString();
778 simProfileBlock["region-flags"] = 0;
779 simProfileBlock["water-height"] = 20;
780 simProfileBlock["agents"] = 1;
781 simProfileBlock["map-image-id"] = simProfile.regionMapTextureID.ToString();
782
783 // For Sugilite compatibility
784 simProfileBlock["regionhandle"] = simProfile.regionHandle.ToString();
785 simProfileBlock["sim_ip"] = simProfile.serverIP.ToString();
786 simProfileBlock["sim_port"] = simProfile.serverPort.ToString();
787 simProfileBlock["sim_uri"] = simProfile.serverURI.ToString();
788 simProfileBlock["uuid"] = simProfile.UUID.ToString();
789 simProfileBlock["remoting_port"] = simProfile.remotingPort.ToString();
790 simProfileBlock["http_port"] = simProfile.httpPort;
791
792 simProfileList.Add(simProfileBlock);
793 }
794 }
795 }
796 m_log.Info("[MAP]: Std map " + simProfileList.Count.ToString() +
797 " regions @ (" + xmin + "," + ymin + ")..(" + xmax + "," + ymax + ")");
798 }
799
800 responseData["sim-profiles"] = simProfileList;
801
802 return response;
803 }
804
805 /// <summary>
806 /// Returns up to <code>maxNumber</code> profiles of regions that have a name starting with <code>name</code>
807 /// </summary>
808 /// <param name="request"></param>
809 /// <returns></returns>
810 public XmlRpcResponse XmlRpcSearchForRegionMethod(XmlRpcRequest request, IPEndPoint remoteClient)
811 {
812 Hashtable requestData = (Hashtable)request.Params[0];
813
814 if (!requestData.ContainsKey("name") || !requestData.Contains("maxNumber"))
815 {
816 m_log.Warn("[DATA] Invalid region-search request; missing name or maxNumber");
817 return new XmlRpcResponse(500, "Missing name or maxNumber in region search request");
818 }
819
820 Hashtable responseData = new Hashtable();
821
822 string name = (string)requestData["name"];
823 int maxNumber = Convert.ToInt32((string)requestData["maxNumber"]);
824 if (maxNumber == 0 || name.Length < 3)
825 {
826 // either we didn't want any, or we were too unspecific
827 responseData["numFound"] = 0;
828 }
829 else
830 {
831 List<RegionProfileData> sims = m_gridDBService.GetRegions(name, maxNumber);
832
833 responseData["numFound"] = sims.Count;
834 for (int i = 0; i < sims.Count; ++i)
835 {
836 RegionProfileData sim = sims[i];
837 string prefix = "region" + i + ".";
838 responseData[prefix + "region_name"] = sim.regionName;
839 responseData[prefix + "region_UUID"] = sim.UUID.ToString();
840 responseData[prefix + "region_locx"] = sim.regionLocX.ToString();
841 responseData[prefix + "region_locy"] = sim.regionLocY.ToString();
842 responseData[prefix + "sim_ip"] = sim.serverIP.ToString();
843 responseData[prefix + "sim_port"] = sim.serverPort.ToString();
844 responseData[prefix + "remoting_port"] = sim.remotingPort.ToString();
845 responseData[prefix + "http_port"] = sim.httpPort.ToString();
846 responseData[prefix + "map_UUID"] = sim.regionMapTextureID.ToString();
847 }
848 }
849
850 XmlRpcResponse response = new XmlRpcResponse();
851 response.Value = responseData;
852 return response;
853 }
854
855 /// <summary>
856 /// Construct an XMLRPC registration disabled response
857 /// </summary>
858 /// <param name="error"></param>
859 /// <returns></returns>
860 public static XmlRpcResponse XmlRPCRegionRegistrationDisabledResponse(string error)
861 {
862 XmlRpcResponse errorResponse = new XmlRpcResponse();
863 Hashtable errorResponseData = new Hashtable();
864 errorResponse.Value = errorResponseData;
865 errorResponseData["restricted"] = error;
866 return errorResponse;
867 }
868 }
869
870 /// <summary>
871 /// Exception generated when a simulator fails to login to the grid
872 /// </summary>
873 public class LoginException : Exception
874 {
875 /// <summary>
876 /// Return an XmlRpcResponse version of the exception message suitable for sending to a client
877 /// </summary>
878 /// <param name="message"></param>
879 /// <param name="xmlRpcMessage"></param>
880 public XmlRpcResponse XmlRpcErrorResponse
881 {
882 get { return m_xmlRpcErrorResponse; }
883 }
884 private XmlRpcResponse m_xmlRpcErrorResponse;
885
886 public LoginException(string message, string xmlRpcMessage)
887 : base(message)
888 {
889 // FIXME: Might be neater to refactor and put the method inside here
890 m_xmlRpcErrorResponse = GridXmlRpcModule.ErrorResponse(xmlRpcMessage);
891 }
892
893 public LoginException(string message, string xmlRpcMessage, Exception e)
894 : base(message, e)
895 {
896 // FIXME: Might be neater to refactor and put the method inside here
897 m_xmlRpcErrorResponse = GridXmlRpcModule.ErrorResponse(xmlRpcMessage);
898 }
899 }
900}
diff --git a/OpenSim/Grid/GridServer.Modules/Resources/GridServer.Modules.addin.xml b/OpenSim/Grid/GridServer.Modules/Resources/GridServer.Modules.addin.xml
deleted file mode 100644
index c2c5ac3..0000000
--- a/OpenSim/Grid/GridServer.Modules/Resources/GridServer.Modules.addin.xml
+++ /dev/null
@@ -1,11 +0,0 @@
1<Addin id="OpenSim.Grid.GridServer.Modules" version="0.1">
2 <Runtime>
3 <Import assembly="OpenSim.Grid.GridServer.Modules.dll"/>
4 </Runtime>
5 <Dependencies>
6 <Addin id="OpenSim.Grid.GridServer" version="0.5" />
7 </Dependencies>
8 <Extension path = "/OpenSim/GridServer">
9 <Plugin id="GridServerModules" type="OpenSim.Grid.GridServer.Modules.GridServerPlugin" />
10 </Extension>
11</Addin>
generated by cgit v1.1 at 2024-11-14 12:45:10 +0000