Changeset 688


Ignore:
Timestamp:
01/20/09 14:35:42 (11 years ago)
Author:
Eoin
Message:

torrent_internal state machine needs to be made an async one to address current issues.

Location:
trunk/src
Files:
6 edited

Legend:

Unmodified
Added
Removed
  • trunk/src/halSession.cpp

    r687 r688  
    506506 
    507507                get(a.handle)->signals().torrent_paused(); 
     508 
     509                get(a.handle)->post_event(ev_paused_alert()); 
    508510        } 
    509511         
    510512        void operator()(libt::save_resume_data_alert const& a) const 
    511513        { 
     514                HAL_DEV_MSG(L"save_resume_data_alert"); 
     515 
    512516                event_log.post(shared_ptr<EventDetail>( 
    513517                        new EventMsg((hal::wform(hal::app().res_wstr(HAL_WRITE_RESUME_ALERT))  
  • trunk/src/halTorrent.cpp

    r663 r688  
    662662        return pimpl()->the_torrents_.exists(filename); 
    663663         
    664         } HAL_GENERIC_TORRENT_EXCEPTION_CATCH(filename, "isTorrent") 
     664        } HAL_GENERIC_TORRENT_EXCEPTION_CATCH(filename, "is_torrent") 
    665665         
    666666        return false; 
     
    678678        pimpl()->the_torrents_.get(filename)->pause(); 
    679679         
    680         } HAL_GENERIC_TORRENT_EXCEPTION_CATCH(filename, "pauseTorrent") 
     680        } HAL_GENERIC_TORRENT_EXCEPTION_CATCH(filename, "pause_torrent") 
    681681} 
    682682 
     
    692692        pimpl()->the_torrents_.get(filename)->resume(); 
    693693         
    694         } HAL_GENERIC_TORRENT_EXCEPTION_CATCH(filename, "resumeTorrent") 
     694        } HAL_GENERIC_TORRENT_EXCEPTION_CATCH(filename, "resume_torrent") 
    695695} 
    696696 
     
    706706        pimpl()->the_torrents_.get(filename)->stop(); 
    707707         
    708         } HAL_GENERIC_TORRENT_EXCEPTION_CATCH(filename, "stopTorrent") 
     708        } HAL_GENERIC_TORRENT_EXCEPTION_CATCH(filename, "stop_torrent") 
    709709} 
    710710 
     
    720720        return pimpl()->the_torrents_.get(filename)->is_active(); 
    721721         
    722         } HAL_GENERIC_TORRENT_EXCEPTION_CATCH(filename, "isTorrentActive") 
     722        } HAL_GENERIC_TORRENT_EXCEPTION_CATCH(filename, "is_torrent_active") 
    723723         
    724724        return false; // ??? is this correct 
     
    736736        pimpl()->the_torrents_.get(filename)->handle().force_reannounce(); 
    737737         
    738         } HAL_GENERIC_TORRENT_EXCEPTION_CATCH(filename, "reannounceTorrent") 
     738        } HAL_GENERIC_TORRENT_EXCEPTION_CATCH(filename, "reannounce_torrent") 
    739739} 
    740740 
     
    751751        pimpl()->the_torrents_.get(filename)->force_recheck(); 
    752752         
    753         } HAL_GENERIC_TORRENT_EXCEPTION_CATCH(filename, "recheckTorrent") 
     753        } HAL_GENERIC_TORRENT_EXCEPTION_CATCH(filename, "recheck_torrent") 
    754754} 
    755755 
  • trunk/src/halTorrentIntEvents.hpp

    r687 r688  
    1818namespace sc = boost::statechart; 
    1919 
    20 struct ev_remove_from_session : boost::statechart::event<ev_remove_from_session> 
     20struct ev_remove_from_session : sc::event<ev_remove_from_session> 
    2121{ 
    2222public: 
     
    3131}; 
    3232 
    33 struct ev_add_to_session : boost::statechart::event<ev_add_to_session> 
     33struct ev_add_to_session : sc::event<ev_add_to_session> 
    3434{ 
    3535public: 
     
    4848 
    4949struct ev_stop : sc::event< ev_stop > {}; 
     50struct ev_resume : sc::event< ev_resume > {}; 
    5051 
    51 struct ev_write_resume_data : sc::event< ev_stop > {}; 
     52struct ev_write_resume_data : sc::event< ev_write_resume_data > {}; 
    5253struct ev_resume_data_alert : sc::event< ev_resume_data_alert > {}; 
    5354 
  • trunk/src/halTorrentIntStates.cpp

    r687 r688  
    2222} 
    2323 
    24 sc::result in_the_session::react(const ev_remove_from_session& evt) 
    25 { 
    26         torrent_internal& t_i = context<torrent_internal>(); 
    27  
    28         if (evt.write_data()) 
    29         { 
    30                 HAL_DEV_MSG(L"requesting resume data"); 
    31                 t_i.save_resume_data();  
    32  
    33                 return transit< leaving_session >(); 
    34         } 
    35         else 
    36         { 
    37                 HAL_DEV_MSG(L"removing handle from session"); 
    38                 t_i.remove_torrent(); 
    39  
    40                 assert(!t_i.in_session());       
    41                 HAL_DEV_MSG(L"Removed from session!"); 
    42  
    43                 return transit< out_of_session >(); 
    44         } 
    45 } 
    46  
    4724in_the_session::~in_the_session() 
    48 { 
    49         TORRENT_STATE_LOG(L"Exiting ~in_the_session()"); 
    50 } 
    51  
    52 // -------- leaving_session -------- 
    53  
    54 leaving_session::leaving_session(base_type::my_context ctx) : 
    55         base_type::my_base(ctx) 
    56 { 
    57         TORRENT_STATE_LOG(L"Entering leaving_session()"); 
    58 } 
    59  
    60 leaving_session::~leaving_session() 
    61 { 
    62         TORRENT_STATE_LOG(L"Exiting ~leaving_session()"); 
    63 } 
    64  
    65 sc::result leaving_session::react(const ev_add_to_session& evt) 
    66 { 
    67         torrent_internal& t_i = context<torrent_internal>(); 
    68         assert(t_i.in_session()); 
    69  
    70         return transit< in_the_session >(); 
    71 } 
    72  
    73 sc::result leaving_session::react(const ev_resume_data_alert& evt) 
    7425{ 
    7526        torrent_internal& t_i = context<torrent_internal>(); 
     
    7930        HAL_DEV_MSG(L"Removed from session!"); 
    8031 
    81         return transit< out_of_session >(); 
     32        TORRENT_STATE_LOG(L"Exiting ~in_the_session()"); 
    8233} 
    8334 
     
    12172        p.paused = evt.pause(); 
    12273        p.duplicate_is_error = false; 
    123         p.auto_managed = t_i.managed_; 
     74        p.auto_managed = false;//t_i.managed_; 
    12475 
    12576        t_i.handle_ = t_i.the_session_->add_torrent(p);          
     
    12778        t_i.in_session_ = true; 
    12879 
    129         return transit< in_the_session >(); 
     80        if (evt.pause()) 
     81                return transit< paused >(); 
     82        else 
     83                return transit< active >(); 
    13084} 
    13185 
     
    13488{ 
    13589        TORRENT_STATE_LOG(L"Entering active()"); 
     90 
     91        torrent_internal& t_i = context<torrent_internal>(); 
     92        t_i.state(torrent_details::torrent_active); 
    13693} 
    13794 
     
    153110} 
    154111 
    155 pausing::pausing() 
     112pausing::pausing(base_type::my_context ctx) : 
     113        base_type::my_base(ctx) 
    156114{ 
    157115        TORRENT_STATE_LOG(L"Entering pausing()"); 
     116 
     117        torrent_internal& t_i = context<torrent_internal>(); 
     118        t_i.state(torrent_details::torrent_pausing); 
    158119} 
    159120 
     
    167128{ 
    168129        TORRENT_STATE_LOG(L"Entering paused()"); 
     130 
     131        torrent_internal& t_i = context<torrent_internal>(); 
     132        t_i.state(torrent_details::torrent_paused); 
    169133} 
    170134 
     
    174138} 
    175139 
    176 stopping::stopping() 
     140sc::result paused::react(const ev_resume& evt) 
     141{ 
     142        context<torrent_internal>().handle_.resume(); 
     143 
     144        return transit< active >(); 
     145} 
     146 
     147stopping::stopping(base_type::my_context ctx) : 
     148        base_type::my_base(ctx) 
    177149{ 
    178150        TORRENT_STATE_LOG(L"Entering stopping()"); 
     
    182154{ 
    183155        TORRENT_STATE_LOG(L"Exiting ~stopping()"); 
     156 
     157        torrent_internal& t_i = context<torrent_internal>(); 
     158        t_i.state(torrent_details::torrent_stopping); 
    184159} 
    185160 
     
    191166}*/ 
    192167 
    193 stopped::stopped() 
     168stopped::stopped(base_type::my_context ctx) : 
     169        base_type::my_base(ctx) 
    194170{ 
    195171        TORRENT_STATE_LOG(L"Entering stopped()"); 
     172 
     173        torrent_internal& t_i = context<torrent_internal>(); 
     174        t_i.state(torrent_details::torrent_stopped); 
    196175} 
    197176 
     
    201180} 
    202181 
     182sc::result stopped::react(const ev_resume& evt) 
     183{ 
     184//      torrent_internal& t_i = context<torrent_internal>(); 
     185//      assert(t_i.in_session()); 
     186 
     187        post_event(ev_add_to_session(false)); 
     188 
     189//      context<torrent_internal>().add_to_session(false); 
     190 
     191        return discard_event(); 
     192} 
     193 
    203194resume_data_waiting::resume_data_waiting(base_type::my_context ctx) : 
    204195        base_type::my_base(ctx) 
  • trunk/src/halTorrentIntStates.hpp

    r687 r688  
    4646}; 
    4747 
    48 struct leaving_session : sc::state<leaving_session, torrent_internal>  
    49 { 
    50         typedef sc::state<leaving_session, torrent_internal> base_type; 
    51  
    52         typedef mpl::list< 
    53                 sc::custom_reaction< ev_add_to_session >, 
    54                 sc::custom_reaction< ev_resume_data_alert > 
    55         > reactions; 
    56  
    57         leaving_session(base_type::my_context ctx); 
    58         ~leaving_session();      
    59  
    60         sc::result react(const ev_resume_data_alert& evt); 
    61         sc::result react(const ev_add_to_session& evt); 
    62 }; 
    63  
    6448struct active; 
    6549struct pausing; 
     
    7357        typedef sc::state<in_the_session, torrent_internal, mpl::list< resume_data_idling, paused > > base_type; 
    7458 
    75         typedef mpl::list< 
    76                 sc::custom_reaction< ev_remove_from_session > 
    77         > reactions; 
     59//      typedef mpl::list< 
     60//              sc::transition< ev_paused_alert, paused > 
     61//      > reactions; 
    7862 
    7963        in_the_session(base_type::my_context ctx); 
    8064        ~in_the_session(); 
    8165 
    82         sc::result react(const ev_remove_from_session& evt); 
    8366}; 
    8467 
     
    8669{ 
    8770        typedef mpl::list< 
    88                 sc::transition< ev_paused_alert, resume_data_waiting > 
     71                sc::transition< ev_write_resume_data, resume_data_waiting > 
    8972        > reactions; 
    9073 
     
    11194        typedef mpl::list< 
    11295                sc::custom_reaction< ev_pause >, 
    113                 sc::custom_reaction< ev_stop > 
     96                sc::custom_reaction< ev_stop >, 
     97                sc::transition< ev_paused_alert, paused > 
    11498        > reactions; 
    11599 
     
    121105}; 
    122106 
    123 struct pausing : sc::simple_state<pausing, in_the_session::orthogonal< 1 > > 
     107struct pausing : sc::state<pausing, in_the_session::orthogonal< 1 > > 
    124108{ 
     109        typedef sc::state<pausing, in_the_session::orthogonal< 1 > > base_type; 
     110 
    125111        typedef sc::transition< ev_paused_alert, paused > reactions; 
    126112 
    127         pausing(); 
     113        pausing(base_type::my_context ctx); 
    128114        ~pausing(); 
    129115}; 
     
    133119        typedef sc::state<paused, in_the_session::orthogonal< 1 > > base_type; 
    134120 
     121        typedef mpl::list< 
     122                sc::transition< ev_stop, stopping >, 
     123                sc::custom_reaction< ev_resume > 
     124        > reactions; 
     125 
    135126        paused(base_type::my_context ctx); 
    136127        ~paused(); 
     128 
     129        sc::result react(const ev_resume& evt); 
    137130}; 
    138131 
    139 struct stopping : sc::simple_state<stopping, in_the_session::orthogonal< 1 > > 
     132struct stopping : sc::state<stopping, in_the_session::orthogonal< 1 > > 
    140133{ 
     134        typedef sc::state<stopping, in_the_session::orthogonal< 1 > > base_type; 
     135 
    141136        typedef mpl::list< 
    142137        //      sc::custom_reaction< ev_paused_alert >, 
    143                 sc::transition< ev_resume_data_alert, stopped > 
     138                sc::transition< ev_paused_alert, stopped > 
    144139        > reactions; 
    145140 
    146         stopping(); 
     141        stopping(base_type::my_context ctx); 
    147142        ~stopping(); 
    148143 
     
    150145}; 
    151146 
    152 struct stopped : sc::simple_state<stopped, out_of_session> 
     147struct stopped : sc::state<stopped, out_of_session> 
    153148{ 
    154         stopped(); 
     149        typedef sc::state<stopped, out_of_session> base_type; 
     150 
     151        typedef mpl::list< 
     152                sc::custom_reaction< ev_resume > 
     153        > reactions; 
     154 
     155        stopped(base_type::my_context ctx); 
    155156        ~stopped(); 
     157 
     158        sc::result react(const ev_resume& evt); 
    156159}; 
    157160 
  • trunk/src/halTorrentInternal.hpp

    r687 r688  
    350350 
    351351        #undef TORRENT_INTERNALS_DEFAULTS 
     352 
     353        ~torrent_internal() 
     354        { 
     355                terminate(); 
     356        } 
    352357         
    353358        torrent_details_ptr get_torrent_details_ptr() 
     
    590595                HAL_DEV_MSG(L"Added to session"); 
    591596 
     597                return; 
     598 
    592599                if (handle_.is_paused()) 
    593600                        state(torrent_details::torrent_paused);  
     
    617624                } 
    618625                 
    619                 process_event( ev_remove_from_session(write_data) ); 
     626                process_event(ev_remove_from_session(write_data)); 
    620627 
    621628                return true; 
     
    649656                mutex_t::scoped_lock l(mutex_); 
    650657                HAL_DEV_MSG(hal::wform(L"resume() - %1%") % name_); 
     658                 
     659                process_event(ev_resume()); 
     660 
     661                return; 
    651662 
    652663                if (state() == torrent_details::torrent_stopped) 
     
    669680                mutex_t::scoped_lock l(mutex_); 
    670681                HAL_DEV_MSG(hal::wform(L"pause() - %1%") % name_); 
     682                 
     683                process_event(ev_pause()); 
     684 
     685                return; 
    671686 
    672687                if (state() == torrent_details::torrent_stopped) 
     
    695710                mutex_t::scoped_lock l(mutex_); 
    696711                HAL_DEV_MSG(hal::wform(L"stop() - %1%") % name_); 
    697  
    698                 HAL_DEV_MSG(hal::wform(L"stop() requesting")); 
     712                 
     713                process_event(ev_stop()); 
     714 
     715        /*      HAL_DEV_MSG(hal::wform(L"stop() requesting")); 
    699716 
    700717                if (state() != torrent_details::torrent_stopped) 
     
    719736                        } 
    720737                } 
     738        */ 
    721739        } 
    722740 
Note: See TracChangeset for help on using the changeset viewer.