source: trunk/src/halTorrent.cpp @ 778

Revision 778, 26.1 KB checked in by Eoin, 10 years ago (diff)

Made get torrent details non-blocking. Need to do same for get session details.

Line 
1
2//         Copyright Eóin O'Callaghan 2006 - 2009.
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#include <functional>
9
10#include "global/wtl_app.hpp"
11#include "global/string_conv.hpp"
12#include "global/ini_adapter.hpp"
13
14#include "halTorrent.hpp"
15#include "halTypes.hpp"
16#include "halEvent.hpp"
17#include "halSignaler.hpp"
18
19#include "halTorrentInternal.hpp"
20#include "halTorrentManager.hpp"
21#include "halSession.hpp"
22#include "halConfig.hpp"
23
24namespace hal
25{
26        boost::optional<libt::session>* torrent_internal::the_session_ = 0;
27}
28
29namespace hal
30{
31
32/*bit& bittorrent()
33{
34        static bit t;
35        return t;
36}
37*/
38bool file_details::less(const file_details& r, size_t index) const
39{       
40        switch (index)
41        {
42        case branch_e: return branch < r.branch;
43        case filename_e: return filename < r.filename;
44
45        case type_e: return type < r.type;
46        case size_e: return size < r.size;
47
48        case progress_e: return (static_cast<double>(progress)/size) < (static_cast<double>(r.progress)/r.size);
49        case priority_e: return priority < r.priority;
50
51        default: return false; // ???
52        };
53}
54
55std::wstring file_details::to_wstring(size_t index)
56{
57        switch (index)
58        {
59        case branch_e: return branch.string();
60        case filename_e: return filename;
61
62        case type_e: return L"(Undefined)"; // ???
63
64        case size_e: return (wform(L"%1$.2fMB") % (static_cast<double>(size)/(1024*1024))).str();
65        case progress_e: return (wform(L"%1$.2f%%") % (static_cast<double>(progress)/size*100)).str(); 
66
67        case priority_e:               
68                {
69                        switch (priority)
70                        {
71                        case 0:
72                                return hal::app().res_wstr(HAL_FILE_PRIORITY_0);
73                        case 1:
74                                return hal::app().res_wstr(HAL_FILE_PRIORITY_1);
75                        case 2:
76                                return hal::app().res_wstr(HAL_FILE_PRIORITY_2);
77                        case 3:
78                                return hal::app().res_wstr(HAL_FILE_PRIORITY_3);
79                        case 4:
80                                return hal::app().res_wstr(HAL_FILE_PRIORITY_4);
81                        case 5:
82                                return hal::app().res_wstr(HAL_FILE_PRIORITY_5);
83                        case 6:
84                                return hal::app().res_wstr(HAL_FILE_PRIORITY_6);
85                        case 7:
86                                return hal::app().res_wstr(HAL_FILE_PRIORITY_7);
87                        default:
88                                return hal::app().res_wstr(HAL_FILE_PRIORITY_0);
89                        };
90                } 
91
92        default: return L"(Undefined)"; // ???
93        };
94}
95
96void file_details_sort(file_details_vec& p, size_t index, bool cmp_less)
97{
98        std::stable_sort(p.begin(), p.end(), 
99                bind(&hal_details_compare<const file_details&>, _1, _2, index, cmp_less));
100}
101
102const peer_details_vec& torrent_details::get_peer_details() const
103{
104        if (!peer_details_filled_)
105        {
106                bittorrent::Instance().get_all_peer_details(hal::to_utf8(name_), peer_details_);
107                peer_details_filled_ = true;
108        }
109       
110        return peer_details_;
111}
112
113const file_details_vec& torrent_details::get_file_details() const
114{
115        if (!file_details_filled_)
116        {
117                bittorrent::Instance().get_all_file_details(hal::to_utf8(name_), file_details_);
118                file_details_filled_ = true;
119        }
120       
121        return file_details_;
122}
123
124bool torrent_details::less(const torrent_details& r, size_t index) const
125{
126        switch (index)
127        {
128        case name_e: return name_ < r.name_;
129        case state_e: return state_ < r.state_;
130
131        case speed_down_e: return speed_.first < r.speed_.first;
132        case speed_up_e: return speed_.second < r.speed_.second;
133        case progress_e: return completion_ < r.completion_;
134        case distributed_copies_e: return distributed_copies_ < r.distributed_copies_;
135
136        case remaining_e: 
137                {
138                boost::int64_t left = total_wanted_-total_wanted_done_;
139                boost::int64_t right = r.total_wanted_-r.total_wanted_done_;
140
141                return left < right;
142                }
143
144        case total_wanted_e: return total_wanted_ < r.total_wanted_;
145        case completed_e: return total_wanted_done_ < r.total_wanted_done_; 
146
147        case uploaded_e: return total_payload_uploaded_ < r.total_payload_uploaded_;
148        case downloaded_e: return total_payload_downloaded_ < r.total_payload_downloaded_;
149
150        case peers_e: return peers_ < r.peers_;
151        case seeds_e: return seeds_ < r.seeds_;
152
153        case ratio_e: 
154                {
155                float left = (total_payload_downloaded_) 
156                                ? static_cast<float>(total_payload_uploaded_)
157                                        / static_cast<float>(total_payload_downloaded_)
158                                : 0;
159               
160                float right = (r.total_payload_downloaded_) 
161                                ? static_cast<float>(r.total_payload_uploaded_)
162                                        / static_cast<float>(r.total_payload_downloaded_)
163                                : 0;
164               
165                return left < right; 
166                }
167
168        case eta_e: return estimated_time_left_ < r.estimated_time_left_;
169        case tracker: return currentTracker_ < r.currentTracker_;
170        case update_tracker_in_e: return update_tracker_in_ < r.update_tracker_in_;
171
172        case active_time_e: return active_ < r.active_;
173        case seeding_time_e: return seeding_ < r.seeding_;
174        case start_time_e: return start_time_ < r.start_time_;
175        case finish_time_e: return finish_time_ < r.finish_time_;
176
177        case queue_position_e: return queue_position_ < r.queue_position_;
178        case managed_e: return managed_ < r.managed_;
179
180        default: return false; // ???
181        };
182}
183
184std::wstring torrent_details::to_wstring(size_t index)
185{
186        switch (index)
187        {
188        case name_e: return name_;
189        case state_e: return state_;
190
191        case progress_e: return (wform(L"%1$.2f%%") % (completion_*100)).str(); 
192        case speed_down_e: return (wform(L"%1$.2fkb/s") % (speed_.first/1024)).str(); 
193        case speed_up_e: return (wform(L"%1$.2fkb/s") % (speed_.second/1024)).str(); 
194
195        case distributed_copies_e: 
196                {
197                float copies = distributed_copies_;
198               
199                if (copies < 0)
200                        return L"Seeding"; 
201                else
202                        return (hal::wform(L"%1$.2f") % copies).str(); 
203                }
204
205        case remaining_e: 
206                {
207                return (wform(L"%1$.2fMB") % (static_cast<float>(total_wanted_-total_wanted_done_)/(1024*1024))).str(); 
208                }
209
210        case completed_e: return (wform(L"%1$.2fMB") % (static_cast<float>(total_wanted_done_)/(1024*1024))).str();
211
212        case total_wanted_e: 
213                {
214                return (wform(L"%1$.2fMB") % (static_cast<float>(total_wanted_-total_wanted_done_)/(1024*1024))).str(); 
215                }
216
217        case uploaded_e: 
218                {
219                return (wform(L"%1$.2fMB") % (static_cast<float>(total_payload_uploaded_)/(1024*1024))).str(); 
220                }
221
222        case downloaded_e: 
223                {
224                return (wform(L"%1$.2fMB") % (static_cast<float>(total_payload_downloaded_)/(1024*1024))).str(); 
225                }
226
227        case peers_e: return (wform(L"%1% (%2%)") % connected_peers_ % peers_).str(); 
228        case seeds_e: return (wform(L"%1% (%2%)") % connected_seeds_ % seeds_).str(); 
229
230        case ratio_e: 
231                {
232                        float ratio = (total_payload_downloaded_) 
233                                ? static_cast<float>(total_payload_uploaded_)
234                                        / static_cast<float>(total_payload_downloaded_)
235                                : 0;
236                       
237                        return (wform(L"%1$.2f") % ratio).str(); 
238                }
239
240        case eta_e: 
241                { 
242                if (!estimated_time_left_.is_special())
243                        return hal::from_utf8(
244                                boost::posix_time::to_simple_string(estimated_time_left_));
245                else
246                        return app().res_wstr(HAL_INF);         
247                }       
248
249        case tracker: return currentTracker_;
250
251        case update_tracker_in_e:               
252                { 
253                if (!update_tracker_in_.is_special())
254                        return from_utf8(
255                                boost::posix_time::to_simple_string(update_tracker_in_));
256                else
257                        return app().res_wstr(HAL_INF);         
258                }       
259
260        case active_time_e: 
261                {
262                if (!active_.is_special())
263                        return from_utf8(
264                                boost::posix_time::to_simple_string(active_));
265                else
266                        return app().res_wstr(HAL_INF);         
267                }
268
269        case seeding_time_e: 
270                { 
271                if (!seeding_.is_special())
272                        return from_utf8(
273                                boost::posix_time::to_simple_string(seeding_));
274                else
275                        return app().res_wstr(HAL_INF);
276                }       
277
278        case start_time_e: 
279                { 
280                if (!start_time_.is_special())
281                        return from_utf8(
282                                boost::posix_time::to_simple_string(start_time_));
283                else
284                        return app().res_wstr(IDS_NA);
285                }               
286
287        case finish_time_e:             
288                { 
289                if (!finish_time_.is_special())
290                        return from_utf8(
291                                boost::posix_time::to_simple_string(finish_time_));
292                else
293                        return app().res_wstr(IDS_NA); 
294                }               
295
296        case queue_position_e: 
297                {
298                        if (queue_position_ != -1)
299                                return (wform(L"%1%") % queue_position_).str(); 
300                        else
301                                return app().res_wstr(IDS_NA);         
302                }
303
304        case managed_e: return managed_ ?  L"Yes" : L"No";
305
306        default: return L"(Undefined)"; // ???
307        };
308}
309
310/*void torrent_details_manager::sort(size_t column_index, bool cmp_less) const
311{
312        std::stable_sort(torrents_.begin(), torrents_.end(),
313                bind(&hal_details_ptr_compare<torrent_details_ptr>, _1, _2, column_index, cmp_less));
314}*/
315
316web_seed_or_dht_node_detail::web_seed_or_dht_node_detail() : 
317        url(L""), 
318        port(-1), 
319        type(hal::app().res_wstr(HAL_INT_NEWT_ADD_PEERS_WEB)) 
320{}
321
322web_seed_or_dht_node_detail::web_seed_or_dht_node_detail(std::wstring u) : 
323        url(u), 
324        port(-1), 
325        type(hal::app().res_wstr(HAL_INT_NEWT_ADD_PEERS_WEB)) 
326{}
327
328web_seed_or_dht_node_detail::web_seed_or_dht_node_detail(std::wstring u, int p) : 
329        url(u), 
330        port(p), 
331        type(hal::app().res_wstr(HAL_INT_NEWT_ADD_PEERS_DHT)) 
332{}
333
334bit::bit() :
335        pimpl_(new bit_impl())
336{}
337
338bit::~bit()
339{}
340
341bit_impl* bit::pimpl()
342{
343        if (!pimpl_) throw std::runtime_error("bittorrent() accessed after destructer");
344
345        return &*pimpl_;
346}
347
348const bit_impl* bit::pimpl() const
349{
350        if (!pimpl_) throw std::runtime_error("bittorrent() accessed after destructer");
351
352        return &*pimpl_;
353}
354
355void bit::shutdown_session()
356{
357        HAL_DEV_MSG(L"Commence shutdown_session()"); 
358
359        pimpl_.reset();
360
361        HAL_DEV_MSG(L"End shutdown_session()"); 
362}
363
364void bit::save_torrent_data()
365{
366        pimpl()->save_torrent_data();
367}
368
369bool bit::create_torrent(const create_torrent_params& params, fs::wpath out_file, progress_callback fn)
370{
371        return pimpl()->create_torrent(params, out_file, fn);
372}
373
374bit::torrent bit::get_wstr(const std::wstring& filename)
375{
376        return bit::torrent(pimpl()->the_torrents_.get(filename));
377}
378
379bool bit::listen_on(std::pair<int, int> const& range)
380{
381        return pimpl()->listen_on(range);
382}
383
384int bit::is_listening_on() 
385{
386        return pimpl()->is_listening_on();
387}
388
389void bit::stop_listening()
390{
391        pimpl()->stop_listening();
392}
393
394bool bit::ensure_dht_on(const hal::dht_settings& dht)
395{
396        return pimpl()->ensure_dht_on(dht);
397}
398
399void bit::ensure_dht_off()
400{
401        pimpl()->ensure_dht_off();
402}
403
404void bit::set_mapping(bool upnp, bool nat_pmp)
405{
406        pimpl()->set_mapping(upnp, nat_pmp);
407}
408
409std::wstring bit::upnp_router_model()
410{
411        return pimpl()->upnp_router_model();
412}
413
414queue_settings bit::get_queue_settings()
415{
416        return pimpl()->get_queue_settings();
417}
418
419void bit::set_queue_settings(const queue_settings& s)
420{
421        pimpl()->set_queue_settings(s);
422}
423
424timeouts bit::get_timeouts()
425{
426        return pimpl()->get_timeouts();
427}
428
429void bit::set_timeouts(const timeouts& t)
430{
431        pimpl()->set_timeouts(t);
432}
433
434void bit::set_session_limits(int maxConn, int maxUpload)
435{               
436        pimpl()->set_session_limits(maxConn, maxUpload);
437}
438
439void bit::set_session_speed(float download, float upload)
440{
441        pimpl()->set_session_speed(download, upload);
442}
443
444bool bit::ensure_ip_filter_on(progress_callback fn)
445{
446        return pimpl()->ensure_ip_filter_on(fn);
447}
448
449void bit::ensure_ip_filter_off()
450{
451        pimpl()->ensure_ip_filter_off();
452}
453
454void bit::set_resolve_countries(bool b)
455{
456        pimpl()->set_resolve_countries(b);
457}
458
459void bit::start_smart_ban_plugin()
460{
461        pimpl()->start_smart_ban_plugin();
462}
463
464void bit::start_ut_pex_plugin()
465{
466        pimpl()->start_ut_pex_plugin();
467}
468
469void bit::start_ut_metadata_plugin()
470{
471        pimpl()->start_ut_metadata_plugin();
472}
473
474void bit::start_metadata_plugin()
475{
476        pimpl()->start_metadata_plugin();
477}
478
479#ifndef TORRENT_DISABLE_ENCRYPTION     
480
481void bit::ensure_pe_on(const pe_settings& pe)
482{
483        pimpl()->ensure_pe_on(pe);
484}
485
486void bit::ensure_pe_off()
487{
488        pimpl()->ensure_pe_off();
489}
490#endif
491
492void bit::ip_v4_filter_block(boost::asio::ip::address_v4 first, boost::asio::ip::address_v4 last)
493{
494        pimpl()->ip_filter_.add_rule(first, last, libt::ip_filter::blocked);
495        pimpl()->ip_filter_count();
496        pimpl()->ip_filter_changed_ = true;
497}
498
499void bit::ip_v6_filter_block(boost::asio::ip::address_v6 first, boost::asio::ip::address_v6 last)
500{
501        pimpl()->ip_v6_filter_block(first, last);
502}
503
504size_t bit::ip_filter_size()
505{
506        return pimpl()->ip_filter_size();
507}
508
509void bit::clear_ip_filter()
510{
511        pimpl()->clear_ip_filter();
512}
513
514bool bit::ip_filter_import_dat(boost::filesystem::path file, progress_callback fn, bool octalFix)
515{
516        return pimpl()->ip_filter_import_dat(file, fn, octalFix);
517}
518
519const SessionDetail bit::get_session_details()
520{
521        SessionDetail details;
522       
523        details.port = pimpl()->session_->is_listening() ? pimpl()->session_->listen_port() : -1;
524       
525        libt::session_status status = pimpl()->session_->status();
526       
527        details.speed = std::pair<double, double>(status.download_rate, status.upload_rate);
528       
529        details.dht_on = pimpl()->dht_on_;
530        details.dht_nodes = status.dht_nodes;
531        details.dht_torrents = status.dht_torrents;
532       
533        details.ip_filter_on = pimpl()->ip_filter_on_;
534        details.ip_ranges_filtered = pimpl()->ip_filter_count_;
535       
536        return details;
537}
538
539void bit::set_session_half_open_limit(int halfConn)
540{
541        pimpl()->session_->set_max_half_open_connections(halfConn);
542
543        event_log().post(shared_ptr<EventDetail>(new EventMsg(
544                hal::wform(L"Set half-open connections limit to %1%.") % pimpl()->session_->max_half_open_connections())));
545}
546
547void bit::set_torrent_defaults(const connections& defaults)
548{
549        pimpl()->default_torrent_max_connections_ = defaults.total;
550        pimpl()->default_torrent_max_uploads_ = defaults.uploads;
551
552        event_log().post(shared_ptr<EventDetail>(new EventMsg(
553                hal::wform(L"Set torrent connections total %1% and uploads %2%.") 
554                        % defaults.total % defaults.uploads)));
555
556        pimpl()->default_torrent_download_ = defaults.download_rate;
557        pimpl()->default_torrent_upload_ = defaults.upload_rate;
558
559        event_log().post(shared_ptr<EventDetail>(new EventMsg(
560                hal::wform(L"Set torrent default rates at %1$.2fkb/s down and %2$.2fkb/s upload.") 
561                        % defaults.download_rate % defaults.upload_rate)));
562}
563
564void bit::add_torrent(wpath file, wpath saveDirectory, bool startStopped, bool managed, allocations alloc, 
565                boost::filesystem::wpath moveToDirectory) 
566{
567        pimpl()->add_torrent(file, saveDirectory, startStopped, managed, alloc, moveToDirectory);
568}
569
570const torrent_details_manager& bit::torrentDetails()
571{
572        return torrentDetails_;
573}
574
575const torrent_details_manager& bit::update_torrent_details_manager(const wstring& focused, const std::set<wstring>& selected)
576{
577        try {
578
579        boost::thread(bind(&bit::update_torrent_details_manager_thread, this, focused, selected));
580       
581        } HAL_GENERIC_TORRENT_EXCEPTION_CATCH("Torrent Unknown!", "updatetorrent_details_manager")
582       
583        return torrentDetails_;
584}
585
586void bit::update_torrent_details_manager_thread(const wstring& focused, const std::set<wstring>& selected)
587{
588        try {   
589
590        torrent_details_map tmp_map;
591       
592        for (torrent_manager::torrent_by_name::iterator i=pimpl()->the_torrents_.begin(), e=pimpl()->the_torrents_.end(); i != e; ++i)
593        {
594                torrent_details_ptr pT = (*i).torrent->get_torrent_details_ptr();                               
595                tmp_map[(*i).torrent->name()] = pT;
596        }
597
598        {
599               
600        mutex_t::scoped_lock l(torrentDetails_.mutex_);
601
602        torrentDetails_.clear_all(l);   
603        torrentDetails_.focused_ = focused;
604        torrentDetails_.selected_names_ = selected;
605
606        std::swap(tmp_map, torrentDetails_.torrent_map_);
607
608        }
609       
610        } HAL_GENERIC_TORRENT_EXCEPTION_CATCH("Torrent Unknown!", "updatetorrent_details_manager")
611}
612
613void bit::resume_all()
614{
615        pimpl()->resume_all();
616}
617
618void bit::close_all(boost::optional<report_num_active> fn)
619{
620        pimpl()->close_all(fn);
621}
622
623const cache_details bit::get_cache_details() const
624{
625        return pimpl()->get_cache_details();
626}
627
628void bit::get_all_peer_details(const std::string& filename, peer_details_vec& peer_container)
629{
630        get_all_peer_details(from_utf8_safe(filename), peer_container);
631}
632
633void bit::get_all_peer_details(const std::wstring& filename, peer_details_vec& peer_container)
634{
635        try {
636       
637        pimpl()->the_torrents_.get(filename)->get_peer_details(peer_container);
638       
639        } HAL_GENERIC_TORRENT_EXCEPTION_CATCH(filename, "get_all_peer_details")
640}
641
642void bit::get_all_file_details(const std::string& filename, file_details_vec& file_details)
643{
644        get_all_file_details(from_utf8_safe(filename), file_details);
645}
646
647void bit::get_all_file_details(const std::wstring& filename, file_details_vec& file_details)
648{
649        try {
650       
651        pimpl()->the_torrents_.get(filename)->get_file_details(file_details);
652       
653        } HAL_GENERIC_TORRENT_EXCEPTION_CATCH(filename, "get_all_file_details")
654}
655
656bool bit::is_torrent(const std::string& filename)
657{       
658        return is_torrent(hal::to_wstr_shim(filename));
659}
660
661bool bit::is_torrent(const std::wstring& filename)
662{       
663        try {
664       
665        return pimpl()->the_torrents_.exists(filename);
666       
667        } HAL_GENERIC_TORRENT_EXCEPTION_CATCH(filename, "is_torrent")
668       
669        return false;
670}
671
672void bit::pause_torrent(const std::string& filename)
673{
674        pause_torrent(hal::to_wstr_shim(filename));
675}
676
677void bit::pause_torrent(const std::wstring& filename)
678{
679        try {
680       
681        pimpl()->the_torrents_.get(filename)->pause();
682       
683        } HAL_GENERIC_TORRENT_EXCEPTION_CATCH(filename, "pause_torrent")
684}
685
686void bit::resume_torrent(const std::string& filename)
687{
688        resume_torrent(hal::to_wstr_shim(filename));
689}
690
691void bit::resume_torrent(const std::wstring& filename)
692{
693        try {
694       
695        pimpl()->the_torrents_.get(filename)->resume();
696       
697        } HAL_GENERIC_TORRENT_EXCEPTION_CATCH(filename, "resume_torrent")
698}
699
700void bit::stop_torrent(const std::string& filename)
701{
702        stop_torrent(hal::to_wstr_shim(filename));
703}
704
705void bit::stop_torrent(const std::wstring& filename)
706{
707        try {
708       
709        pimpl()->the_torrents_.get(filename)->stop();
710       
711        } HAL_GENERIC_TORRENT_EXCEPTION_CATCH(filename, "stop_torrent")
712}
713
714bool bit::is_torrent_active(const std::string& filename)
715{
716        return is_torrent_active(hal::to_wstr_shim(filename));
717}
718
719bool bit::is_torrent_active(const std::wstring& filename)
720{
721        try {
722       
723        return pimpl()->the_torrents_.get(filename)->is_active();
724       
725        } HAL_GENERIC_TORRENT_EXCEPTION_CATCH(filename, "is_torrent_active")
726       
727        return false; // ??? is this correct
728}
729
730void bit::reannounce_torrent(const std::string& filename)
731{
732        reannounce_torrent(hal::to_wstr_shim(filename));
733}
734
735void bit::reannounce_torrent(const std::wstring& filename)
736{
737        try {
738       
739        pimpl()->the_torrents_.get(filename)->handle().force_reannounce();
740       
741        } HAL_GENERIC_TORRENT_EXCEPTION_CATCH(filename, "reannounce_torrent")
742}
743
744
745void bit::recheck_torrent(const std::string& filename)
746{
747        recheck_torrent(hal::to_wstr_shim(filename));
748}
749
750void bit::recheck_torrent(const std::wstring& filename)
751{
752        try {
753       
754//      pimpl()->the_torrents_.get(filename)->output_torrent_debug_details();
755
756        pimpl()->the_torrents_.get(filename)->force_recheck();
757       
758        } HAL_GENERIC_TORRENT_EXCEPTION_CATCH(filename, "recheck_torrent")
759}
760
761void bit::remove_torrent_wstr(const std::wstring& filename)
762{
763        pimpl()->remove_torrent(filename);
764}
765
766void bit::remove_torrent_wipe_files_wstr(const std::wstring& filename, remove_files f)
767{
768        pimpl()->remove_torrent_wipe_files(hal::to_wstr_shim(filename), f);
769}
770
771void bit::pause_all_torrents()
772{       
773        try {
774
775/*      Behaviour changed to a session pause.
776       
777        for (torrent_manager::torrent_by_name::iterator i=pimpl()->the_torrents_.begin(), e=pimpl()->the_torrents_.end();
778                i != e; ++i)
779        {               
780                if ((*i).torrent->in_session())
781                        (*i).torrent->pause();
782        }
783*/
784        pimpl()->session_->pause();
785       
786        } HAL_GENERIC_TORRENT_EXCEPTION_CATCH("Torrent Unknown!", "pause_all_torrents")
787}
788
789void bit::unpause_all_torrents()
790{       
791        try {
792       
793/*      for (torrent_manager::torrent_by_name::iterator i=pimpl()->the_torrents_.begin(), e=pimpl()->the_torrents_.end();
794                i != e; ++i)
795        {
796                if ((*i).torrent->in_session() && (*i).torrent->get_state() == torrent_details::torrent_paused)
797                        (*i).torrent->resume();
798        }
799*/
800        pimpl()->session_->resume();
801       
802        } HAL_GENERIC_TORRENT_EXCEPTION_CATCH("Torrent Unknown!", "unpause_all_torrents")
803}
804
805bool bit::is_any_torrent_active()
806{
807        bool result = false;
808       
809        try {
810       
811        for (torrent_manager::torrent_by_name::iterator i=pimpl()->the_torrents_.begin(), e=pimpl()->the_torrents_.end();
812                i != e; ++i)
813        {
814                if ((*i).torrent->is_active())
815                {
816                        result = true;
817                        break;
818                }
819        }
820       
821        } HAL_GENERIC_TORRENT_EXCEPTION_CATCH("Torrent Unknown!", "is_any_torrent_active")
822       
823        return result;
824}
825
826void bit::schedual_action(boost::posix_time::ptime time, timeout_actions action)
827{
828        return pimpl()->schedual_action(time, action);
829}
830
831void bit::schedual_action(boost::posix_time::time_duration duration, timeout_actions action)
832{
833        return pimpl()->schedual_action(duration, action);
834}
835
836void bit::schedual_callback(boost::posix_time::ptime time, action_callback_t action)
837{
838        return pimpl()->schedual_callback(time, action);
839}
840
841void bit::schedual_callback(boost::posix_time::time_duration duration, action_callback_t action)
842{
843        return pimpl()->schedual_callback(duration, action);
844}
845
846void bit::schedual_cancel()
847{
848        return pimpl()->schedual_cancel();
849}
850
851bit::torrent::torrent()
852{}
853
854bit::torrent::torrent(boost::shared_ptr<torrent_internal> p) :
855        ptr(p)
856{}
857
858bool bit::torrent::is_open() const
859{
860        return ptr;
861}
862
863bit::torrent::exec_around_ptr::proxy::proxy(torrent_internal* t) : 
864        t_(t),
865        l_(t->mutex_)
866{
867//      HAL_DEV_MSG(L"Ctor proxy");
868}
869
870bit::torrent::exec_around_ptr::proxy::~proxy() 
871{
872//      HAL_DEV_MSG(L"Dtor proxy");
873}
874
875const std::wstring bit::torrent::get_name() const
876{
877        try {
878       
879        return ptr->name();
880       
881        } HAL_GENERIC_TORRENT_EXCEPTION_CATCH(L"Torrent Unknown", "torrent::get_name()")
882       
883        return 0;
884}
885
886float bit::torrent::get_ratio() const
887{
888        try {
889       
890        return ptr->get_ratio();
891       
892        } HAL_GENERIC_TORRENT_PROP_EXCEPTION_CATCH("torrent::get_ratio")
893       
894        return 0;
895}
896
897void bit::torrent::set_ratio(float r)
898{
899        try {
900
901        ptr->set_ratio(r);
902       
903        } HAL_GENERIC_TORRENT_PROP_EXCEPTION_CATCH("torrent::set_ratio")
904}
905
906std::pair<int, int> bit::torrent::get_connection_limits() const
907{
908        try {
909       
910        return ptr->get_connection_limit();
911       
912        } HAL_GENERIC_TORRENT_PROP_EXCEPTION_CATCH("torrent::get_connection_limits")
913       
914        return std::make_pair(-1, -1);
915}
916
917void bit::torrent::set_connection_limits(const std::pair<int, int>& l)
918{
919        try {
920       
921        ptr->set_connection_limit(l.first, l.second);
922       
923        } HAL_GENERIC_TORRENT_PROP_EXCEPTION_CATCH("torrent::set_connection_limits")
924}
925
926std::pair<float, float> bit::torrent::get_rate_limits() const
927{
928        try {
929       
930        return ptr->get_transfer_speed();
931       
932        } HAL_GENERIC_TORRENT_PROP_EXCEPTION_CATCH("torrent::get_rate_limits")
933       
934        return std::pair<float, float>(-1.0, -1.0);
935}
936
937void bit::torrent::set_rate_limits(const std::pair<float, float>& l)
938{
939        try {
940       
941        ptr->set_transfer_speed(l.first, l.second);
942       
943        } HAL_GENERIC_TORRENT_PROP_EXCEPTION_CATCH("torrent::set_rate_limits")
944}
945
946wpath bit::torrent::get_save_directory() const
947{
948        try {
949       
950        return ptr->get_save_directory();
951       
952        } HAL_GENERIC_TORRENT_PROP_EXCEPTION_CATCH("torrent::get_save_directory")
953       
954        return L"";
955}
956
957void bit::torrent::set_save_directory(const wpath& s)
958{
959        try {
960       
961        ptr->set_save_directory(s);
962       
963        } HAL_GENERIC_TORRENT_PROP_EXCEPTION_CATCH("torrent::set_save_directory")
964}
965
966wpath bit::torrent::get_move_to_directory() const
967{
968        try {
969       
970        return ptr->get_move_to_directory();
971       
972        } HAL_GENERIC_TORRENT_PROP_EXCEPTION_CATCH("torrent::get_save_directory")
973       
974        return L"";
975}
976
977void bit::torrent::set_move_to_directory(const wpath& m)
978{
979        try {
980       
981        ptr->set_move_to_directory(m);
982       
983        } HAL_GENERIC_TORRENT_PROP_EXCEPTION_CATCH("torrent::set_move_to_directory")
984}
985
986std::pair<wstring, wstring> bit::torrent::get_tracker_login() const
987{
988        try {
989       
990        return ptr->get_tracker_login();
991       
992        } HAL_GENERIC_TORRENT_PROP_EXCEPTION_CATCH("get_tracker_login")
993       
994        return std::make_pair(L"!!! exception thrown !!!", L"!!! exception thrown !!!");
995}
996
997void bit::torrent::set_tracker_login(const std::pair<wstring, wstring>& p)
998{
999        try {
1000       
1001        ptr->set_tracker_login(p.first, p.second);
1002       
1003        } HAL_GENERIC_TORRENT_PROP_EXCEPTION_CATCH("torrent::set_tracker_login")
1004}
1005
1006bool bit::torrent::get_is_active() const
1007{
1008        try {
1009       
1010        return ptr->is_active();
1011       
1012        } HAL_GENERIC_TORRENT_PROP_EXCEPTION_CATCH("torrent::get_is_active")
1013       
1014        return L"";
1015}
1016
1017bool bit::torrent::get_in_session() const
1018{
1019        try {
1020       
1021        return ptr->in_session();
1022       
1023        } HAL_GENERIC_TORRENT_PROP_EXCEPTION_CATCH("torrent::get_in_session")
1024       
1025        return L"";
1026}
1027
1028std::vector<tracker_detail> bit::torrent::get_trackers() const
1029{
1030        try {
1031       
1032        return ptr->get_trackers();
1033       
1034        } HAL_GENERIC_TORRENT_PROP_EXCEPTION_CATCH("torrent::get_trackers")
1035       
1036        return std::vector<tracker_detail>();
1037}
1038
1039void bit::torrent::set_trackers(const std::vector<tracker_detail>& trackers)
1040{
1041        try {
1042       
1043        ptr->set_trackers(trackers);
1044       
1045        } HAL_GENERIC_TORRENT_PROP_EXCEPTION_CATCH("torrent::set_trackers")
1046}
1047
1048void bit::torrent::reset_trackers()
1049{
1050        try {
1051       
1052        ptr->reset_trackers();
1053       
1054        } HAL_GENERIC_TORRENT_PROP_EXCEPTION_CATCH("torrent::set_trackers")
1055}
1056
1057void bit::torrent::set_file_priorities(const std::pair<std::vector<int>, int>& p)
1058{
1059        try { 
1060
1061        ptr->set_file_priorities(p.first, p.second);
1062       
1063        } HAL_GENERIC_TORRENT_PROP_EXCEPTION_CATCH("torrent::set_trackers")
1064}
1065
1066void bit::torrent::adjust_queue_position(bit::queue_adjustments adjust)
1067{
1068        try { 
1069
1070        ptr->adjust_queue_position(adjust);
1071       
1072        } HAL_GENERIC_TORRENT_PROP_EXCEPTION_CATCH("torrent::adjust_queue_position")
1073}
1074
1075bool bit::torrent::get_managed() const
1076{
1077        try {
1078       
1079        return ptr->is_managed();
1080       
1081        } HAL_GENERIC_TORRENT_PROP_EXCEPTION_CATCH("torrent::get_managed")
1082       
1083        return false;
1084}
1085
1086void bit::torrent::set_managed(bool m)
1087{
1088        try {
1089       
1090        ptr->set_managed(m);
1091       
1092        } HAL_GENERIC_TORRENT_PROP_EXCEPTION_CATCH("torrent::set_managed")
1093}
1094
1095void bit::start_event_receiver()
1096{
1097        try {
1098
1099        pimpl()->start_alert_handler();
1100
1101        event_log().post(shared_ptr<EventDetail>(new EventMsg(L"        ... started handler")));
1102       
1103        } HAL_GENERIC_PIMPL_EXCEPTION_CATCH("bit::start_event_receiver()")
1104}
1105
1106void bit::stop_event_receiver()
1107{
1108        try {
1109
1110        event_log().post(shared_ptr<EventDetail>(new EventMsg(L"Stopping event handler")));
1111
1112        pimpl()->stop_alert_handler();
1113       
1114        } HAL_GENERIC_PIMPL_EXCEPTION_CATCH("bit::stop_event_receiver()")
1115}
1116
1117int bit::default_torrent_max_connections() { return pimpl()->default_torrent_max_connections_; }
1118int bit::default_torrent_max_uploads() { return pimpl()->default_torrent_max_uploads_; }
1119float bit::default_torrent_download() { return pimpl()->default_torrent_download_; }
1120float bit::default_torrent_upload() { return pimpl()->default_torrent_upload_; }
1121       
1122};
Note: See TracBrowser for help on using the repository browser.