← Back to branch summary

~ubuntu-branches/ubuntu/maverick/libtorrent-rasterbar/maverick

« back to all changes in this revision

Viewing changes to bindings/python/src/session.cpp

  • Committer: Bazaar Package Importer
  • Author(s): Cristian Greco
  • Date: 2008-07-02 10:46:21 UTC
  • Revision ID: james.westby@ubuntu.com-20080702104621-jzx3pfke9lkcxfxn
Tags: upstream-0.13.1
Import upstream version 0.13.1

Show diffs side-by-side

added added

removed removed

Lines of Context:
bindings/python/src/session.cpp
 
1
// Copyright Daniel Wallin, Arvid Norberg 2006. Use, modification and distribution is
 
2
// subject to the Boost Software License, Version 1.0. (See accompanying
 
3
// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
 
4
 
 
5
#include <libtorrent/session.hpp>
 
6
#include <libtorrent/torrent.hpp>
 
7
#include <libtorrent/storage.hpp>
 
8
#include <libtorrent/ip_filter.hpp>
 
9
#include <boost/python.hpp>
 
10
#include "gil.hpp"
 
11
 
 
12
using namespace boost::python;
 
13
using namespace libtorrent;
 
14
 
 
15
extern char const* session_status_doc;
 
16
extern char const* session_status_has_incoming_connections_doc;
 
17
extern char const* session_status_upload_rate_doc;
 
18
extern char const* session_status_download_rate_doc;
 
19
extern char const* session_status_payload_upload_rate_doc;
 
20
extern char const* session_status_payload_download_rate_doc;
 
21
extern char const* session_status_total_download_doc;
 
22
extern char const* session_status_total_upload_doc;
 
23
extern char const* session_status_total_payload_download_doc;
 
24
extern char const* session_status_total_payload_upload_doc;
 
25
extern char const* session_status_num_peers_doc;
 
26
extern char const* session_status_dht_nodes_doc;
 
27
extern char const* session_status_cache_nodes_doc;
 
28
extern char const* session_status_dht_torrents_doc;
 
29
 
 
30
extern char const* session_doc;
 
31
extern char const* session_init_doc;
 
32
extern char const* session_listen_on_doc;
 
33
extern char const* session_is_listening_doc;
 
34
extern char const* session_listen_port_doc;
 
35
extern char const* session_status_m_doc;
 
36
extern char const* session_start_dht_doc;
 
37
extern char const* session_stop_dht_doc;
 
38
extern char const* session_dht_state_doc;
 
39
extern char const* session_add_dht_router_doc;
 
40
extern char const* session_add_torrent_doc;
 
41
extern char const* session_remove_torrent_doc;
 
42
extern char const* session_set_download_rate_limit_doc;
 
43
extern char const* session_download_rate_limit_doc;
 
44
extern char const* session_set_upload_rate_limit_doc;
 
45
extern char const* session_upload_rate_limit_doc;
 
46
extern char const* session_set_max_uploads_doc;
 
47
extern char const* session_set_max_connections_doc;
 
48
extern char const* session_set_max_half_open_connections_doc;
 
49
extern char const* session_num_connections_doc;
 
50
extern char const* session_set_settings_doc;
 
51
extern char const* session_set_pe_settings_doc;
 
52
extern char const* session_get_pe_settings_doc; 
 
53
extern char const* session_set_severity_level_doc;
 
54
extern char const* session_pop_alert_doc;
 
55
extern char const* session_start_upnp_doc;
 
56
extern char const* session_start_lsd_doc;
 
57
extern char const* session_stop_lsd_doc;
 
58
extern char const* session_stop_upnp_doc;
 
59
extern char const* session_start_natpmp_doc;
 
60
extern char const* session_stop_natpmp_doc;
 
61
extern char const* session_set_ip_filter_doc;
 
62
 
 
63
namespace
 
64
{
 
65
 
 
66
  bool listen_on(session& s, int min_, int max_, char const* interface)
 
67
  {
 
68
      allow_threading_guard guard;
 
69
      return s.listen_on(std::make_pair(min_, max_), interface);
 
70
  }
 
71
 
 
72
#ifndef TORRENT_DISABLE_DHT
 
73
  void add_dht_router(session& s, std::string router_, int port_)
 
74
  {
 
75
      allow_threading_guard guard;
 
76
      return s.add_dht_router(std::make_pair(router_, port_));
 
77
  }
 
78
#endif
 
79
 
 
80
  struct invoke_extension_factory
 
81
  {
 
82
      invoke_extension_factory(object const& callback)
 
83
        : cb(callback)
 
84
      {}
 
85
 
 
86
      boost::shared_ptr<torrent_plugin> operator()(torrent* t, void*)
 
87
      {
 
88
          lock_gil lock;
 
89
          return extract<boost::shared_ptr<torrent_plugin> >(cb(ptr(t)))();
 
90
      }
 
91
 
 
92
      object cb;
 
93
  };
 
94
 
 
95
  void add_extension(session& s, object const& e)
 
96
  {
 
97
      allow_threading_guard guard;
 
98
      s.add_extension(invoke_extension_factory(e));
 
99
  }
 
100
 
 
101
  torrent_handle add_torrent(session& s, torrent_info const& ti
 
102
    , boost::filesystem::path const& save, entry const& resume
 
103
    , storage_mode_t storage_mode, bool paused)
 
104
  {
 
105
    allow_threading_guard guard;
 
106
    return s.add_torrent(ti, save, resume, storage_mode, paused, default_storage_constructor);
 
107
  }
 
108
  
 
109
} // namespace unnamed
 
110
 
 
111
void bind_session()
 
112
{
 
113
    class_<session_status>("session_status", session_status_doc)
 
114
        .def_readonly(
 
115
            "has_incoming_connections", &session_status::has_incoming_connections
 
116
          , session_status_has_incoming_connections_doc
 
117
        )
 
118
        .def_readonly(
 
119
            "upload_rate", &session_status::upload_rate
 
120
          , session_status_upload_rate_doc
 
121
        )
 
122
        .def_readonly(
 
123
            "download_rate", &session_status::download_rate
 
124
          , session_status_download_rate_doc
 
125
        )
 
126
        .def_readonly(
 
127
            "payload_upload_rate", &session_status::payload_upload_rate
 
128
          , session_status_payload_upload_rate_doc
 
129
        )
 
130
        .def_readonly(
 
131
            "payload_download_rate", &session_status::payload_download_rate
 
132
          , session_status_payload_download_rate_doc
 
133
        )
 
134
        .def_readonly(
 
135
            "total_download", &session_status::total_download
 
136
          , session_status_total_download_doc
 
137
        )
 
138
        .def_readonly(
 
139
            "total_upload", &session_status::total_upload
 
140
          , session_status_total_upload_doc
 
141
        )
 
142
        .def_readonly(
 
143
            "total_payload_download", &session_status::total_payload_download
 
144
          , session_status_total_payload_download_doc
 
145
        )
 
146
        .def_readonly(
 
147
            "total_payload_upload", &session_status::total_payload_upload
 
148
          , session_status_total_payload_upload_doc
 
149
        )
 
150
        .def_readonly(
 
151
            "num_peers", &session_status::num_peers
 
152
          , session_status_num_peers_doc
 
153
        )
 
154
#ifndef TORRENT_DISABLE_DHT
 
155
        .def_readonly(
 
156
            "dht_nodes", &session_status::dht_nodes
 
157
          , session_status_dht_nodes_doc
 
158
        )
 
159
        .def_readonly(
 
160
            "dht_cache_nodes", &session_status::dht_node_cache
 
161
          , session_status_cache_nodes_doc
 
162
        )
 
163
        .def_readonly(
 
164
            "dht_torrents", &session_status::dht_torrents
 
165
          , session_status_dht_torrents_doc
 
166
        )
 
167
#endif
 
168
        ;
 
169
 
 
170
    enum_<storage_mode_t>("storage_mode_t")
 
171
        .value("storage_mode_allocate", storage_mode_allocate)
 
172
        .value("storage_mode_compact", storage_mode_compact)
 
173
        .value("storage_mode_sparse", storage_mode_sparse)
 
174
    ;
 
175
 
 
176
    enum_<session::options_t>("options_t")
 
177
        .value("none", session::none)
 
178
        .value("delete_files", session::delete_files)
 
179
    ;
 
180
         
 
181
    class_<session, boost::noncopyable>("session", session_doc, no_init)
 
182
        .def(
 
183
            init<fingerprint>(arg("fingerprint")=fingerprint("LT",0,1,0,0), session_init_doc)
 
184
        )
 
185
        .def(
 
186
            "listen_on", &listen_on
 
187
          , (arg("min"), "max", arg("interface") = (char const*)0)
 
188
          , session_listen_on_doc
 
189
        )
 
190
        .def("is_listening", allow_threads(&session::is_listening), session_is_listening_doc)
 
191
        .def("listen_port", allow_threads(&session::listen_port), session_listen_port_doc)
 
192
        .def("status", allow_threads(&session::status), session_status_m_doc)
 
193
#ifndef TORRENT_DISABLE_DHT
 
194
        .def(
 
195
            "add_dht_router", &add_dht_router
 
196
          , (arg("router"), "port")
 
197
          , session_add_dht_router_doc
 
198
        )
 
199
        .def("start_dht", allow_threads(&session::start_dht), session_start_dht_doc)
 
200
        .def("stop_dht", allow_threads(&session::stop_dht), session_stop_dht_doc)
 
201
        .def("dht_state", allow_threads(&session::dht_state), session_dht_state_doc)
 
202
        .def("set_dht_proxy", allow_threads(&session::set_dht_proxy))
 
203
#endif
 
204
        .def(
 
205
            "add_torrent", &add_torrent
 
206
          , (
 
207
                arg("resume_data") = entry(), arg("storage_mode") = storage_mode_sparse,
 
208
                arg("paused") = false
 
209
            )
 
210
          , session_add_torrent_doc
 
211
        )
 
212
        .def("remove_torrent", allow_threads(&session::remove_torrent), arg("option") = session::none
 
213
                          , session_remove_torrent_doc)
 
214
        .def(
 
215
            "set_download_rate_limit", allow_threads(&session::set_download_rate_limit)
 
216
          , session_set_download_rate_limit_doc
 
217
        )
 
218
        .def(
 
219
            "download_rate_limit", allow_threads(&session::download_rate_limit)
 
220
          , session_download_rate_limit_doc
 
221
        )
 
222
 
 
223
        .def(
 
224
            "set_upload_rate_limit", allow_threads(&session::set_upload_rate_limit)
 
225
          , session_set_upload_rate_limit_doc
 
226
        )
 
227
        .def(
 
228
            "upload_rate_limit", allow_threads(&session::upload_rate_limit)
 
229
          , session_upload_rate_limit_doc
 
230
        )
 
231
 
 
232
        .def(
 
233
            "set_max_uploads", allow_threads(&session::set_max_uploads)
 
234
          , session_set_max_uploads_doc
 
235
        )
 
236
        .def(
 
237
            "set_max_connections", allow_threads(&session::set_max_connections)
 
238
          , session_set_max_connections_doc
 
239
        )
 
240
        .def(
 
241
            "set_max_half_open_connections", allow_threads(&session::set_max_half_open_connections)
 
242
          , session_set_max_half_open_connections_doc
 
243
        )
 
244
        .def(
 
245
            "num_connections", allow_threads(&session::num_connections)
 
246
          , session_num_connections_doc
 
247
        )
 
248
        .def("set_settings", allow_threads(&session::set_settings), session_set_settings_doc)
 
249
#ifndef TORRENT_DISABLE_ENCRYPTION
 
250
        .def("set_pe_settings", allow_threads(&session::set_pe_settings), session_set_pe_settings_doc)
 
251
        .def("get_pe_settings", allow_threads(&session::get_pe_settings), return_value_policy<copy_const_reference>())
 
252
#endif
 
253
        .def(
 
254
            "set_severity_level", allow_threads(&session::set_severity_level)
 
255
          , session_set_severity_level_doc
 
256
        )
 
257
        .def("pop_alert", allow_threads(&session::pop_alert), session_pop_alert_doc)
 
258
        .def("add_extension", &add_extension)
 
259
        .def("set_peer_proxy", allow_threads(&session::set_peer_proxy))
 
260
        .def("set_tracker_proxy", allow_threads(&session::set_tracker_proxy))
 
261
        .def("set_web_seed_proxy", allow_threads(&session::set_web_seed_proxy))
 
262
        .def("start_upnp", allow_threads(&session::start_upnp), session_start_upnp_doc)
 
263
        .def("stop_upnp", allow_threads(&session::stop_upnp), session_stop_upnp_doc)
 
264
        .def("start_lsd", allow_threads(&session::start_lsd), session_start_lsd_doc)
 
265
        .def("stop_lsd", allow_threads(&session::stop_lsd), session_stop_lsd_doc)
 
266
        .def("start_natpmp", allow_threads(&session::start_natpmp), session_start_natpmp_doc)
 
267
        .def("stop_natpmp", allow_threads(&session::stop_natpmp), session_stop_natpmp_doc)
 
268
        .def("set_ip_filter", allow_threads(&session::set_ip_filter), session_set_ip_filter_doc)
 
269
        ;
 
270
 
 
271
    register_ptr_to_python<std::auto_ptr<alert> >();
 
272
}
 
273
 
 
274