1
0

MainServer.cs 14 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357
  1. /*
  2. * Copyright (c) Contributors, http://opensimulator.org/
  3. * See CONTRIBUTORS.TXT for a full list of copyright holders.
  4. *
  5. * Redistribution and use in source and binary forms, with or without
  6. * modification, are permitted provided that the following conditions are met:
  7. * * Redistributions of source code must retain the above copyright
  8. * notice, this list of conditions and the following disclaimer.
  9. * * Redistributions in binary form must reproduce the above copyright
  10. * notice, this list of conditions and the following disclaimer in the
  11. * documentation and/or other materials provided with the distribution.
  12. * * Neither the name of the OpenSimulator Project nor the
  13. * names of its contributors may be used to endorse or promote products
  14. * derived from this software without specific prior written permission.
  15. *
  16. * THIS SOFTWARE IS PROVIDED BY THE DEVELOPERS ``AS IS'' AND ANY
  17. * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
  18. * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
  19. * DISCLAIMED. IN NO EVENT SHALL THE CONTRIBUTORS BE LIABLE FOR ANY
  20. * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
  21. * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
  22. * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
  23. * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  24. * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
  25. * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  26. */
  27. using System;
  28. using System.Collections.Generic;
  29. using System.Reflection;
  30. using System.Net;
  31. using System.Text;
  32. using log4net;
  33. using OpenSim.Framework;
  34. using OpenSim.Framework.Console;
  35. using OpenSim.Framework.Servers.HttpServer;
  36. namespace OpenSim.Framework.Servers
  37. {
  38. public class MainServer
  39. {
  40. // private static readonly ILog m_log = LogManager.GetLogger(MethodBase.GetCurrentMethod().DeclaringType);
  41. private static BaseHttpServer instance = null;
  42. private static Dictionary<uint, BaseHttpServer> m_Servers = new Dictionary<uint, BaseHttpServer>();
  43. /// <summary>
  44. /// Control the printing of certain debug messages.
  45. /// </summary>
  46. /// <remarks>
  47. /// If DebugLevel >= 1 then short warnings are logged when receiving bad input data.
  48. /// If DebugLevel >= 2 then long warnings are logged when receiving bad input data.
  49. /// If DebugLevel >= 3 then short notices about all incoming non-poll HTTP requests are logged.
  50. /// If DebugLevel >= 4 then the time taken to fulfill the request is logged.
  51. /// If DebugLevel >= 5 then the start of the body of incoming non-poll HTTP requests will be logged.
  52. /// If DebugLevel >= 6 then the entire body of incoming non-poll HTTP requests will be logged.
  53. /// </remarks>
  54. public static int DebugLevel
  55. {
  56. get { return s_debugLevel; }
  57. set
  58. {
  59. s_debugLevel = value;
  60. lock (m_Servers)
  61. foreach (BaseHttpServer server in m_Servers.Values)
  62. server.DebugLevel = s_debugLevel;
  63. }
  64. }
  65. private static int s_debugLevel;
  66. /// <summary>
  67. /// Set the main HTTP server instance.
  68. /// </summary>
  69. /// <remarks>
  70. /// This will be used to register all handlers that listen to the default port.
  71. /// </remarks>
  72. /// <exception cref='Exception'>
  73. /// Thrown if the HTTP server has not already been registered via AddHttpServer()
  74. /// </exception>
  75. public static BaseHttpServer Instance
  76. {
  77. get { return instance; }
  78. set
  79. {
  80. lock (m_Servers)
  81. if (!m_Servers.ContainsValue(value))
  82. throw new Exception("HTTP server must already have been registered to be set as the main instance");
  83. instance = value;
  84. }
  85. }
  86. /// <summary>
  87. /// Get all the registered servers.
  88. /// </summary>
  89. /// <remarks>
  90. /// Returns a copy of the dictionary so this can be iterated through without locking.
  91. /// </remarks>
  92. /// <value></value>
  93. public static Dictionary<uint, BaseHttpServer> Servers
  94. {
  95. get { return new Dictionary<uint, BaseHttpServer>(m_Servers); }
  96. }
  97. public static void RegisterHttpConsoleCommands(ICommandConsole console)
  98. {
  99. console.Commands.AddCommand(
  100. "Comms", false, "show http-handlers",
  101. "show http-handlers",
  102. "Show all registered http handlers", HandleShowHttpHandlersCommand);
  103. console.Commands.AddCommand(
  104. "Debug", false, "debug http", "debug http <in|out|all> [<level>]",
  105. "Turn on http request logging.",
  106. "If in or all and\n"
  107. + " level <= 0 then no extra logging is done.\n"
  108. + " level >= 1 then short warnings are logged when receiving bad input data.\n"
  109. + " level >= 2 then long warnings are logged when receiving bad input data.\n"
  110. + " level >= 3 then short notices about all incoming non-poll HTTP requests are logged.\n"
  111. + " level >= 4 then the time taken to fulfill the request is logged.\n"
  112. + " level >= 5 then a sample from the beginning of the data is logged.\n"
  113. + " level >= 6 then the entire data is logged.\n"
  114. + " no level is specified then the current level is returned.\n\n"
  115. + "If out or all and\n"
  116. + " level >= 3 then short notices about all outgoing requests going through WebUtil are logged.\n"
  117. + " level >= 4 then the time taken to fulfill the request is logged.\n"
  118. + " level >= 5 then a sample from the beginning of the data is logged.\n"
  119. + " level >= 6 then the entire data is logged.\n",
  120. HandleDebugHttpCommand);
  121. }
  122. /// <summary>
  123. /// Turn on some debugging values for OpenSim.
  124. /// </summary>
  125. /// <param name="args"></param>
  126. private static void HandleDebugHttpCommand(string module, string[] cmdparams)
  127. {
  128. if (cmdparams.Length < 3)
  129. {
  130. MainConsole.Instance.Output("Usage: debug http <in|out|all> 0..6");
  131. return;
  132. }
  133. bool inReqs = false;
  134. bool outReqs = false;
  135. bool allReqs = false;
  136. string subCommand = cmdparams[2];
  137. if (subCommand.ToLower() == "in")
  138. {
  139. inReqs = true;
  140. }
  141. else if (subCommand.ToLower() == "out")
  142. {
  143. outReqs = true;
  144. }
  145. else if (subCommand.ToLower() == "all")
  146. {
  147. allReqs = true;
  148. }
  149. else
  150. {
  151. MainConsole.Instance.Output("You must specify in, out or all");
  152. return;
  153. }
  154. if (cmdparams.Length >= 4)
  155. {
  156. string rawNewDebug = cmdparams[3];
  157. int newDebug;
  158. if (!int.TryParse(rawNewDebug, out newDebug))
  159. {
  160. MainConsole.Instance.OutputFormat("{0} is not a valid debug level", rawNewDebug);
  161. return;
  162. }
  163. if (newDebug < 0 || newDebug > 6)
  164. {
  165. MainConsole.Instance.OutputFormat("{0} is outside the valid debug level range of 0..6", newDebug);
  166. return;
  167. }
  168. if (allReqs || inReqs)
  169. {
  170. MainServer.DebugLevel = newDebug;
  171. MainConsole.Instance.OutputFormat("IN debug level set to {0}", newDebug);
  172. }
  173. if (allReqs || outReqs)
  174. {
  175. WebUtil.DebugLevel = newDebug;
  176. MainConsole.Instance.OutputFormat("OUT debug level set to {0}", newDebug);
  177. }
  178. }
  179. else
  180. {
  181. if (allReqs || inReqs)
  182. MainConsole.Instance.OutputFormat("Current IN debug level is {0}", MainServer.DebugLevel);
  183. if (allReqs || outReqs)
  184. MainConsole.Instance.OutputFormat("Current OUT debug level is {0}", WebUtil.DebugLevel);
  185. }
  186. }
  187. private static void HandleShowHttpHandlersCommand(string module, string[] args)
  188. {
  189. if (args.Length != 2)
  190. {
  191. MainConsole.Instance.Output("Usage: show http-handlers");
  192. return;
  193. }
  194. StringBuilder handlers = new StringBuilder();
  195. lock (m_Servers)
  196. {
  197. foreach (BaseHttpServer httpServer in m_Servers.Values)
  198. {
  199. handlers.AppendFormat(
  200. "Registered HTTP Handlers for server at {0}:{1}\n", httpServer.ListenIPAddress, httpServer.Port);
  201. handlers.AppendFormat("* XMLRPC:\n");
  202. foreach (String s in httpServer.GetXmlRpcHandlerKeys())
  203. handlers.AppendFormat("\t{0}\n", s);
  204. handlers.AppendFormat("* HTTP:\n");
  205. foreach (String s in httpServer.GetHTTPHandlerKeys())
  206. handlers.AppendFormat("\t{0}\n", s);
  207. handlers.AppendFormat("* HTTP (poll):\n");
  208. foreach (String s in httpServer.GetPollServiceHandlerKeys())
  209. handlers.AppendFormat("\t{0}\n", s);
  210. handlers.AppendFormat("* JSONRPC:\n");
  211. foreach (String s in httpServer.GetJsonRpcHandlerKeys())
  212. handlers.AppendFormat("\t{0}\n", s);
  213. // handlers.AppendFormat("* Agent:\n");
  214. // foreach (String s in httpServer.GetAgentHandlerKeys())
  215. // handlers.AppendFormat("\t{0}\n", s);
  216. handlers.AppendFormat("* LLSD:\n");
  217. foreach (String s in httpServer.GetLLSDHandlerKeys())
  218. handlers.AppendFormat("\t{0}\n", s);
  219. handlers.AppendFormat("* StreamHandlers ({0}):\n", httpServer.GetStreamHandlerKeys().Count);
  220. foreach (String s in httpServer.GetStreamHandlerKeys())
  221. handlers.AppendFormat("\t{0}\n", s);
  222. handlers.Append("\n");
  223. }
  224. }
  225. MainConsole.Instance.Output(handlers.ToString());
  226. }
  227. /// <summary>
  228. /// Register an already started HTTP server to the collection of known servers.
  229. /// </summary>
  230. /// <param name='server'></param>
  231. public static void AddHttpServer(BaseHttpServer server)
  232. {
  233. lock (m_Servers)
  234. {
  235. if (m_Servers.ContainsKey(server.Port))
  236. throw new Exception(string.Format("HTTP server for port {0} already exists.", server.Port));
  237. m_Servers.Add(server.Port, server);
  238. }
  239. }
  240. /// <summary>
  241. /// Removes the http server listening on the given port.
  242. /// </summary>
  243. /// <remarks>
  244. /// It is the responsibility of the caller to do clean up.
  245. /// </remarks>
  246. /// <param name='port'></param>
  247. /// <returns></returns>
  248. public static bool RemoveHttpServer(uint port)
  249. {
  250. lock (m_Servers)
  251. {
  252. if (instance != null && instance.Port == port)
  253. instance = null;
  254. return m_Servers.Remove(port);
  255. }
  256. }
  257. /// <summary>
  258. /// Does this collection of servers contain one with the given port?
  259. /// </summary>
  260. /// <remarks>
  261. /// Unlike GetHttpServer, this will not instantiate a server if one does not exist on that port.
  262. /// </remarks>
  263. /// <param name='port'></param>
  264. /// <returns>true if a server with the given port is registered, false otherwise.</returns>
  265. public static bool ContainsHttpServer(uint port)
  266. {
  267. lock (m_Servers)
  268. return m_Servers.ContainsKey(port);
  269. }
  270. /// <summary>
  271. /// Get the default http server or an http server for a specific port.
  272. /// </summary>
  273. /// <remarks>
  274. /// If the requested HTTP server doesn't already exist then a new one is instantiated and started.
  275. /// </remarks>
  276. /// <returns></returns>
  277. /// <param name='port'>If 0 then the default HTTP server is returned.</param>
  278. public static IHttpServer GetHttpServer(uint port)
  279. {
  280. return GetHttpServer(port, null);
  281. }
  282. /// <summary>
  283. /// Get the default http server, an http server for a specific port
  284. /// and/or an http server bound to a specific address
  285. /// </summary>
  286. /// <remarks>
  287. /// If the requested HTTP server doesn't already exist then a new one is instantiated and started.
  288. /// </remarks>
  289. /// <returns></returns>
  290. /// <param name='port'>If 0 then the default HTTP server is returned.</param>
  291. /// <param name='ipaddr'>A specific IP address to bind to. If null then the default IP address is used.</param>
  292. public static IHttpServer GetHttpServer(uint port, IPAddress ipaddr)
  293. {
  294. if (port == 0)
  295. return Instance;
  296. if (instance != null && port == Instance.Port)
  297. return Instance;
  298. lock (m_Servers)
  299. {
  300. if (m_Servers.ContainsKey(port))
  301. return m_Servers[port];
  302. m_Servers[port] = new BaseHttpServer(port);
  303. if (ipaddr != null)
  304. m_Servers[port].ListenIPAddress = ipaddr;
  305. m_Servers[port].Start();
  306. return m_Servers[port];
  307. }
  308. }
  309. }
  310. }