llsdrpcclient.h
上传用户:king477883
上传日期:2021-03-01
资源大小:9553k
文件大小:9k
源码类别:

游戏引擎

开发平台:

C++ Builder

  1. /** 
  2.  * @file llsdrpcclient.h
  3.  * @author Phoenix
  4.  * @date 2005-11-05
  5.  * @brief Implementation and helpers for structure data RPC clients.
  6.  *
  7.  * $LicenseInfo:firstyear=2005&license=viewergpl$
  8.  * 
  9.  * Copyright (c) 2005-2010, Linden Research, Inc.
  10.  * 
  11.  * Second Life Viewer Source Code
  12.  * The source code in this file ("Source Code") is provided by Linden Lab
  13.  * to you under the terms of the GNU General Public License, version 2.0
  14.  * ("GPL"), unless you have obtained a separate licensing agreement
  15.  * ("Other License"), formally executed by you and Linden Lab.  Terms of
  16.  * the GPL can be found in doc/GPL-license.txt in this distribution, or
  17.  * online at http://secondlifegrid.net/programs/open_source/licensing/gplv2
  18.  * 
  19.  * There are special exceptions to the terms and conditions of the GPL as
  20.  * it is applied to this Source Code. View the full text of the exception
  21.  * in the file doc/FLOSS-exception.txt in this software distribution, or
  22.  * online at
  23.  * http://secondlifegrid.net/programs/open_source/licensing/flossexception
  24.  * 
  25.  * By copying, modifying or distributing this software, you acknowledge
  26.  * that you have read and understood your obligations described above,
  27.  * and agree to abide by those obligations.
  28.  * 
  29.  * ALL LINDEN LAB SOURCE CODE IS PROVIDED "AS IS." LINDEN LAB MAKES NO
  30.  * WARRANTIES, EXPRESS, IMPLIED OR OTHERWISE, REGARDING ITS ACCURACY,
  31.  * COMPLETENESS OR PERFORMANCE.
  32.  * $/LicenseInfo$
  33.  */
  34. #ifndef LL_LLSDRPCCLIENT_H
  35. #define LL_LLSDRPCCLIENT_H
  36. /** 
  37.  * This file declares classes to encapsulate a basic structured data
  38.  * remote procedure client.
  39.  */
  40. #include "llchainio.h"
  41. #include "llfiltersd2xmlrpc.h"
  42. #include "lliopipe.h"
  43. #include "llurlrequest.h"
  44. /** 
  45.  * @class LLSDRPCClientResponse
  46.  * @brief Abstract base class to represent a response from an SD server.
  47.  *
  48.  * This is used as a base class for callbacks generated from an
  49.  * structured data remote procedure call. The
  50.  * <code>extractResponse</code> method will deal with the llsdrpc method
  51.  * call overhead, and keep track of what to call during the next call
  52.  * into <code>process</code>. If you use this as a base class, you
  53.  * need to implement <code>response</code>, <code>fault</code>, and
  54.  * <code>error</code> to do something useful. When in those methods,
  55.  * you can parse and utilize the mReturnValue member data.
  56.  */
  57. class LLSDRPCResponse : public LLIOPipe
  58. {
  59. public:
  60. LLSDRPCResponse();
  61. virtual ~LLSDRPCResponse();
  62. /** 
  63.  * @brief This method extracts the response out of the sd passed in
  64.  *
  65.  * Any appropriate data found in the sd passed in will be
  66.  * extracted and managed by this object - not copied or cloned. It
  67.  * will still be up to the caller to delete the pointer passed in.
  68.  * @param sd The raw structured data response from the remote server.
  69.  * @return Returns true if this was able to parse the structured data.
  70.  */
  71. bool extractResponse(const LLSD& sd);
  72. protected:
  73. /** 
  74.  * @brief Method called when the response is ready.
  75.  */
  76. virtual bool response(LLPumpIO* pump) = 0;
  77. /** 
  78.  * @brief Method called when a fault is generated by the remote server.
  79.  */
  80. virtual bool fault(LLPumpIO* pump) = 0;
  81. /** 
  82.  * @brief Method called when there was an error
  83.  */
  84. virtual bool error(LLPumpIO* pump) = 0;
  85. protected:
  86. /* @name LLIOPipe virtual implementations
  87.  */
  88. //@{
  89. /** 
  90.  * @brief Process the data in buffer
  91.  */
  92. virtual EStatus process_impl(
  93. const LLChannelDescriptors& channels,
  94. buffer_ptr_t& buffer,
  95. bool& eos,
  96. LLSD& context,
  97. LLPumpIO* pump);
  98. //@}
  99. protected:
  100. LLSD mReturnValue;
  101. bool mIsError;
  102. bool mIsFault;
  103. };
  104. /** 
  105.  * @class LLSDRPCClient
  106.  * @brief Client class for a structured data remote procedure call.
  107.  *
  108.  * This class helps deal with making structured data calls to a remote
  109.  * server. You can visualize the calls as:
  110.  * <code>
  111.  * response = uri.method(parameter)
  112.  * </code>
  113.  * where you pass in everything to <code>call</code> and this class
  114.  * takes care of the rest of the details.
  115.  * In typical usage, you will derive a class from this class and
  116.  * provide an API more useful for the specific application at
  117.  * hand. For example, if you were writing a service to send an instant
  118.  * message, you could create an API for it to send the messsage, and
  119.  * that class would do the work of translating it into the method and
  120.  * parameter, find the destination, and invoke <code>call</call> with
  121.  * a useful implementation of LLSDRPCResponse passed in to handle the
  122.  * response from the network.
  123.  */
  124. class LLSDRPCClient : public LLIOPipe
  125. {
  126. public:
  127. LLSDRPCClient();
  128. virtual ~LLSDRPCClient();
  129. /** 
  130.  * @brief Enumeration for tracking which queue to process the
  131.  * response.
  132.  */
  133. enum EPassBackQueue
  134. {
  135. EPBQ_PROCESS,
  136. EPBQ_CALLBACK,
  137. };
  138. /** 
  139.  * @brief Call a method on a remote LLSDRPCServer
  140.  *
  141.  * @param uri The remote object to call, eg,
  142.  * http://localhost/usher. If you are using a factory with a fixed
  143.  * url, the uri passed in will probably be ignored.
  144.  * @param method The method to call on the remote object
  145.  * @param parameter The parameter to pass into the remote
  146.  * object. It is up to the caller to delete the value passed in.
  147.  * @param response The object which gets the response.
  148.  * @param queue Specifies to call the response on the process or
  149.  * callback queue.
  150.  * @return Returns true if this object will be able to make the RPC call.
  151.  */
  152. bool call(
  153. const std::string& uri,
  154. const std::string& method,
  155. const LLSD& parameter,
  156. LLSDRPCResponse* response,
  157. EPassBackQueue queue);
  158. /** 
  159.  * @brief Call a method on a remote LLSDRPCServer
  160.  *
  161.  * @param uri The remote object to call, eg,
  162.  * http://localhost/usher. If you are using a factory with a fixed
  163.  * url, the uri passed in will probably be ignored.
  164.  * @param method The method to call on the remote object
  165.  * @param parameter The seriailized parameter to pass into the
  166.  * remote object.
  167.  * @param response The object which gets the response.
  168.  * @param queue Specifies to call the response on the process or
  169.  * callback queue.
  170.  * @return Returns true if this object will be able to make the RPC call.
  171.  */
  172. bool call(
  173. const std::string& uri,
  174. const std::string& method,
  175. const std::string& parameter,
  176. LLSDRPCResponse* response,
  177. EPassBackQueue queue);
  178. protected:
  179. /** 
  180.  * @brief Enumeration for tracking client state.
  181.  */
  182. enum EState
  183. {
  184. STATE_NONE,
  185. STATE_READY,
  186. STATE_WAITING_FOR_RESPONSE,
  187. STATE_DONE
  188. };
  189. /* @name LLIOPipe virtual implementations
  190.  */
  191. //@{
  192. /** 
  193.  * @brief Process the data in buffer
  194.  */
  195. virtual EStatus process_impl(
  196. const LLChannelDescriptors& channels,
  197. buffer_ptr_t& buffer,
  198. bool& eos,
  199. LLSD& context,
  200. LLPumpIO* pump);
  201. //@}
  202. protected:
  203. EState mState;
  204. std::string mURI;
  205. std::string mRequest;
  206. EPassBackQueue mQueue;
  207. LLIOPipe::ptr_t mResponse;
  208. };
  209. /** 
  210.  * @class LLSDRPCClientFactory
  211.  * @brief Basic implementation for making an SD RPC client factory
  212.  *
  213.  * This class eases construction of a basic sd rpc client. Here is an
  214.  * example of it's use:
  215.  * <code>
  216.  *  class LLUsefulService : public LLService { ... }
  217.  *  LLService::registerCreator(
  218.  *    "useful",
  219.  *    LLService::creator_t(new LLSDRPCClientFactory<LLUsefulService>))
  220.  * </code>
  221.  */
  222. template<class Client>
  223. class LLSDRPCClientFactory : public LLChainIOFactory
  224. {
  225. public:
  226. LLSDRPCClientFactory() {}
  227. LLSDRPCClientFactory(const std::string& fixed_url) : mURL(fixed_url) {}
  228. virtual bool build(LLPumpIO::chain_t& chain, LLSD context) const
  229. {
  230. lldebugs << "LLSDRPCClientFactory::build" << llendl;
  231. LLIOPipe::ptr_t service(new Client);
  232. chain.push_back(service);
  233. LLURLRequest* http(new LLURLRequest(LLURLRequest::HTTP_POST));
  234. LLIOPipe::ptr_t http_pipe(http);
  235. http->addHeader("Content-Type: text/llsd");
  236. if(mURL.empty())
  237. {
  238. chain.push_back(LLIOPipe::ptr_t(new LLContextURLExtractor(http)));
  239. }
  240. else
  241. {
  242. http->setURL(mURL);
  243. }
  244. chain.push_back(http_pipe);
  245. chain.push_back(service);
  246. return true;
  247. }
  248. protected:
  249. std::string mURL;
  250. };
  251. /** 
  252.  * @class LLXMLSDRPCClientFactory
  253.  * @brief Basic implementation for making an XMLRPC to SD RPC client factory
  254.  *
  255.  * This class eases construction of a basic sd rpc client which uses
  256.  * xmlrpc as a serialization grammar. Here is an example of it's use:
  257.  * <code>
  258.  *  class LLUsefulService : public LLService { ... }
  259.  *  LLService::registerCreator(
  260.  *    "useful",
  261.  *    LLService::creator_t(new LLXMLSDRPCClientFactory<LLUsefulService>))
  262.  * </code>
  263.  */
  264. template<class Client>
  265. class LLXMLSDRPCClientFactory : public LLChainIOFactory
  266. {
  267. public:
  268. LLXMLSDRPCClientFactory() {}
  269. LLXMLSDRPCClientFactory(const std::string& fixed_url) : mURL(fixed_url) {}
  270. virtual bool build(LLPumpIO::chain_t& chain, LLSD context) const
  271. {
  272. lldebugs << "LLXMLSDRPCClientFactory::build" << llendl;
  273. LLIOPipe::ptr_t service(new Client);
  274. chain.push_back(service);
  275. LLURLRequest* http(new LLURLRequest(LLURLRequest::HTTP_POST));
  276. LLIOPipe::ptr_t http_pipe(http);
  277. http->addHeader("Content-Type: text/xml");
  278. if(mURL.empty())
  279. {
  280. chain.push_back(LLIOPipe::ptr_t(new LLContextURLExtractor(http)));
  281. }
  282. else
  283. {
  284. http->setURL(mURL);
  285. }
  286. chain.push_back(LLIOPipe::ptr_t(new LLFilterSD2XMLRPCRequest(NULL)));
  287. chain.push_back(http_pipe);
  288. chain.push_back(LLIOPipe::ptr_t(new LLFilterXMLRPCResponse2LLSD));
  289. chain.push_back(service);
  290. return true;
  291. }
  292. protected:
  293. std::string mURL;
  294. };
  295. #endif // LL_LLSDRPCCLIENT_H