diff options
author | Diva Canto | 2010-01-10 20:17:37 -0800 |
---|---|---|
committer | Diva Canto | 2010-01-10 20:17:37 -0800 |
commit | 5cf6d6fa79dada85bd56530551409809d338b7d2 (patch) | |
tree | 24f89393fc9b25f138caed27919800230dafe70d /OpenSim/Grid/GridServer | |
parent | OpenSim.Region.Communications.* is no more. Thanks to everyone who contribute... (diff) | |
download | opensim-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 '')
-rw-r--r-- | OpenSim/Grid/GridServer.Modules/GridDBService.cs | 284 | ||||
-rw-r--r-- | OpenSim/Grid/GridServer.Modules/GridMessagingModule.cs | 164 | ||||
-rw-r--r-- | OpenSim/Grid/GridServer.Modules/GridRestModule.cs | 282 | ||||
-rw-r--r-- | OpenSim/Grid/GridServer.Modules/GridServerPlugin.cs | 176 | ||||
-rw-r--r-- | OpenSim/Grid/GridServer.Modules/GridXmlRpcModule.cs | 900 | ||||
-rw-r--r-- | OpenSim/Grid/GridServer.Modules/Resources/GridServer.Modules.addin.xml | 11 | ||||
-rw-r--r-- | OpenSim/Grid/GridServer/GridServerBase.cs | 170 | ||||
-rw-r--r-- | OpenSim/Grid/GridServer/IGridPlugin.cs | 49 | ||||
-rw-r--r-- | OpenSim/Grid/GridServer/Properties/AssemblyInfo.cs | 63 |
9 files changed, 0 insertions, 2099 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 | |||
28 | using System; | ||
29 | using System.Collections; | ||
30 | using System.Collections.Generic; | ||
31 | using System.IO; | ||
32 | using System.Reflection; | ||
33 | using System.Xml; | ||
34 | using log4net; | ||
35 | using Nwc.XmlRpc; | ||
36 | using OpenMetaverse; | ||
37 | using OpenSim.Data; | ||
38 | using OpenSim.Framework; | ||
39 | using OpenSim.Framework.Communications; | ||
40 | using OpenSim.Framework.Servers; | ||
41 | |||
42 | |||
43 | namespace 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 | |||
28 | using System; | ||
29 | using System.Collections; | ||
30 | using System.Collections.Generic; | ||
31 | using System.Net; | ||
32 | using System.Reflection; | ||
33 | using System.Text; | ||
34 | using Nwc.XmlRpc; | ||
35 | using log4net; | ||
36 | using OpenSim.Data; | ||
37 | using OpenSim.Framework.Servers; | ||
38 | using OpenSim.Framework.Servers.HttpServer; | ||
39 | using OpenSim.Framework; | ||
40 | using OpenSim.Grid.Framework; | ||
41 | |||
42 | namespace 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 | |||
28 | using System; | ||
29 | using System.Collections; | ||
30 | using System.Collections.Generic; | ||
31 | using System.IO; | ||
32 | using System.Reflection; | ||
33 | using System.Xml; | ||
34 | using log4net; | ||
35 | using OpenMetaverse; | ||
36 | using OpenSim.Data; | ||
37 | using OpenSim.Framework; | ||
38 | using OpenSim.Framework.Communications; | ||
39 | using OpenSim.Framework.Servers.HttpServer; | ||
40 | using OpenSim.Grid.Framework; | ||
41 | |||
42 | namespace 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 | |||
28 | using System; | ||
29 | using System.Collections.Generic; | ||
30 | using System.Reflection; | ||
31 | using System.Text; | ||
32 | using log4net; | ||
33 | using OpenSim.Framework; | ||
34 | using OpenSim.Framework.Console; | ||
35 | using OpenSim.Grid.Framework; | ||
36 | using OpenSim.Grid; | ||
37 | |||
38 | namespace 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 | |||
28 | using System; | ||
29 | using System.Collections; | ||
30 | using System.Collections.Generic; | ||
31 | using System.IO; | ||
32 | using System.Net; | ||
33 | using System.Reflection; | ||
34 | using System.Xml; | ||
35 | using log4net; | ||
36 | using Nwc.XmlRpc; | ||
37 | using OpenMetaverse; | ||
38 | using OpenSim.Data; | ||
39 | using OpenSim.Framework; | ||
40 | using OpenSim.Framework.Communications; | ||
41 | using OpenSim.Framework.Servers; | ||
42 | using OpenSim.Framework.Servers.HttpServer; | ||
43 | using OpenSim.Grid.Framework; | ||
44 | |||
45 | namespace 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> | ||
diff --git a/OpenSim/Grid/GridServer/GridServerBase.cs b/OpenSim/Grid/GridServer/GridServerBase.cs deleted file mode 100644 index 9b0d7ea..0000000 --- a/OpenSim/Grid/GridServer/GridServerBase.cs +++ /dev/null | |||
@@ -1,170 +0,0 @@ | |||
1 | /* | ||
2 | * Copyright (c) Contributors, http://opensimulator.org/ | ||
3 | * See CONTRIBUTORS.TXT for a full list of copyright holders. | ||
4 | * | ||
5 | * Redistribution and use in source and binary forms, with or without | ||
6 | * modification, are permitted provided that the following conditions are met: | ||
7 | * * Redistributions of source code must retain the above copyright | ||
8 | * notice, this list of conditions and the following disclaimer. | ||
9 | * * Redistributions in binary form must reproduce the above copyright | ||
10 | * notice, this list of conditions and the following disclaimer in the | ||
11 | * documentation and/or other materials provided with the distribution. | ||
12 | * * Neither the name of the OpenSimulator Project nor the | ||
13 | * names of its contributors may be used to endorse or promote products | ||
14 | * derived from this software without specific prior written permission. | ||
15 | * | ||
16 | * THIS SOFTWARE IS PROVIDED BY THE DEVELOPERS ``AS IS'' AND ANY | ||
17 | * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED | ||
18 | * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE | ||
19 | * DISCLAIMED. IN NO EVENT SHALL THE CONTRIBUTORS BE LIABLE FOR ANY | ||
20 | * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES | ||
21 | * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; | ||
22 | * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND | ||
23 | * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT | ||
24 | * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS | ||
25 | * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. | ||
26 | */ | ||
27 | |||
28 | using System; | ||
29 | using System.Collections.Generic; | ||
30 | using System.IO; | ||
31 | using System.Reflection; | ||
32 | using log4net; | ||
33 | using Nini.Config; | ||
34 | using OpenSim.Framework; | ||
35 | using OpenSim.Framework.Console; | ||
36 | using OpenSim.Framework.Servers; | ||
37 | using OpenSim.Framework.Servers.HttpServer; | ||
38 | using OpenSim.Grid.Framework; | ||
39 | |||
40 | namespace OpenSim.Grid.GridServer | ||
41 | { | ||
42 | /// <summary> | ||
43 | /// </summary> | ||
44 | public class GridServerBase : BaseOpenSimServer, IGridServiceCore | ||
45 | { | ||
46 | private static readonly ILog m_log = LogManager.GetLogger(MethodBase.GetCurrentMethod().DeclaringType); | ||
47 | |||
48 | protected GridConfig m_config; | ||
49 | public string m_consoleType = "local"; | ||
50 | public IConfigSource m_configSource = null; | ||
51 | public string m_configFile = "GridServer_Config.xml"; | ||
52 | |||
53 | public GridConfig Config | ||
54 | { | ||
55 | get { return m_config; } | ||
56 | } | ||
57 | |||
58 | public string Version | ||
59 | { | ||
60 | get { return m_version; } | ||
61 | } | ||
62 | |||
63 | protected List<IGridPlugin> m_plugins = new List<IGridPlugin>(); | ||
64 | |||
65 | public void Work() | ||
66 | { | ||
67 | m_console.Output("Enter help for a list of commands\n"); | ||
68 | |||
69 | while (true) | ||
70 | { | ||
71 | m_console.Prompt(); | ||
72 | } | ||
73 | } | ||
74 | |||
75 | public GridServerBase() | ||
76 | { | ||
77 | } | ||
78 | |||
79 | protected override void StartupSpecific() | ||
80 | { | ||
81 | switch (m_consoleType) | ||
82 | { | ||
83 | case "rest": | ||
84 | m_console = new RemoteConsole("Grid"); | ||
85 | break; | ||
86 | case "basic": | ||
87 | m_console = new CommandConsole("Grid"); | ||
88 | break; | ||
89 | default: | ||
90 | m_console = new LocalConsole("Grid"); | ||
91 | break; | ||
92 | } | ||
93 | MainConsole.Instance = m_console; | ||
94 | m_config = new GridConfig("GRID SERVER", (Path.Combine(Util.configDir(), m_configFile))); | ||
95 | |||
96 | m_log.Info("[GRID]: Starting HTTP process"); | ||
97 | m_httpServer = new BaseHttpServer(m_config.HttpPort); | ||
98 | if (m_console is RemoteConsole) | ||
99 | { | ||
100 | RemoteConsole c = (RemoteConsole)m_console; | ||
101 | c.SetServer(m_httpServer); | ||
102 | IConfig netConfig = m_configSource.AddConfig("Network"); | ||
103 | netConfig.Set("ConsoleUser", m_config.ConsoleUser); | ||
104 | netConfig.Set("ConsolePass", m_config.ConsolePass); | ||
105 | c.ReadConfig(m_configSource); | ||
106 | } | ||
107 | |||
108 | LoadPlugins(); | ||
109 | |||
110 | m_httpServer.Start(); | ||
111 | |||
112 | base.StartupSpecific(); | ||
113 | } | ||
114 | |||
115 | protected virtual void LoadPlugins() | ||
116 | { | ||
117 | using (PluginLoader<IGridPlugin> loader = new PluginLoader<IGridPlugin>(new GridPluginInitialiser(this))) | ||
118 | { | ||
119 | loader.Load("/OpenSim/GridServer"); | ||
120 | m_plugins = loader.Plugins; | ||
121 | } | ||
122 | } | ||
123 | |||
124 | public override void ShutdownSpecific() | ||
125 | { | ||
126 | foreach (IGridPlugin plugin in m_plugins) plugin.Dispose(); | ||
127 | } | ||
128 | |||
129 | #region IServiceCore | ||
130 | protected Dictionary<Type, object> m_moduleInterfaces = new Dictionary<Type, object>(); | ||
131 | |||
132 | /// <summary> | ||
133 | /// Register an Module interface. | ||
134 | /// </summary> | ||
135 | /// <typeparam name="T"></typeparam> | ||
136 | /// <param name="iface"></param> | ||
137 | public void RegisterInterface<T>(T iface) | ||
138 | { | ||
139 | lock (m_moduleInterfaces) | ||
140 | { | ||
141 | if (!m_moduleInterfaces.ContainsKey(typeof(T))) | ||
142 | { | ||
143 | m_moduleInterfaces.Add(typeof(T), iface); | ||
144 | } | ||
145 | } | ||
146 | } | ||
147 | |||
148 | public bool TryGet<T>(out T iface) | ||
149 | { | ||
150 | if (m_moduleInterfaces.ContainsKey(typeof(T))) | ||
151 | { | ||
152 | iface = (T)m_moduleInterfaces[typeof(T)]; | ||
153 | return true; | ||
154 | } | ||
155 | iface = default(T); | ||
156 | return false; | ||
157 | } | ||
158 | |||
159 | public T Get<T>() | ||
160 | { | ||
161 | return (T)m_moduleInterfaces[typeof(T)]; | ||
162 | } | ||
163 | |||
164 | public BaseHttpServer GetHttpServer() | ||
165 | { | ||
166 | return m_httpServer; | ||
167 | } | ||
168 | #endregion | ||
169 | } | ||
170 | } | ||
diff --git a/OpenSim/Grid/GridServer/IGridPlugin.cs b/OpenSim/Grid/GridServer/IGridPlugin.cs deleted file mode 100644 index bd0feb6..0000000 --- a/OpenSim/Grid/GridServer/IGridPlugin.cs +++ /dev/null | |||
@@ -1,49 +0,0 @@ | |||
1 | /* | ||
2 | * Copyright (c) Contributors, http://opensimulator.org/ | ||
3 | * See CONTRIBUTORS.TXT for a full list of copyright holders. | ||
4 | * | ||
5 | * Redistribution and use in source and binary forms, with or without | ||
6 | * modification, are permitted provided that the following conditions are met: | ||
7 | * * Redistributions of source code must retain the above copyright | ||
8 | * notice, this list of conditions and the following disclaimer. | ||
9 | * * Redistributions in binary form must reproduce the above copyright | ||
10 | * notice, this list of conditions and the following disclaimer in the | ||
11 | * documentation and/or other materials provided with the distribution. | ||
12 | * * Neither the name of the OpenSimulator Project nor the | ||
13 | * names of its contributors may be used to endorse or promote products | ||
14 | * derived from this software without specific prior written permission. | ||
15 | * | ||
16 | * THIS SOFTWARE IS PROVIDED BY THE DEVELOPERS ``AS IS'' AND ANY | ||
17 | * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED | ||
18 | * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE | ||
19 | * DISCLAIMED. IN NO EVENT SHALL THE CONTRIBUTORS BE LIABLE FOR ANY | ||
20 | * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES | ||
21 | * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; | ||
22 | * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND | ||
23 | * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT | ||
24 | * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS | ||
25 | * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. | ||
26 | * | ||
27 | */ | ||
28 | |||
29 | using OpenSim.Framework; | ||
30 | |||
31 | namespace OpenSim.Grid.GridServer | ||
32 | { | ||
33 | public interface IGridPlugin : IPlugin | ||
34 | { | ||
35 | void Initialise(GridServerBase gridServer); | ||
36 | void PostInitialise(); | ||
37 | } | ||
38 | |||
39 | public class GridPluginInitialiser : PluginInitialiserBase | ||
40 | { | ||
41 | private GridServerBase server; | ||
42 | public GridPluginInitialiser (GridServerBase s) { server = s; } | ||
43 | public override void Initialise (IPlugin plugin) | ||
44 | { | ||
45 | IGridPlugin p = plugin as IGridPlugin; | ||
46 | p.Initialise (server); | ||
47 | } | ||
48 | } | ||
49 | } | ||
diff --git a/OpenSim/Grid/GridServer/Properties/AssemblyInfo.cs b/OpenSim/Grid/GridServer/Properties/AssemblyInfo.cs deleted file mode 100644 index 24c4bd7..0000000 --- a/OpenSim/Grid/GridServer/Properties/AssemblyInfo.cs +++ /dev/null | |||
@@ -1,63 +0,0 @@ | |||
1 | /* | ||
2 | * Copyright (c) Contributors, http://opensimulator.org/ | ||
3 | * See CONTRIBUTORS.TXT for a full list of copyright holders. | ||
4 | * | ||
5 | * Redistribution and use in source and binary forms, with or without | ||
6 | * modification, are permitted provided that the following conditions are met: | ||
7 | * * Redistributions of source code must retain the above copyright | ||
8 | * notice, this list of conditions and the following disclaimer. | ||
9 | * * Redistributions in binary form must reproduce the above copyright | ||
10 | * notice, this list of conditions and the following disclaimer in the | ||
11 | * documentation and/or other materials provided with the distribution. | ||
12 | * * Neither the name of the OpenSimulator Project nor the | ||
13 | * names of its contributors may be used to endorse or promote products | ||
14 | * derived from this software without specific prior written permission. | ||
15 | * | ||
16 | * THIS SOFTWARE IS PROVIDED BY THE DEVELOPERS ``AS IS'' AND ANY | ||
17 | * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED | ||
18 | * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE | ||
19 | * DISCLAIMED. IN NO EVENT SHALL THE CONTRIBUTORS BE LIABLE FOR ANY | ||
20 | * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES | ||
21 | * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; | ||
22 | * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND | ||
23 | * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT | ||
24 | * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS | ||
25 | * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. | ||
26 | */ | ||
27 | |||
28 | using System.Reflection; | ||
29 | using System.Runtime.InteropServices; | ||
30 | |||
31 | // General information about an assembly is controlled through the following | ||
32 | // set of attributes. Change these attribute values to modify the information | ||
33 | // associated with an assembly. | ||
34 | |||
35 | [assembly : AssemblyTitle("OGS-GridServer")] | ||
36 | [assembly : AssemblyDescription("")] | ||
37 | [assembly : AssemblyConfiguration("")] | ||
38 | [assembly : AssemblyCompany("http://opensimulator.org")] | ||
39 | [assembly : AssemblyProduct("OGS-GridServer")] | ||
40 | [assembly : AssemblyCopyright("Copyright (c) OpenSimulator.org Developers 2007-2009")] | ||
41 | [assembly : AssemblyTrademark("")] | ||
42 | [assembly : AssemblyCulture("")] | ||
43 | |||
44 | // Setting ComVisible to false makes the types in this assembly not visible | ||
45 | // to COM components. If you need to access a type in this assembly from | ||
46 | // COM, set the ComVisible attribute to true on that type. | ||
47 | |||
48 | [assembly : ComVisible(false)] | ||
49 | |||
50 | // The following GUID is for the ID of the typelib if this project is exposed to COM | ||
51 | |||
52 | [assembly : Guid("b541b244-3d1d-4625-9003-bc2a3a6a39a4")] | ||
53 | |||
54 | // Version information for an assembly consists of the following four values: | ||
55 | // | ||
56 | // Major Version | ||
57 | // Minor Version | ||
58 | // Build Number | ||
59 | // Revision | ||
60 | // | ||
61 | |||
62 | [assembly : AssemblyVersion("0.6.5.*")] | ||
63 | [assembly : AssemblyFileVersion("0.6.5.0")] | ||