source: trunk/src/halTorrent.hpp @ 660

Revision 660, 19.9 KB checked in by Eoin, 11 years ago (diff)

FileDetail? struct converted to file_details along with other related naming changes.

Line 
1
2//         Copyright Eóin O'Callaghan 2006 - 2008.
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#pragma once
8
9/*#include <string>
10#include <vector>
11#include <set>
12
13#include <boost/foreach.hpp>
14#include <boost/format.hpp>
15#include <boost/array.hpp>
16#include <boost/lexical_cast.hpp>
17#include <boost/bind.hpp>
18
19#include <boost/smart_ptr.hpp>
20#include <boost/noncopyable.hpp>
21
22#include <boost/signal.hpp>
23#include <boost/optional.hpp>
24#include <boost/function.hpp>
25
26#include <boost/smart_ptr.hpp>
27
28#include <boost/filesystem/path.hpp>
29#include <boost/filesystem/operations.hpp>
30#include <boost/filesystem/fstream.hpp>
31*/
32
33#include <boost/algorithm/string.hpp>
34
35#include <stlsoft/properties/method_properties.hpp>
36#include <stlsoft/util/operator_bool_adaptor.hpp>
37
38#include <boost/asio/ip/tcp.hpp>
39#include <boost/asio/ip/udp.hpp>
40
41#include "halTypes.hpp"
42#include "halPeers.hpp"
43
44namespace hal
45{
46
47template<typename T>
48bool hal_details_ptr_compare(T l, T r, size_t index = 0, bool cmp_less = true)
49{
50        if (cmp_less)
51                return l->less(*r, index);
52        else
53                return r->less(*l, index);
54}
55
56template<typename T>
57bool hal_details_compare(T l, T r, size_t index = 0, bool cmp_less = true)
58{
59        if (cmp_less)
60                return l.less(r, index);
61        else
62                return r.less(l, index);
63}
64
65inline boost::wformat wform(const std::wstring & f_string) 
66{
67    using namespace boost::io;
68
69        boost::wformat fmter(f_string);
70    fmter.exceptions( no_error_bits  );
71    return fmter;
72}
73
74struct torrentBriefDetail
75{
76        std::wstring filename;
77        std::wstring status;
78        std::pair<float,float> speed;
79        float completion;
80        int peers;
81        int seeds;
82};
83
84struct queue_settings;
85struct timeouts;
86struct dht_settings;
87struct cache_settings;
88struct pe_settings;
89struct connections;
90struct cache_details;
91
92
93struct file_details
94{
95        file_details(boost::filesystem::wpath p, 
96                        boost::int64_t s=0, 
97                        boost::int64_t pg=0, 
98                        int pr=1, 
99                        size_t o=0, 
100                        unsigned t=file_details::file) :
101                branch(p.parent_path()),
102                filename(p.filename()),
103                type(t),
104                size(s),
105                progress(pg),
106                priority(pr),
107                order_(o)
108        {}
109       
110        bool operator==(const file_details& file) const
111        {
112                return (branch == file.branch);
113        }
114       
115        bool operator<(const file_details& file) const
116        {
117                return (branch < file.branch);
118        }
119       
120        enum file_type
121        {
122                folder,
123                file
124        };
125       
126        size_t order() const { return order_; }
127       
128        boost::filesystem::wpath branch;
129        std::wstring filename;
130        unsigned type;
131        boost::int64_t size;
132        boost::int64_t progress;
133        int priority;
134       
135private:
136        size_t order_;
137};
138
139inline bool file_details_names_equal(const file_details& l, const file_details& r)
140{
141        return l.filename == r.filename;
142}
143
144inline bool file_details_names_less(const file_details& l, const file_details& r)
145{
146        return l.filename < r.filename;
147}
148
149typedef std::vector<file_details> file_details_vec;
150
151
152class torrent_details 
153{
154public:
155        torrent_details(std::wstring n, std::wstring f, 
156                        std::wstring sd, 
157                        std::wstring s, 
158                        std::wstring cT, 
159                        std::pair<float,float> sp=std::pair<float,float>(0,0),
160                        float c=0, float d=0, 
161                        size_type tWD=0, size_type tW=0, 
162                        size_type tU=0, size_type tpU=0, 
163                        size_type tD=0, size_type tpD=0, 
164                        boost::tuple<size_type, size_type, size_type, size_type> connections = 
165                                boost::tuple<size_type, size_type, size_type, size_type>(0,0,0,0), 
166                        float r=0, 
167                        boost::posix_time::time_duration eta=boost::posix_time::seconds(0), 
168                        boost::posix_time::time_duration uIn=boost::posix_time::seconds(0),
169                        boost::posix_time::time_duration actve=boost::posix_time::seconds(0), 
170                        boost::posix_time::time_duration seding=boost::posix_time::seconds(0), 
171                        boost::posix_time::ptime srt=boost::posix_time::second_clock::universal_time(), 
172                        boost::posix_time::ptime fin=boost::posix_time::second_clock::universal_time(), 
173                        int q_p=-1, 
174                        bool man=false) :
175                filename_(f),
176                name_(n),
177                saveDir_(sd),
178                state_(s),
179                currentTracker_(cT),
180                speed_(sp),
181                completion_(c),
182                distributed_copies_(d),
183                total_wanted_done_(tWD),
184                total_wanted_(tW),
185                total_uploaded_(tU),
186                total_payload_uploaded_(tpU),
187                total_downloaded_(tD),
188                total_payload_downloaded_(tpD),
189                peers_(connections.get<0>()),
190                connected_peers_(connections.get<1>()),
191                seeds_(connections.get<2>()),
192                connected_seeds_(connections.get<3>()),
193                ratio_(r),
194                estimated_time_left_(eta),
195                update_tracker_in_(uIn),
196                peer_details_filled_(false),
197                file_details_filled_(false),
198                active_(actve),
199                seeding_(seding),
200                start_time_(srt),
201                finish_time_(fin),
202                queue_position_(q_p),
203                managed_(man)
204        {}
205
206        torrent_details() :     
207                peer_details_filled_(false),
208                file_details_filled_(false)
209        {};     
210       
211        enum state
212        {
213                torrent_active = 0,
214                torrent_paused,
215                torrent_stopped,
216                torrent_pausing,
217                torrent_stopping
218        };
219
220        enum details
221        {
222                name_e = 0,
223                state_e,
224                progress_e,
225                speed_down_e,
226                speed_up_e,
227                peers_e,
228                seeds_e,
229                eta_e,
230                distributed_copies_e,
231                tracker,
232                update_tracker_in_e,
233                ratio_e,
234                total_wanted_e,
235                completed_e,
236                remaining_e,
237                downloaded_e,
238                uploaded_e,
239                active_time_e,
240                seeding_time_e,
241                start_time_e,
242                finish_time_e,
243                managed_e,
244                queue_position_e
245        };
246       
247//      const std::wstring& filename() const { return filename_; }
248        const std::wstring& name() const { return name_; }
249        const std::wstring& save_directory() const { return saveDir_; }
250        const std::wstring& state() const { return state_; }
251        const std::wstring& current_tracker() const { return currentTracker_; }
252       
253        std::pair<float,float> speed() const { return speed_; }
254        const float& completion() const { return completion_; }
255        const float& distributed_copies() const { return distributed_copies_; }
256       
257        size_type total_uploaded() const { return total_uploaded_; }
258        size_type total_payload_uploaded() const { return total_payload_uploaded_; }
259        size_type total_downloaded() const { return total_downloaded_; }
260        size_type total_payload_downloaded() const { return total_payload_downloaded_; }
261        size_type total_wanted_done() const { return total_wanted_done_; }
262        size_type total_wanted() const { return total_wanted_; }
263       
264        size_type peers() const { return peers_; }
265        size_type peers_connected() const { return connected_peers_; }
266        size_type seeds() const { return seeds_; }
267        size_type seeds_connected() const { return connected_seeds_; }
268       
269        float ratio() { return ratio_; }
270       
271        const boost::posix_time::time_duration& estimated_time_left() { return estimated_time_left_; }
272        const boost::posix_time::time_duration& update_tracker_in() { return update_tracker_in_; }
273       
274        const peer_details_vec& get_peer_details() const;
275        const file_details_vec& get_file_details() const;
276       
277        const boost::posix_time::time_duration& active() { return active_; }
278        const boost::posix_time::time_duration& seeding() { return seeding_; }
279        const boost::posix_time::ptime& start_time() { return start_time_; }
280        const boost::posix_time::ptime& finish_time() { return finish_time_; }
281
282        int queue_position() const { return queue_position_; }
283        bool managed() const { return managed_; }
284
285        bool less(const torrent_details& r, size_t index = 0) const;
286        std::wstring to_wstring(size_t index = 0);
287       
288public:
289        std::wstring filename_;
290        std::wstring name_;
291        std::wstring saveDir_;
292        std::wstring state_;
293        std::wstring currentTracker_;
294
295        std::pair<float,float> speed_;         
296        float completion_;     
297        float distributed_copies_;
298       
299        size_type total_wanted_done_;
300        size_type total_wanted_;
301        size_type total_uploaded_;
302        size_type total_payload_uploaded_;
303        size_type total_downloaded_;
304        size_type total_payload_downloaded_;
305       
306        size_type peers_;
307        size_type connected_peers_;
308        size_type seeds_;
309        size_type connected_seeds_;
310       
311        float ratio_;
312       
313        boost::posix_time::time_duration estimated_time_left_;
314        boost::posix_time::time_duration update_tracker_in_;
315       
316        boost::posix_time::time_duration active_;
317        boost::posix_time::time_duration seeding_;
318        boost::posix_time::ptime start_time_;
319        boost::posix_time::ptime finish_time_;
320
321        int queue_position_;
322        bool managed_;
323       
324private:
325        mutable bool peer_details_filled_;
326        mutable peer_details_vec peer_details_;
327       
328        mutable bool file_details_filled_;
329        mutable file_details_vec file_details_;
330};
331
332typedef boost::shared_ptr<torrent_details> torrent_details_ptr;
333typedef boost::scoped_ptr<torrent_details> torrent_details_sptr;
334typedef boost::weak_ptr<torrent_details> torrent_details_wptr;
335typedef std::vector<torrent_details_ptr> torrent_details_vec;
336typedef std::map<std::wstring, torrent_details_ptr> torrent_details_map;
337
338class torrent_details_manager
339{
340public: 
341        void sort(size_t index, bool cmp_less = true) const;
342       
343        const torrent_details_vec torrents() const 
344        {
345                mutex_t::scoped_lock l(mutex_); 
346                return torrents_; 
347        }
348       
349        const torrent_details_vec selectedTorrents() const 
350        { 
351                mutex_t::scoped_lock l(mutex_); 
352                return selectedTorrents_; 
353        }
354       
355        const torrent_details_ptr focusedTorrent() const 
356        {
357                mutex_t::scoped_lock l(mutex_); 
358                return selectedTorrent_; 
359        }
360       
361        const torrent_details_ptr get(std::wstring filename) const
362        {
363                mutex_t::scoped_lock l(mutex_); 
364               
365                torrent_details_map::const_iterator i = torrentMap_.find(filename);
366               
367                if (i != torrentMap_.end())
368                        return i->second;
369                else
370                        return torrent_details_ptr();
371        }
372       
373        friend class bit;
374
375private:
376        void clearAll(const mutex_t::scoped_lock&)
377        {
378                // !! No mutex lock, it should only be called from functions which
379                // have the lock themselves, hence the unused function param
380               
381                torrents_.clear();
382                torrentMap_.clear();
383                selectedTorrents_.clear();
384                selectedTorrent_.reset();
385        }
386
387        mutable torrent_details_vec torrents_;
388       
389        torrent_details_map torrentMap_;
390        torrent_details_vec selectedTorrents_;
391        torrent_details_ptr selectedTorrent_;
392       
393        mutable mutex_t mutex_;
394};
395
396struct tracker_detail
397{
398        tracker_detail() {}
399        tracker_detail(std::wstring u, int t) : url(u), tier(t) {}
400       
401        bool operator<(const tracker_detail& t) const
402        {
403                return (tier < t.tier);
404        }
405       
406        std::wstring url;
407        int tier;
408};
409
410typedef std::vector<tracker_detail> tracker_details_t;
411
412struct web_seed_or_dht_node_detail
413{
414        web_seed_or_dht_node_detail();
415        web_seed_or_dht_node_detail(std::wstring u);
416        web_seed_or_dht_node_detail(std::wstring u, int p);
417               
418        std::wstring url;
419        int port;
420        std::wstring type;
421};
422
423typedef std::vector<pair<fs::wpath, size_type> > file_size_pairs_t;
424
425struct dht_node_detail
426{
427        dht_node_detail() {}
428        dht_node_detail(std::wstring u, int p) : url(u), port(p) {}
429       
430        std::wstring url;
431        int port;
432};
433
434typedef std::vector<dht_node_detail> dht_node_details_t;
435
436struct web_seed_detail
437{
438        web_seed_detail() {}
439        web_seed_detail(std::wstring u) : url(u) {}
440       
441        std::wstring url;
442};
443
444typedef std::vector<web_seed_detail> web_seed_details_t;
445
446struct create_torrent_params
447{
448        create_torrent_params() {}
449
450        std::wstring creator;
451        std::wstring comment;
452        int piece_size;
453        bool private_torrent;
454
455        file_size_pairs_t file_size_pairs;
456        fs::wpath root_path;
457
458        tracker_details_t trackers;
459        dht_node_details_t dht_nodes;
460        web_seed_details_t web_seeds;
461};
462
463class EventDetail;
464
465struct SessionDetail
466{
467        int port;
468       
469        std::pair<double, double> speed;
470       
471        bool dht_on;
472        size_t dht_nodes;
473        size_t dht_torrents;
474       
475        bool ip_filter_on;
476        size_t ip_ranges_filtered;
477};
478
479typedef boost::function<bool (size_t, size_t, size_t)> filterCallback;
480typedef boost::function<bool (size_t, std::wstring)> progress_callback;
481typedef boost::function<void (int)> report_num_active;
482typedef std::pair<wstring, wstring> wstring_pair;
483typedef std::pair<float, float> float_pair;
484typedef std::pair<int, int> int_pair;
485typedef std::pair<std::vector<int>, int> vec_int_pair;
486
487class bit_impl;
488class torrent_internal;
489
490class bit
491{
492public:         
493
494        enum mappings
495        {
496                mappingNone = 0,
497                mappingUPnP,
498                mappingNatPMP
499        };
500
501        enum allocations
502        {
503                sparse_allocation = 1,
504                compact_allocation,
505                full_allocation
506        };
507
508        enum queue_adjustments
509        {
510                move_up = 0,
511                move_down,
512                move_to_top,
513                move_to_bottom
514        };
515
516        class null_torrent : public std::exception
517        {
518        public:
519                null_torrent() {}               
520                virtual ~null_torrent() throw () {}
521        };
522
523        class torrent : public stlsoft::operator_bool_adaptor<torrent>
524        {
525                typedef torrent class_type;
526
527        public:
528                class exec_around_ptr
529                {
530                public:
531                        class proxy 
532                        {
533                        public:
534                                explicit proxy(torrent_internal* t);
535
536                                torrent_internal* operator->() 
537                                {
538                                        return t_;
539                                }
540
541                                ~proxy ();
542
543                        private:
544                                torrent_internal* t_;
545                                mutex_t::scoped_lock l_;
546                        };
547
548                        exec_around_ptr() {}
549                        exec_around_ptr(boost::shared_ptr<torrent_internal> p) : ptr(p) {}
550
551                        proxy operator->() const
552                        {
553                                if (!ptr)
554                                        throw null_torrent();
555
556                                return proxy(&(*ptr));
557                        }
558
559                        operator bool() const { return ptr; }
560
561                private:
562                        boost::shared_ptr<torrent_internal> ptr;
563                };
564
565                torrent();
566                torrent(boost::shared_ptr<torrent_internal> p);
567
568                const std::wstring get_name() const;
569
570                float get_ratio() const;
571                void set_ratio(float new_ratio);
572               
573                std::pair<int, int> get_connection_limits() const;
574                void set_connection_limits(const std::pair<int, int>&);
575                std::pair<float, float> get_rate_limits() const;
576                void set_rate_limits(const std::pair<float, float>&);
577
578                wpath get_save_directory() const;
579                void set_save_directory(const wpath&);
580                wpath get_move_to_directory() const;
581                void set_move_to_directory(const wpath&);
582
583                std::pair<wstring, wstring> get_tracker_login() const;
584                void set_tracker_login(const std::pair<wstring, wstring>&);
585
586                std::vector<tracker_detail> get_trackers() const;
587                void set_trackers(const std::vector<tracker_detail>&);
588
589                bool get_is_active() const;
590                bool get_in_session() const;
591
592                void set_file_priorities(const vec_int_pair&);
593
594                void set_managed(bool);
595                bool get_managed() const;
596
597        public:
598                STLSOFT_METHOD_PROPERTY_GET_EXTERNAL(const std::wstring, class_type, 
599                        get_name, name);
600
601                STLSOFT_METHOD_PROPERTY_GETSET_EXTERNAL(float, float, class_type, 
602                        get_ratio, set_ratio, ratio);
603
604                STLSOFT_METHOD_PROPERTY_GETSET_EXTERNAL(int_pair, const int_pair&, class_type, 
605                        get_connection_limits, set_connection_limits, connection_limits);
606                STLSOFT_METHOD_PROPERTY_GETSET_EXTERNAL(float_pair, const float_pair&, class_type, 
607                        get_rate_limits, set_rate_limits, rate_limits);
608               
609                STLSOFT_METHOD_PROPERTY_GETSET_EXTERNAL(wpath, const wpath&, class_type, 
610                        get_save_directory, set_save_directory, save_directory);
611                STLSOFT_METHOD_PROPERTY_GETSET_EXTERNAL(wpath, const wpath&, class_type, 
612                        get_move_to_directory, set_move_to_directory, move_to_directory);
613
614                STLSOFT_METHOD_PROPERTY_GETSET_EXTERNAL(wstring_pair, const wstring_pair&, 
615                        class_type, get_tracker_login, set_tracker_login, tracker_login);
616
617                STLSOFT_METHOD_PROPERTY_GET_EXTERNAL(bool, class_type, 
618                        get_is_active, is_active);
619                STLSOFT_METHOD_PROPERTY_GET_EXTERNAL(bool, class_type, 
620                        get_in_session, in_session);
621
622                STLSOFT_METHOD_PROPERTY_GETSET_EXTERNAL(std::vector<tracker_detail>, const std::vector<tracker_detail>&, 
623                        class_type, get_trackers, set_trackers, trackers);
624
625                STLSOFT_METHOD_PROPERTY_GETSET_EXTERNAL(bool, bool, class_type, 
626                        get_managed, set_managed, managed);
627
628                STLSOFT_METHOD_PROPERTY_SET_EXTERNAL(const vec_int_pair&, class_type, 
629                        set_file_priorities, file_priorities);
630
631                void reset_trackers();
632                bool is_open() const;
633                void adjust_queue_position(bit::queue_adjustments adjust);
634
635        private:
636                exec_around_ptr ptr;
637        };
638
639        void shutdown_session();
640        void save_torrent_data();
641
642        bool create_torrent(const create_torrent_params& params, fs::wpath out_file, progress_callback fn);
643
644        template<typename T>
645        torrent get(T t)
646        {
647                return get_wstr(to_wstr_shim(t));
648        }
649       
650        template<>
651        torrent get(const hal::torrent_details_ptr t)
652        {
653                if (t) 
654                        return get_wstr(t->name());
655                else
656                        return torrent();
657        }       
658
659        torrent get_wstr(const std::wstring& filename);
660       
661        bool listen_on(std::pair<int, int> const& portRange);
662        int is_listening_on();
663        void stop_listening();
664       
665        bool ensure_dht_on(const dht_settings& dht);
666        void ensure_dht_off();
667       
668        void ensure_pe_on(const pe_settings& pe);
669        void ensure_pe_off();
670       
671        bool ensure_ip_filter_on(progress_callback fn);
672        void ensure_ip_filter_off();
673
674        void set_resolve_countries(bool);
675        void start_smart_ban_plugin();
676        void start_ut_pex_plugin();
677        void start_ut_metadata_plugin();
678        void start_metadata_plugin();
679
680        void set_mapping(bool upnp, bool nat_pmp);
681        std::wstring upnp_router_model();
682
683        void ip_v4_filter_block(boost::asio::ip::address_v4 first, boost::asio::ip::address_v4 last);
684        void ip_v6_filter_block(boost::asio::ip::address_v6 first, boost::asio::ip::address_v6 last);
685        bool ip_filter_import_dat(boost::filesystem::path file, progress_callback fn, bool octalFix);
686        size_t ip_filter_size();
687        void clear_ip_filter(); 
688       
689        void set_session_half_open_limit(int halfConn);
690        void set_session_limits(int maxConn, int maxUpload);
691        void set_session_speed(float download, float upload);
692
693        queue_settings get_queue_settings();
694        void set_queue_settings(const queue_settings& s);
695       
696        timeouts get_timeouts();
697        void set_timeouts(const timeouts& t);
698
699        const cache_details get_cache_details() const;
700
701        void set_cache_settings(const cache_settings& cache);
702        cache_settings get_cache_settings() const;
703       
704        const SessionDetail get_session_details();
705
706        void set_torrent_defaults(const connections& defaults); 
707        void add_torrent(boost::filesystem::wpath file, boost::filesystem::wpath saveDirectory, 
708                bool startPaused=false, bool managed=false, allocations alloc=hal::bit::sparse_allocation, 
709                boost::filesystem::wpath moveToDirectory=L"", bool useMoveTo=false);
710       
711        void get_all_peer_details(const std::string& filename, peer_details_vec& peerContainer);
712        void get_all_peer_details(const std::wstring& filename, peer_details_vec& peerContainer);
713        void get_all_file_details(const std::string& filename, file_details_vec& file_details);
714        void get_all_file_details(const std::wstring& filename, file_details_vec& file_details);
715       
716        void resume_all();
717        void close_all(boost::optional<report_num_active> fn);
718       
719        bool is_torrent(const std::string& filename);
720        bool is_torrent(const std::wstring& filename); 
721       
722        void pause_torrent(const std::string& filename);
723        void pause_torrent(const std::wstring& filename);
724        void resume_torrent(const std::string& filename);
725        void resume_torrent(const std::wstring& filename);
726        void stop_torrent(const std::string& filename);
727        void stop_torrent(const std::wstring& filename);
728        bool is_torrent_active(const std::string& filename);
729        bool is_torrent_active(const std::wstring& filename);
730        void reannounce_torrent(const std::string& filename);
731        void reannounce_torrent(const std::wstring& filename);
732        void recheck_torrent(const std::string& filename);
733        void recheck_torrent(const std::wstring& filename);
734       
735        void pause_all_torrents();
736        void unpause_all_torrents();
737
738        template<typename S>
739        void remove_torrent(S filename)
740        { 
741                remove_torrent_wstr(to_wstr_shim(filename)); 
742        }       
743
744        template<typename S>
745        void remove_torrent_wipe_files(S filename)
746        { 
747                remove_torrent_wipe_files_wstr(to_wstr_shim(filename)); 
748        }       
749
750        void start_event_receiver();
751        void stop_event_receiver();
752       
753        friend bit& bittorrent();
754       
755        int default_torrent_max_connections();
756        int default_torrent_max_uploads();
757        float default_torrent_download();
758        float default_torrent_upload(); 
759
760        const torrent_details_manager& torrentDetails();
761        const torrent_details_manager& updatetorrent_details_manager(const std::wstring& focused, const std::set<std::wstring>& selected);
762       
763private:
764        bit();
765
766        bit_impl* pimpl();
767        const bit_impl* pimpl() const;
768        boost::scoped_ptr<bit_impl> pimpl_;
769       
770        void remove_torrent_wstr(const std::wstring& filename);
771        void remove_torrent_wipe_files_wstr(const std::wstring&  filename);
772       
773        torrent_details_manager torrentDetails_;
774};
775
776bit& bittorrent();
777
778};
Note: See TracBrowser for help on using the repository browser.