Changeset 690 for trunk


Ignore:
Timestamp:
01/20/09 18:51:25 (11 years ago)
Author:
Eoin
Message:

Torrent removal (without wiping files) fixed.

Location:
trunk/src
Files:
8 edited

Legend:

Unmodified
Added
Removed
  • trunk/src/HaliteListView.hpp

    r657 r690  
    11 
    2 //         Copyright Eóin O'Callaghan 2006 - 2008. 
     2//         Copyright Eóin O'Callaghan 2006 - 2009. 
    33// Distributed under the Boost Software License, Version 1.0. 
    44//    (See accompanying file LICENSE_1_0.txt or copy at 
  • trunk/src/halSession.cpp

    r689 r690  
    11 
    2 //         Copyright Eóin O'Callaghan 2006 - 2008. 
     2//         Copyright Eóin O'Callaghan 2006 - 2009. 
    33// Distributed under the Boost Software License, Version 1.0. 
    44//    (See accompanying file LICENSE_1_0.txt or copy at 
     
    510510        } 
    511511         
     512        void operator()(libt::torrent_resumed_alert const& a) const 
     513        { 
     514                HAL_DEV_MSG(L"torrent_resumed_alert"); 
     515 
     516                get(a.handle)->locked_process_event(ev_resumed_alert()); 
     517        } 
     518         
    512519        void operator()(libt::save_resume_data_alert const& a) const 
    513520        { 
     
    736743                        libt::torrent_finished_alert, 
    737744                        libt::torrent_paused_alert, 
     745                        libt::torrent_resumed_alert, 
    738746                        libt::peer_error_alert, 
    739747                        libt::peer_ban_alert, 
  • trunk/src/halSession.hpp

    r681 r690  
    11 
    2 //         Copyright Eóin O'Callaghan 2006 - 2008. 
     2//         Copyright Eóin O'Callaghan 2006 - 2009. 
    33// Distributed under the Boost Software License, Version 1.0. 
    44//    (See accompanying file LICENSE_1_0.txt or copy at 
     
    956956                the_torrents_.erase(filename); 
    957957                 
    958                 thread_t t(bind(&bit_impl::removal_thread, this, pTI, false));   
     958        //      thread_t t(bind(&bit_impl::removal_thread, this, pTI, false));   
    959959                 
    960960                } HAL_GENERIC_TORRENT_EXCEPTION_CATCH(filename, "remove_torrent") 
     
    10501050                event_log.post(shared_ptr<EventDetail>(new EventInfo(L"Stopping all torrents..."))); 
    10511051 
    1052                 int     num_active = 0; 
    1053                 for (torrent_manager::torrent_by_name::iterator i=the_torrents_.begin(), e=the_torrents_.end();  
    1054                                 i != e; ++i) 
    1055                 { 
    1056                         if ((*i).torrent && (*i).torrent->state() != torrent_details::torrent_stopped  
    1057                                         && (*i).torrent->state() != torrent_details::torrent_paused) 
     1052                session_.pause();                
     1053 
     1054                // Ok this polling loop here is a bit curde, but a blocking wait is actually appropiate.                 
     1055                {  
     1056                int num_active = 1; 
     1057 
     1058                while (num_active > 0) 
     1059                { 
     1060                        num_active = 0; 
     1061 
     1062                        for (torrent_manager::torrent_by_name::iterator i=the_torrents_.begin(), e=the_torrents_.end();  
     1063                                        i != e; ++i) 
    10581064                        { 
    1059                                 signaler_wrapper<>* sig_pause = new signaler_wrapper<>(bind(&bit_impl::close_counter, this, &num_active)); 
    1060                                 (*i).torrent->signals().torrent_paused.connect(bind(&signaler_wrapper<>::operator(), sig_pause)); 
    1061  
    1062                                 signaler_wrapper<>* sig_resume = new signaler_wrapper<>(bind(&bit_impl::close_counter, this, &num_active)); 
    1063                                 (*i).torrent->signals().resume_data.connect(bind(&signaler_wrapper<>::operator(), sig_resume)); 
    1064  
    1065                                 num_active += 2; // because two things need to happen! 
    1066  
    1067                                 (*i).torrent->save_resume_data(); 
     1065                                if ((*i).torrent &&  
     1066                                                (((*i).torrent->state() != torrent_details::torrent_stopped  
     1067                                                        && (*i).torrent->state() != torrent_details::torrent_paused) 
     1068                                                || (*i).torrent->awaiting_resume_data())) 
     1069                                { 
     1070                                        num_active += 1; 
     1071                                } 
    10681072                        } 
    1069                 } 
    1070  
    1071                 event_log.post(shared_ptr<EventDetail>(new EventInfo(hal::wform(L"%1% active") % (num_active/2)))); 
    1072                 session_.pause();                
    1073  
    1074                 // Ok this polling loop here is a bit curde, but a blocking wait is actually appropiate. 
    1075                 while (num_active > 0) 
    1076                 { 
    1077                         event_log.post(shared_ptr<EventDetail>(new EventInfo(hal::wform(L"%1% still active") % (num_active/2)))); 
     1073 
     1074                        event_log.post(shared_ptr<EventDetail>(new EventInfo(hal::wform(L"%1% still active") % (num_active)))); 
    10781075 
    10791076                        if (fn) (*fn)(num_active/2); 
    10801077                        boost::this_thread::sleep(pt::milliseconds(500)); 
     1078                }  
     1079                 
    10811080                } 
    10821081                 
    10831082                event_log.post(shared_ptr<EventDetail>(new EventInfo(L"All torrents stopped.")));                
    1084                 event_log.post(shared_ptr<EventDetail>(new EventInfo(L"Fast-resume data written."))); 
    10851083                 
    10861084                } HAL_GENERIC_TORRENT_EXCEPTION_CATCH("Torrent Unknown!", "close_all()") 
  • trunk/src/halTorrent.cpp

    r688 r690  
    11 
    2 //         Copyright Eóin O'Callaghan 2006 - 2008. 
     2//         Copyright Eóin O'Callaghan 2006 - 2009. 
    33// Distributed under the Boost Software License, Version 1.0. 
    44//    (See accompanying file LICENSE_1_0.txt or copy at 
  • trunk/src/halTorrentIntEvents.hpp

    r689 r690  
    4949struct ev_stop : sc::event< ev_stop > {}; 
    5050struct ev_resume : sc::event< ev_resume > {}; 
     51struct ev_resumed_alert : sc::event<ev_paused_alert> {}; 
    5152 
    5253struct ev_write_resume_data : sc::event< ev_write_resume_data > {}; 
  • trunk/src/halTorrentIntStates.cpp

    r689 r690  
    2727 
    2828        HAL_DEV_MSG(L"Removing handle from session"); 
    29         t_i.remove_torrent(); 
    30         HAL_DEV_MSG(L"Removed from session!"); 
     29        t_i.the_session_->remove_torrent(t_i.handle_); 
    3130 
    3231        TORRENT_STATE_LOG(L"Exiting ~in_the_session()"); 
     
    3938{ 
    4039        TORRENT_STATE_LOG(L"Entering out_of_session()"); 
     40 
     41        context<torrent_internal>().in_session_ = false; 
    4142} 
    4243 
     
    7273        p.paused = evt.pause(); 
    7374        p.duplicate_is_error = false; 
    74         p.auto_managed = false;//t_i.managed_; 
     75        p.auto_managed = t_i.managed_; 
    7576 
    7677        t_i.handle_ = t_i.the_session_->add_torrent(p); 
     78 
    7779        assert(t_i.handle_.is_valid()); 
    7880        t_i.in_session_ = true; 
     
    199201        TORRENT_STATE_LOG(L"Entering resume_data_waiting()"); 
    200202 
     203        context<torrent_internal>().awaiting_resume_data_ = true; 
    201204        context<torrent_internal>().handle_.save_resume_data(); 
    202205} 
     
    204207resume_data_waiting::~resume_data_waiting() 
    205208{ 
     209        context<torrent_internal>().awaiting_resume_data_ = false; 
     210 
    206211        TORRENT_STATE_LOG(L"Exiting ~resume_data_waiting()"); 
    207212} 
  • trunk/src/halTorrentIntStates.hpp

    r689 r690  
    88 
    99#include "halTorrentInternal.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 
    1910 
    2011#include <boost/statechart/event.hpp> 
     
    5748        typedef sc::state<in_the_session, torrent_internal, mpl::list< resume_data_idling, paused > > base_type; 
    5849 
    59 //      typedef mpl::list< 
    60 //              sc::transition< ev_paused_alert, paused > 
    61 //      > reactions; 
    62  
    6350        in_the_session(base_type::my_context ctx); 
    6451        ~in_the_session(); 
    65  
    6652}; 
    6753 
     
    122108        typedef mpl::list< 
    123109                sc::custom_reaction< ev_stop >, 
    124                 sc::custom_reaction< ev_resume > 
     110                sc::custom_reaction< ev_resume >, 
     111                sc::transition< ev_resumed_alert, active > 
    125112        > reactions; 
    126113 
  • trunk/src/halTorrentInternal.hpp

    r689 r690  
    11 
    2 //         Copyright Eóin O'Callaghan 2006 - 2008. 
     2//         Copyright Eóin O'Callaghan 2006 - 2009. 
    33// Distributed under the Boost Software License, Version 1.0. 
    44//    (See accompanying file LICENSE_1_0.txt or copy at 
     
    295295        public sc::state_machine<torrent_internal, out_of_session> 
    296296{ 
    297 //      friend class bit_impl;   
    298297        friend class bit::torrent::exec_around_ptr::proxy; 
    299298 
     
    316315                uploads_(-1), \ 
    317316                ratio_(0), \ 
     317                awaiting_resume_data_(false), \ 
    318318                resolve_countries_(true), \ 
    319319                total_uploaded_(0), \ 
     
    596596                assert(the_session_ != 0); 
    597597 
    598                 process_event( ev_add_to_session(paused) ); 
     598                process_event(ev_add_to_session(paused)); 
    599599                 
    600600                assert(in_session()); 
    601601                HAL_DEV_MSG(L"Added to session"); 
    602602 
    603                 return; 
    604  
    605                 if (handle_.is_paused()) 
    606                         state(torrent_details::torrent_paused);  
    607  
    608603                } 
    609604                catch(std::exception& e) 
     
    621616 
    622617                mutex_t::scoped_lock l(mutex_); 
    623  
    624                 if (!in_session()) 
    625                 { 
    626                         in_session_ = false; 
    627                         HAL_DEV_MSG(L"Was not is session!"); 
    628  
    629                         return false; 
    630                 } 
    631618                 
    632619                process_event(ev_remove_from_session(write_data)); 
     
    643630        } 
    644631 
    645         void remove_torrent() 
     632/*      void remove_torrent() 
    646633        { 
    647634                the_session_->remove_torrent(handle_); 
     
    650637                assert(!in_session());   
    651638        } 
    652          
     639*/       
    653640        bool in_session() const 
    654641        {  
     
    664651                 
    665652                process_event(ev_resume()); 
    666  
    667                 return; 
    668  
    669                 if (state() == torrent_details::torrent_stopped) 
    670                 {        
    671                         add_to_session(false); 
    672                         assert(in_session());                    
    673                 } 
    674                 else 
    675                 { 
    676                         assert(in_session()); 
    677                         handle_.resume(); 
    678                 }        
    679                  
    680                 state(torrent_details::torrent_active);                  
    681                 //assert(!handle_.is_paused()); 
    682653        } 
    683654         
     
    687658                HAL_DEV_MSG(hal::wform(L"pause() - %1%") % name_); 
    688659                 
    689                 process_event(ev_pause()); 
    690  
    691                 return; 
    692  
    693                 if (state() == torrent_details::torrent_stopped) 
    694                 {        
    695                         add_to_session(true); 
    696  
    697                         assert(in_session()); 
    698                         assert(handle_.is_paused()); 
    699                 } 
    700                 else 
    701                 { 
    702                         assert(in_session()); 
    703  
    704                         HAL_DEV_MSG(hal::wform(L"pause() - handle_.pause()")); 
    705                         handle_.pause(); 
    706  
    707                         signaler_wrapper<>* sig = new signaler_wrapper<>(bind(&torrent_internal::completed_pause, this)); 
    708                         signals().torrent_paused.connect(bind(&signaler_wrapper<>::operator(), sig)); 
    709  
    710                         state(torrent_details::torrent_pausing); 
    711                 }                        
     660                process_event(ev_pause());               
    712661        } 
    713662         
     
    718667                 
    719668                process_event(ev_stop()); 
    720  
    721         /*      HAL_DEV_MSG(hal::wform(L"stop() requesting")); 
    722  
    723                 if (state() != torrent_details::torrent_stopped) 
    724                 { 
    725                         if (state() == torrent_details::torrent_active) 
    726                         { 
    727                                 assert(in_session()); 
    728                                 assert(!(handle_.is_paused())); 
    729  
    730                                 signaler_wrapper<>* sig = new signaler_wrapper<>(bind(&torrent_internal::completed_stop, this)); 
    731                                 signals().torrent_paused.connect(bind(&signaler_wrapper<>::operator(), sig)); 
    732                                  
    733                                 HAL_DEV_MSG(hal::wform(L"stop() - handle_.pause()")); 
    734                                 handle_.pause(); 
    735  
    736                                 state(torrent_details::torrent_stopping); 
    737                         } 
    738                         else if (state() == torrent_details::torrent_paused) 
    739                         {                        
    740                                 remove_from_session(); 
    741                                 state(torrent_details::torrent_stopped);                                 
    742                         } 
    743                 } 
    744         */ 
    745669        } 
    746670 
     
    12321156                return state_;  
    12331157        } 
     1158 
     1159        bool awaiting_resume_data() { return awaiting_resume_data_; } 
    12341160 
    12351161        static libt::session* the_session_;      
     
    14311357         
    14321358        mutable unsigned state_; 
     1359        bool awaiting_resume_data_; 
     1360 
    14331361        int connections_; 
    14341362        int uploads_; 
Note: See TracChangeset for help on using the changeset viewer.