source: trunk/src/halXmlRpc.cpp @ 268

Revision 268, 6.9 KB checked in by Eoin, 13 years ago (diff)

Added copyright eventually.

Line 
1
2//         Copyright Eóin O'Callaghan 2006 - 2007.
3// Distributed under the Boost Software License, Version 1.0.
4//    (See accompanying file LICENSE_1_0.txt or copy at
5//          http://www.boost.org/LICENSE_1_0.txt)
6
7#include "stdAfx.hpp"
8
9#include <string>
10
11#include <boost/thread/thread.hpp>
12#include <boost/thread/mutex.hpp>
13#include <boost/thread/recursive_mutex.hpp>
14#include <boost/thread/xtime.hpp>
15#include <boost/thread/condition.hpp>
16#include <boost/thread/tss.hpp>
17#include <boost/format.hpp>
18#include <boost/bind.hpp>
19
20#include <http/xmlrpc/server.hpp>
21
22#include "halXmlRpc.hpp"
23//#include "halTorrent.hpp"
24
25using namespace std;
26using namespace boost;
27using namespace http;
28using namespace http::xmlrpc;
29
30namespace hal
31{
32
33        XmlRpc& xmlRpc()
34        {
35                static XmlRpc x;
36                return x;
37        }
38       
39        class XmlRpc::XmlRpc_impl
40        {
41                friend class XmlRpc;
42               
43        private:
44                XmlRpc_impl() :
45                        hostRunning(false)
46                {}
47               
48                void host_procedure()
49                {
50                        try
51                        {               
52                        hostRunning = true;
53                        theHost.run();
54                        hostRunning = false;           
55                        }
56                        catch(const exception&)
57                        {
58                       
59                        }       
60                }
61               
62                host theHost;
63                bool hostRunning;
64                scoped_ptr<thread> hostThread;
65        };
66       
67        XmlRpc::XmlRpc() :
68                pimpl(new XmlRpc::XmlRpc_impl())
69        {}
70       
71        void XmlRpc::bindHost(short port)
72        {
73                if (!pimpl->hostRunning)
74                {
75                        pimpl->theHost.bind_to(port);
76                        pimpl->theHost.run();
77                }
78                else
79                {
80                        rebindHost(port);
81                }
82        }
83       
84        void XmlRpc::rebindHost(short port)
85        {
86                pimpl->theHost.unbind();
87                pimpl->theHost.bind_to(port);
88        }
89       
90        void XmlRpc::stopHost()
91        {
92                pimpl->theHost.stop();
93        }
94       
95//      static http::host host(80, 443);
96//      static shared_ptr<thread> host_thread;
97       
98/*      class GetTorrentDetail_vec : public XmlRpcServerMethod
99        {
100        public:
101                GetTorrentDetail_vec(XmlRpcServer* s) :
102                        XmlRpcServerMethod("getTorrentDetail_vec", s)
103                {}
104       
105                void execute(XmlRpcValue& params, XmlRpcValue& result)
106                {
107                        int nArgs = params.size();
108                       
109                        hal::torrentBriefDetails tbd = hal::getTorrents();
110                        if (tbd)
111                        {                               
112                                for(size_t i=0; i<tbd->size(); i++)
113                                {
114                                        wstring details = (wformat(L"%1$.2f%%, (D-U) %2$.2f-%3$.2f kb/s")
115                                                % ((*tbd)[i].completion * 100)
116                                                % ((*tbd)[i].speed.first/1024)
117                                                % ((*tbd)[i].speed.second/1024)
118                                                ).str();
119                                               
120                                        result[i][0] = hal::wcstombs((*tbd)[i].filename);
121                                        result[i][1] = hal::wcstombs(details);
122                                }
123                        }
124                }
125       
126                std::string help() { return std::string("Get Torrent Details"); }
127       
128        } getTorrentDetail_vec(&Server);
129       
130        class GetPausedTorrents : public XmlRpcServerMethod
131        {
132        public:
133                GetPausedTorrents(XmlRpcServer* s) :
134                        XmlRpcServerMethod("getPausedTorrents", s)
135                {}
136       
137                void execute(XmlRpcValue& params, XmlRpcValue& result)
138                {
139                        int nArgs = params.size();
140                       
141                        hal::torrentBriefDetails tbd = hal::getTorrents();
142                        if (tbd)
143                        {               
144                                size_t j = 0;                           
145                                for(size_t i=0; i<tbd->size(); i++)
146                                {
147                                        if ((*tbd)[i].status == L"Paused")                                     
148                                                result[j++] = hal::wcstombs((*tbd)[i].filename);
149                                }
150                        }
151                }
152       
153                std::string help() { return std::string("Get Paused Torrents"); }
154       
155        } getPausedTorrents(&Server);
156       
157        class GetActiveTorrents : public XmlRpcServerMethod
158        {
159        public:
160                GetActiveTorrents(XmlRpcServer* s) :
161                        XmlRpcServerMethod("getActiveTorrents", s)
162                {}
163       
164                void execute(XmlRpcValue& params, XmlRpcValue& result)
165                {
166                        int nArgs = params.size();
167                       
168                        hal::torrentBriefDetails tbd = hal::getTorrents();
169                        if (tbd)
170                        {               
171                                size_t j = 0;                           
172                                for(size_t i=0; i<tbd->size(); i++)
173                                {
174                                        if ((*tbd)[i].status != L"Paused")                                     
175                                                result[j++] = hal::wcstombs((*tbd)[i].filename);
176                                }
177                        }
178                }
179       
180                std::string help() { return std::string("Get Active Torrents"); }
181       
182        } getActiveTorrents(&Server);
183       
184        class ResumeTorrent : public XmlRpcServerMethod
185        {
186        public:
187                ResumeTorrent(XmlRpcServer* s) :
188                        XmlRpcServerMethod("resumeTorrent", s)
189                {}
190       
191                void execute(XmlRpcValue& params, XmlRpcValue& result)
192                {
193                        int nArgs = params.size();
194                        if (nArgs >= 2)
195                        {
196                                string filename = params[1];
197                                hal::resumeTorrent(hal::mbstowcs(filename));
198                        }                       
199                }
200       
201                std::string help() { return std::string("Resume Torrent"); }
202       
203        } resumeTorrent(&Server);
204       
205        class PauseTorrent : public XmlRpcServerMethod
206        {
207        public:
208                PauseTorrent(XmlRpcServer* s) :
209                        XmlRpcServerMethod("pauseTorrent", s)
210                {}
211       
212                void execute(XmlRpcValue& params, XmlRpcValue& result)
213                {
214                        int nArgs = params.size();
215                        if (nArgs >= 2)
216                        {
217                                string filename = params[1];
218                                hal::pauseTorrent(hal::mbstowcs(filename));
219                        }                       
220                }
221       
222                std::string help() { return std::string("Pause Torrent"); }
223       
224        } pauseTorrent(&Server);
225       
226        class Hello : public XmlRpcServerMethod
227        {
228        public:
229                Hello(XmlRpcServer* s) : XmlRpcServerMethod("Hello", s)
230                {}
231       
232                void execute(XmlRpcValue& params, XmlRpcValue& result)
233                {
234                        int nArgs = params.size();
235//                      Log(wformat(L"%1%\r\n") % nArgs);
236                       
237                        for (int i=0; i<nArgs; ++i)
238                        {
239                                switch (params[i].getType())
240                                {
241                                        case XmlRpcValue::TypeInt:                     
242//                                              Log(wformat(L" %1%) Int:%2%\r\n") % i % int(params[i]));
243                                        break;
244                                       
245                                        case XmlRpcValue::TypeString:                   
246//                                              Log(wformat(L" %1%) String\r\n") % i);
247                                        break;
248                                       
249                                        case XmlRpcValue::TypeArray:                   
250//                                              Log(wformat(L" %1%) Array\r\n") % i);
251                                        break;
252                                       
253                                }
254                        }
255                       
256                        string resultstring = "Wayhaa";
257                        result[0] = resultstring;
258                        result[1] = 123;
259                        result[2][0] = 123;
260                        result[2][1] = "Hi";
261                }
262       
263                std::string help() { return std::string("Say hello"); }
264       
265        } hello(&Server);
266       
267        class Close : public XmlRpcServerMethod
268        {
269        public:
270                Close(XmlRpcServer* s) : XmlRpcServerMethod("close", s)
271                {}
272       
273                void execute(XmlRpcValue& params, XmlRpcValue& result)
274                {}
275       
276                std::string help() { return std::string("Close Halite"); }
277       
278        } close(&Server);
279       
280        void RunServer()
281        {
282//              Log(wformat(L"Running Server.\r\n"));
283               
284                Server.bindAndListen(Port);
285               
286                // Enable introspection
287                Server.enableIntrospection(true);
288               
289                // Wait for requests indefinitely
290                Server.work(-1.0);
291         
292//              Log(wformat(L"Shutting down server.\r\n"));     
293        }
294*/
295
296        void host_procedure()
297        {
298                try
299                {
300               
301                cout << "Running server...\r\n";
302//              host.run();
303       
304                cout << "Finished\r\n";
305               
306                }
307                catch(const exception&)
308                {
309//              cout << format("Thread Error: %1%.\r\n") % e.what();
310                }       
311        }
312       
313        bool initServer(int port)
314        {
315                try
316                {
317               
318/*              http::xmlrpc::procedure_manager& man = http::server::add_xmlrpc_handler(host, "/xmlrpc");
319                man.add_procedure("RemoteMethod", &remote_method);
320               
321                cout << "Initializing Host thread.\r\n";       
322               
323                host_tread.reset(new thread(&host_procedure));
324*/             
325                }
326                catch(const exception&)
327                {
328//              cout << format("Main Error: %1%.\r\n") % e.what();
329                }               
330               
331                return true;
332        }
333       
334        void exitServer()
335        {
336//              host_tread.reset();
337        }
338       
339}
Note: See TracBrowser for help on using the repository browser.