source: trunk/src/halTorrentInternal.hpp @ 744

Revision 744, 21.5 KB checked in by Eoin, 11 years ago (diff)

Gotta move state_machine initialization to after session is started.

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#pragma once
8
9#include "halTorrentDefines.hpp"
10
11#ifndef HAL_TORRENT_STATE_LOGGING
12#       define TORRENT_STATE_LOG(s)
13#else
14#       include "../halEvent.hpp"
15#       define TORRENT_STATE_LOG(msg) \
16        hal::event_log.post(boost::shared_ptr<hal::EventDetail>( \
17                        new hal::EventMsg(msg, hal::event_logger::torrent_dev)))
18#endif
19
20#pragma warning (push, 1)
21#       include <libtorrent/file.hpp>
22#       include <libtorrent/hasher.hpp>
23#       include <libtorrent/storage.hpp>
24#       include <libtorrent/file_pool.hpp>
25#       include <libtorrent/alert_types.hpp>
26#       include <libtorrent/entry.hpp>
27#       include <libtorrent/bencode.hpp>
28#       include <libtorrent/session.hpp>
29#       include <libtorrent/ip_filter.hpp>
30#       include <libtorrent/torrent_handle.hpp>
31#       include <libtorrent/peer_connection.hpp>
32#       include <libtorrent/extensions/metadata_transfer.hpp>
33#       include <libtorrent/extensions/ut_pex.hpp>
34#pragma warning (pop)
35
36#include <boost/statechart/event.hpp>
37#include <boost/statechart/state_machine.hpp>
38#include <boost/statechart/simple_state.hpp>
39#include <boost/statechart/transition.hpp>
40#include <boost/statechart/state.hpp>
41#include <boost/statechart/custom_reaction.hpp>
42
43#include <boost/mpl/list.hpp>
44
45#include "halIni.hpp"
46#include "halTypes.hpp"
47#include "halSignaler.hpp"
48#include "halTorrentIntEvents.hpp"
49
50namespace hal
51{
52class TorrentInternalOld;
53class torrent_internal;
54class torrent_manager;
55}
56
57BOOST_CLASS_VERSION(hal::TorrentInternalOld, 9)
58BOOST_CLASS_VERSION(hal::torrent_internal, 2)
59
60namespace hal
61{
62
63namespace libt = libtorrent;
64namespace sc = boost::statechart;
65namespace mpl = boost::mpl;
66
67
68inline libt::entry haldecode(const wpath &file) 
69{
70        fs::ifstream ifs(file, fs::ifstream::binary);
71        if (ifs.is_open()) 
72        {
73                ifs.unsetf(fs::ifstream::skipws);
74                return libt::bdecode(std::istream_iterator<char>(ifs), std::istream_iterator<char>());
75        }
76        else return libt::entry();
77}
78
79inline bool halencode(const wpath &file, const libt::entry &e) 
80{
81        fs::ofstream ofs(file, fs::ofstream::binary);
82
83        if (!ofs.is_open()) 
84                return false;
85       
86        libt::bencode(std::ostream_iterator<char>(ofs), e);
87        return true;
88}
89
90inline path path_to_utf8(const wpath& wp)
91{
92        return path(to_utf8(wp.string()));
93}
94
95inline wpath path_from_utf8(const path& p)
96{
97        return wpath(from_utf8(p.string()));
98}
99
100inline std::pair<std::string, std::string> extract_names(const wpath &file)
101{
102        if (fs::exists(file)) 
103        {       
104                libt::torrent_info info(path_to_utf8(file));
105
106                std::string name = info.name(); 
107                std::string filename = name;
108
109                if (!boost::find_last(filename, ".torrent")) 
110                                filename += ".torrent";
111               
112                event_log.post(shared_ptr<EventDetail>(new EventMsg(
113                        hal::wform(L"Loaded names: %1%, %2%") % from_utf8(name) % from_utf8(filename))));
114
115                return std::make_pair(name, filename);
116        }
117        else
118                return std::make_pair("", "");
119}
120
121inline libt::storage_mode_t hal_allocation_to_libt(bit::allocations alloc)
122{
123        switch (alloc)
124        {
125        case bit::full_allocation:
126                return libt::storage_mode_allocate;
127        case bit::compact_allocation:
128                return libt::storage_mode_compact;
129        case bit::sparse_allocation:
130        default:
131                return libt::storage_mode_sparse;
132        }
133}
134
135class invalid_torrent : public std::exception
136{
137public:
138        invalid_torrent(const wstring& who) :
139                who_(who)
140        {}
141       
142        virtual ~invalid_torrent() throw () {}
143
144        wstring who() const throw ()
145        {
146                return who_;
147        }       
148       
149private:
150        wstring who_;   
151};
152       
153template<typename T>
154class transfer_tracker
155{
156public:
157        transfer_tracker() :
158                total_(0),
159                total_offset_(0)
160        {}
161       
162        transfer_tracker(T total) :
163                total_(total),
164                total_offset_(0)
165        {}
166       
167        transfer_tracker(T total, T offset) :
168                total_(total),
169                total_offset_(offset)
170        {}
171       
172        void reset(T total) const
173        {
174                total_ = total;
175                total_offset_ = 0;
176        }
177       
178        T update(T rel_total) const
179        {
180                total_ += (rel_total - total_offset_);
181                total_offset_ = rel_total;
182               
183                return total_;
184        }
185       
186        void setOffset(T offset) const
187        {
188                total_offset_ = offset;
189        }
190       
191        operator T() const { return total_; }
192       
193        friend class boost::serialization::access;
194        template<class Archive>
195        void serialize(Archive& ar, const unsigned int version)
196        {
197                ar & boost::serialization::make_nvp("total", total_);
198        }
199       
200private:
201        mutable T total_;
202        mutable T total_offset_;
203};
204
205class duration_tracker
206{
207public:
208        duration_tracker() :
209                total_(boost::posix_time::time_duration(0,0,0,0), 
210                        boost::posix_time::time_duration(0,0,0,0))
211        {}
212       
213        boost::posix_time::time_duration update() const
214        {
215                if (start_.is_not_a_date_time()) 
216                        start_ = boost::posix_time::second_clock::universal_time();
217
218                if (static_cast<boost::posix_time::time_duration>(total_).is_special()) 
219                        total_.setOffset(boost::posix_time::time_duration(0,0,0,0));
220               
221                return total_.update(boost::posix_time::second_clock::universal_time() - start_);
222        }
223       
224        void reset() const
225        {
226                total_.setOffset(boost::posix_time::time_duration(0,0,0,0));
227                start_ = boost::posix_time::second_clock::universal_time();
228        }
229       
230        friend class boost::serialization::access;
231        template<class Archive>
232        void serialize(Archive& ar, const unsigned int version)
233        {
234                ar & boost::serialization::make_nvp("total", total_);
235        }
236       
237        operator boost::posix_time::time_duration() const { return total_; }
238       
239private:
240        transfer_tracker<boost::posix_time::time_duration> total_;     
241        mutable boost::posix_time::ptime start_;               
242};
243       
244struct signalers
245{
246        signaler<> torrent_finished;
247
248        boost::signal<void ()> torrent_paused;
249        boost::signal<void ()> resume_data;
250};
251
252class torrent_internal;
253typedef shared_ptr<torrent_internal> torrent_internal_ptr;
254
255struct torrent_standalone :
256        public hal::IniBase<torrent_standalone>
257{
258        typedef torrent_standalone thisClass;
259        typedef hal::IniBase<thisClass> iniClass;
260
261        torrent_standalone() :
262                iniClass("torrent")
263        {}
264
265        torrent_standalone(torrent_internal_ptr t) :
266                iniClass("torrent"),
267                torrent(t),
268                save_time(pt::second_clock::universal_time())
269        {}
270
271        torrent_internal_ptr torrent;
272        pt::ptime save_time;
273
274    friend class boost::serialization::access;
275    template<class Archive>
276    void serialize(Archive& ar, const unsigned int version)
277    {
278                ar & boost::serialization::make_nvp("torrent", torrent);
279                ar & boost::serialization::make_nvp("save_time", save_time);
280    }
281};
282
283struct out_of_session;
284
285class torrent_internal :
286        public boost::enable_shared_from_this<torrent_internal>,
287        public sc::state_machine<torrent_internal, out_of_session>
288{
289        friend class bit::torrent::exec_around_ptr::proxy;
290
291        friend struct out_of_session;   
292        friend struct in_the_session;
293       
294        friend struct active;
295        friend struct pausing;
296        friend struct paused;
297        friend struct stopping;
298        friend struct stopped;
299        friend struct in_error;
300        friend struct resume_data_waiting;
301        friend struct resume_data_idling;
302
303private:
304        #define TORRENT_INTERNALS_DEFAULTS \
305                original_filename_(L""), \
306                transfer_limit_(std::pair<float, float>(-1, -1)), \
307                connections_(-1), \
308                uploads_(-1), \
309                ratio_(0), \
310                resolve_countries_(true), \
311                total_uploaded_(0), \
312                total_base_(0), \
313                progress_(0), \
314                managed_(false), \
315                start_time_(boost::posix_time::second_clock::universal_time()), \
316                in_session_(false), \
317                queue_position_(0)
318               
319        torrent_internal() :   
320                TORRENT_INTERNALS_DEFAULTS,
321                allocation_(bit::sparse_allocation)
322        {
323                state(torrent_details::torrent_stopped);
324        }
325
326        torrent_internal(wpath filename, wpath saveDirectory, bit::allocations alloc, wpath move_to_directory=L"") :
327                TORRENT_INTERNALS_DEFAULTS,
328                save_directory_(saveDirectory.string()),
329                move_to_directory_(move_to_directory.string()),
330                allocation_(alloc)
331        {
332                state(torrent_details::torrent_stopped);
333                assert(the_session_);
334
335                prepare(filename);
336        }
337
338        #undef TORRENT_INTERNALS_DEFAULTS
339
340public:
341        void locked_process_event(const sc::event_base & e)
342        {
343                mutex_t::scoped_lock l(mutex_);
344                process_event(e);
345        }
346
347        ~torrent_internal()
348        {
349                terminate();
350                TORRENT_STATE_LOG(L"Torrent state machine terminate");
351        }
352       
353        torrent_details_ptr get_torrent_details_ptr();
354
355        void adjust_queue_position(bit::queue_adjustments adjust);
356
357        void set_transfer_speed(float down, float up)
358        {       
359                mutex_t::scoped_lock l(mutex_);
360
361                transfer_limit_ = std::make_pair(down, up);
362               
363                apply_transfer_speed();
364        }
365
366        void set_connection_limit(int maxConn, int maxUpload)           
367        {
368                mutex_t::scoped_lock l(mutex_);
369
370                connections_ = maxConn;
371                uploads_ = maxUpload;
372               
373                apply_connection_limit();
374        }
375
376        std::pair<float, float> get_transfer_speed()
377        {
378                return transfer_limit_;
379        }
380
381        std::pair<int, int> get_connection_limit()
382        {
383                return std::make_pair(connections_, uploads_);
384        }
385       
386        const wstring& name() const { return name_; }
387       
388        void set_ratio(float ratio) 
389        { 
390                if (ratio < 0) ratio = 0;
391                ratio_ = ratio; 
392               
393                apply_ratio();
394        }
395       
396        float get_ratio()
397        {
398                return ratio_;
399        }
400
401        void set_managed(bool m)
402        {
403                mutex_t::scoped_lock l(mutex_);
404                managed_ = m;
405               
406                if (in_session()) handle_.auto_managed(managed_);
407        }
408
409        bool is_managed()
410        {
411                if (in_session())
412                {
413                        managed_ = handle_.is_auto_managed();
414                }
415
416                return managed_;
417        }
418       
419        void add_to_session(bool paused = false);
420       
421        bool remove_from_session(bool write_data=true);
422
423        bool in_session() const
424        { 
425                mutex_t::scoped_lock l(mutex_);
426
427                return (in_session_ && the_session_ != 0 && handle_.is_valid());
428        }
429
430        void resume()
431        {
432                mutex_t::scoped_lock l(mutex_);
433                HAL_DEV_MSG(hal::wform(L"resume() - %1%") % name_);
434               
435                process_event(ev_resume());
436        }
437       
438        void pause()
439        {
440                mutex_t::scoped_lock l(mutex_);
441                HAL_DEV_MSG(hal::wform(L"pause() - %1%") % name_);
442               
443                process_event(ev_pause());             
444        }
445       
446        void stop()
447        {
448                mutex_t::scoped_lock l(mutex_);
449                HAL_DEV_MSG(hal::wform(L"stop() - %1%") % name_);
450               
451                process_event(ev_stop());
452        }
453
454        void set_state_stopped()
455        {
456                state(torrent_details::torrent_stopped);
457        }
458
459        void force_recheck()
460        {
461                mutex_t::scoped_lock l(mutex_);
462                HAL_DEV_MSG(hal::wform(L"force_recheck() - %1%") % name_);
463               
464                process_event(ev_force_recheck());     
465        }
466       
467        void write_resume_data(const libt::entry& ent)
468        {                                       
469                HAL_DEV_MSG(L"write_resume_data()");
470
471                wpath resume_dir = hal::app().get_working_directory()/L"resume";
472               
473                if (!exists(resume_dir))
474                        create_directory(resume_dir);
475
476                boost::filesystem::ofstream out(resume_dir/(name_ + L".fastresume"), std::ios_base::binary);
477                out.unsetf(std::ios_base::skipws);
478                bencode(std::ostream_iterator<char>(out), ent);
479
480                HAL_DEV_MSG(L"Written!");
481        }
482
483        void save_resume_data()
484        {
485                handle_.save_resume_data();
486        }
487       
488        void clear_resume_data()
489        {
490                wpath resume_file = hal::app().get_working_directory() / L"resume" / (name_ + L".fastresume");
491               
492                if (exists(resume_file))
493                        remove(resume_file);
494        }
495
496        void delete_torrent_file()
497        {               
498                wpath torrent_file = hal::app().get_working_directory() / L"torrents" / filename_;
499               
500                if (exists(torrent_file))
501                        remove(torrent_file);
502        }
503
504        const wpath get_save_directory()
505        {
506                return save_directory_;
507        }
508
509        void set_save_directory(wpath s, bool force=false)
510        {
511                if (in_session() && !is_finished() &&
512                                s != path_from_utf8(handle_.save_path()))
513                {
514                        handle_.move_storage(path_to_utf8(s));
515                        save_directory_ = s;
516                }
517                else if (!in_session() && force)
518                {
519                        save_directory_ = s;
520                }
521        }
522
523        const wpath get_move_to_directory()
524        {
525                return move_to_directory_;
526        }
527       
528        void set_move_to_directory(wpath m)
529        {
530                if (is_finished() && !m.empty())
531                {
532                        if (m != path_from_utf8(handle_.save_path()))
533                        {
534                                handle_.move_storage(path_to_utf8(m));
535                                save_directory_ = move_to_directory_ = m;
536                        }
537                }
538                else
539                {
540                        move_to_directory_ = m;
541                }
542        }
543
544        bool is_finished()
545        {
546                if (in_session())
547                {
548                        libt::torrent_status::state_t s = handle_.status().state;
549
550                        return (s == libt::torrent_status::seeding ||
551                                                s == libt::torrent_status::finished);
552                }
553                else 
554                        return false;
555        }
556       
557        void finished()
558        {
559                if (finish_time_.is_special())
560                        finish_time_ = boost::posix_time::second_clock::universal_time();
561
562                if (is_finished())
563                {
564                        if (!move_to_directory_.empty() && 
565                                        move_to_directory_ !=  path_from_utf8(handle_.save_path()))
566                        {
567                                handle_.move_storage(path_to_utf8(move_to_directory_));
568                                save_directory_ = move_to_directory_;
569                        }
570                }
571        }
572       
573        bool is_active() const { return state() == torrent_details::torrent_active; }
574
575        unsigned get_state()
576        {
577                return state_;
578        }
579       
580        void set_tracker_login(wstring username, wstring password)
581        {
582                tracker_username_ = username;
583                tracker_password_ = password;
584               
585                apply_tracker_login();
586        }       
587       
588        std::pair<wstring, wstring> get_tracker_login() const
589        {
590                return make_pair(tracker_username_, tracker_password_);
591        }
592       
593        const wstring& filename() const { return filename_; }
594       
595        const wstring& original_filename() const { return original_filename_; }
596       
597        const libt::torrent_handle& handle() const { return handle_; }
598
599        void reset_trackers()
600        {
601                if (in_session())
602                {
603                        handle_.replace_trackers(torrent_trackers_);           
604                        trackers_.clear();
605                }
606        }
607       
608        void set_trackers(const std::vector<tracker_detail>& tracker_details)
609        {
610                trackers_.clear();
611                trackers_.assign(tracker_details.begin(), tracker_details.end());
612               
613                apply_trackers();
614        }
615       
616        const std::vector<tracker_detail>& get_trackers()
617        {
618                if (trackers_.empty() && info_memory_)
619                {
620                        std::vector<libt::announce_entry> trackers = info_memory_->trackers();
621                       
622                        foreach (const libt::announce_entry& entry, trackers)
623                        {
624                                trackers_.push_back(
625                                        tracker_detail(hal::from_utf8(entry.url), entry.tier));
626                        }
627                }               
628                return trackers_;
629        }
630       
631        void set_file_priorities(std::vector<int> fileIndices, int priority)
632        {
633                if (!file_priorities_.empty())
634                {
635                        foreach(int i, fileIndices)
636                                file_priorities_[i] = priority;
637                               
638                        apply_file_priorities();
639                }
640        }
641
642        const wpath& save_directory() { return save_directory_; }
643       
644        friend class boost::serialization::access;
645        template<class Archive>
646        void serialize(Archive& ar, const unsigned int version)
647        {
648                using boost::serialization::make_nvp;
649
650                if (version > 1) {
651                        ar & make_nvp("transfer_limits", transfer_limit_);
652                        ar & make_nvp("connection_limits", connections_);
653                        ar & make_nvp("upload_limits", uploads_);       
654
655                        ar & make_nvp("name", name_);
656                        ar & make_nvp("filename", filename_);   
657
658                        ar & make_nvp("ratio", ratio_); 
659                        ar & make_nvp("progress", progress_);
660                        ar & make_nvp("state", state_);
661        //                      ar & make_nvp("compact_storage", compact_storage_);     
662                        ar & make_nvp("allocation_type", allocation_); 
663                        ar & make_nvp("resolve_countries", resolve_countries_); 
664
665                        ar & make_nvp("tracker_username", tracker_username_);
666                        ar & make_nvp("tracker_password", tracker_password_);
667                        ar & make_nvp("trackers", trackers_);
668
669                        ar & make_nvp("save_directory", save_directory_);
670                        ar & make_nvp("move_to_directory", move_to_directory_);
671                       
672                        ar & make_nvp("payload_uploaded", payload_uploaded_);
673                        ar & make_nvp("payload_downloaded", payload_downloaded_);
674                        ar & make_nvp("uploaded", uploaded_);
675                        ar & make_nvp("downloaded", downloaded_);                       
676                                       
677                        ar & make_nvp("file_priorities", file_priorities_);
678                       
679                        ar & make_nvp("start_time", start_time_);
680                        ar & make_nvp("finish_time", finish_time_);
681                        ar & make_nvp("active_duration", active_duration_);
682                        ar & make_nvp("seeding_duration", seeding_duration_);
683                        ar & make_nvp("managed", managed_);                             
684                } 
685                else 
686                {
687                        ar & make_nvp("transferLimit", transfer_limit_);
688                        ar & make_nvp("connections", connections_);
689                        ar & make_nvp("uploads", uploads_);                     
690                        ar & make_nvp("filename", filename_);   
691
692                        wstring s;
693                        ar & make_nvp("saveDirectory", s);
694                        save_directory_ = s;
695
696                        if (version == 2) {
697                                wstring m;
698                                ar & make_nvp("moveToDirectory", m);
699                                move_to_directory_ = m;
700                        } else {
701                                move_to_directory_ = save_directory_;
702                        }
703                       
704                        ar & make_nvp("payload_uploaded_", payload_uploaded_);
705                        ar & make_nvp("payload_downloaded_", payload_downloaded_);
706                        ar & make_nvp("uploaded_", uploaded_);
707                        ar & make_nvp("downloaded_", downloaded_);     
708                        ar & make_nvp("ratio", ratio_); 
709                        ar & make_nvp("trackerUsername", tracker_username_);
710                        ar & make_nvp("trackerPassword", tracker_password_);
711                       
712                        ar & make_nvp("state", state_);
713                        ar & make_nvp("trackers", trackers_);
714                       
715                        ar & make_nvp("resolve_countries", resolve_countries_);
716                       
717                        ar & make_nvp("file_priorities", file_priorities_);
718                       
719                        ar & make_nvp("start_time", start_time_);
720                        ar & make_nvp("activeDuration", active_duration_);
721                        ar & make_nvp("seedingDuration", seeding_duration_);
722                       
723                        ar & make_nvp("name", name_);
724                        ar & make_nvp("compactStorage", compact_storage_);
725                        ar & make_nvp("finish_time", finish_time_);
726                       
727                        ar & make_nvp("progress", progress_);
728                }
729        }
730
731        void set_entry_data(boost::intrusive_ptr<libt::torrent_info> metadata, libtorrent::entry resumedata)
732        {               
733                info_memory_ = metadata;
734        }
735
736        std::vector<libt::peer_info>& peers() { return peers_; }
737       
738        boost::tuple<size_t, size_t, size_t, size_t> update_peers();
739       
740        void get_peer_details(peer_details_vec& peer_details) const
741        {
742                if (in_session())
743                {
744                        foreach (libt::peer_info peer, peers_) 
745                        {
746                                peer_details.insert(peer);
747                        }       
748                }
749        }
750
751        void get_file_details(file_details_vec& files);
752        file_details_vec get_file_details();
753       
754        void prepare(wpath filename);
755
756        void set_resolve_countries(bool b)
757        {
758                resolve_countries_ = b;
759                apply_resolve_countries();
760        }
761       
762        void extract_names(boost::intrusive_ptr<libt::torrent_info> metadata);
763       
764        boost::intrusive_ptr<libt::torrent_info> info_memory()
765        {
766                if (!info_memory_) 
767                        info_memory_ = boost::intrusive_ptr<libt::torrent_info>
768                                (new libt::torrent_info(path_to_utf8(filename())));
769               
770                return info_memory_;
771        }
772       
773        signalers& signals()
774        {
775                mutex_t::scoped_lock l(mutex_);
776                return signals_;
777        }       
778       
779        unsigned state() const 
780        { 
781                if (!in_session())
782                {
783                        if (state_ != torrent_details::torrent_stopped)
784                        {                       
785                                HAL_DEV_MSG(L"Should really be stopped!");
786                                state_ = torrent_details::torrent_stopped;
787                        }
788                }
789               
790                return state_; 
791        }
792
793        wstring check_error() 
794        {               
795                if (in_session())
796                {
797                        status_memory_ = handle_.status();
798                        return from_utf8(status_memory_.error);
799                }
800                else
801                        return L"";
802        }
803
804        bool awaiting_resume_data() { return (state_downcast<const resume_data_waiting*>() != 0); }
805
806        void output_torrent_debug_details()
807        {
808                HAL_DEV_MSG(wform(L"Name %1%") % name_);
809                HAL_DEV_MSG(wform(L" >> In session       %1%") % in_session());
810
811                if (in_session())
812                {
813
814                wstring state_str;
815
816                switch (state())
817                {
818                case torrent_details::torrent_active:
819                        state_str = L"Active";
820                        break;
821
822                case torrent_details::torrent_paused:
823                        state_str = app().res_wstr(HAL_TORRENT_PAUSED);
824                        break;
825                       
826                case torrent_details::torrent_pausing:
827                        state_str = app().res_wstr(HAL_TORRENT_PAUSING);
828                        break;
829                       
830                case torrent_details::torrent_stopped:
831                        state_str = app().res_wstr(HAL_TORRENT_STOPPED);
832                        break;
833                       
834                case torrent_details::torrent_stopping:
835                        state_str = app().res_wstr(HAL_TORRENT_STOPPING);
836                        break;
837                       
838                case torrent_details::torrent_in_error:
839                        state_str = app().res_wstr(HAL_TORRENT_IN_ERROR);
840                        break;
841                };
842               
843                HAL_DEV_MSG(wform(L" >> State            %1%") % state_str);
844                HAL_DEV_MSG(wform(L" >> Session Paused   %1%") % handle_.is_paused());
845                HAL_DEV_MSG(wform(L" >> Error state      %1%") % check_error());
846
847                }
848        }
849
850        static libt::session* the_session_;     
851
852        friend class torrent_manager;
853
854private:
855        void apply_settings(); 
856        void apply_transfer_speed();
857        void apply_connection_limit(); 
858        void apply_ratio();     
859        void apply_trackers(); 
860        void apply_tracker_login();     
861        void apply_file_priorities();   
862        void apply_resolve_countries();
863        void state(unsigned s);
864
865        void initialize_state_machine(torrent_internal_ptr p)
866        {
867                own_weak_ptr_ = boost::weak_ptr<torrent_internal>(p);
868
869                TORRENT_STATE_LOG(L"Torrent state machine initiate");
870                initiate();
871        }
872
873        mutable mutex_t mutex_;
874        signalers signals_;
875
876        boost::weak_ptr<torrent_internal> own_weak_ptr_;
877       
878        std::pair<float, float> transfer_limit_;
879       
880        mutable unsigned state_;
881        int connections_;
882        int uploads_;
883        bool in_session_;
884        float ratio_;
885        bool resolve_countries_;
886       
887        wstring filename_;
888        wstring name_;
889        wpath save_directory_;
890        wpath move_to_directory_;
891        wstring original_filename_;
892        libt::torrent_handle handle_;   
893        wstring tracker_username_;     
894        wstring tracker_password_;
895       
896        boost::int64_t total_uploaded_;
897        boost::int64_t total_base_;
898       
899        transfer_tracker<boost::int64_t> payload_uploaded_;
900        transfer_tracker<boost::int64_t> payload_downloaded_;
901        transfer_tracker<boost::int64_t> uploaded_;
902        transfer_tracker<boost::int64_t> downloaded_;
903       
904        pt::ptime start_time_;
905        pt::ptime finish_time_;
906        duration_tracker active_duration_;
907        duration_tracker seeding_duration_;
908       
909        std::vector<tracker_detail> trackers_;
910        std::vector<libt::announce_entry> torrent_trackers_;
911        std::vector<libt::peer_info> peers_;   
912        std::vector<int> file_priorities_;
913       
914        float progress_;       
915        int queue_position_;
916        bool compact_storage_;
917        bool managed_;
918        bit::allocations allocation_;
919       
920        boost::intrusive_ptr<libt::torrent_info> info_memory_;
921        libt::torrent_status status_memory_;
922        file_details_vec file_details_memory_;
923};
924
925} // namespace hal
926
927#include "halTorrentIntStates.hpp"
928
Note: See TracBrowser for help on using the repository browser.