Changeset 689 for trunk


Ignore:
Timestamp:
01/20/09 16:19:52 (11 years ago)
Author:
Eoin
Message:

Used a blocking access to the torrent_internal instead.

Location:
trunk/src
Files:
5 edited

Legend:

Unmodified
Added
Removed
  • trunk/src/halSession.cpp

    r688 r689  
    507507                get(a.handle)->signals().torrent_paused(); 
    508508 
    509                 get(a.handle)->post_event(ev_paused_alert()); 
     509                get(a.handle)->locked_process_event(ev_paused_alert()); 
    510510        } 
    511511         
     
    523523                get(a.handle)->signals().resume_data(); 
    524524 
    525                 get(a.handle)->post_event(ev_resume_data_alert()); 
     525                get(a.handle)->locked_process_event(ev_resume_data_alert()); 
     526        } 
     527         
     528        void operator()(libt::save_resume_data_failed_alert const& a) const 
     529        { 
     530                HAL_DEV_MSG(L"save_resume_failed_data_alert"); 
     531 
     532/*              event_log.post(shared_ptr<EventDetail>( 
     533                        new EventMsg((hal::wform(hal::app().res_wstr(HAL_WRITE_RESUME_ALERT))  
     534                                        % get(a.handle)->name()),  
     535                                event_logger::warning, a.timestamp()))); */ 
     536 
     537                get(a.handle)->locked_process_event(ev_resume_data_failed_alert()); 
    526538        } 
    527539         
     
    717729                libt::handle_alert< 
    718730                        libt::save_resume_data_alert, 
     731                        libt::save_resume_data_failed_alert, 
    719732                        libt::external_ip_alert, 
    720733                        libt::portmap_error_alert, 
  • trunk/src/halTorrentIntEvents.hpp

    r688 r689  
    5252struct ev_write_resume_data : sc::event< ev_write_resume_data > {}; 
    5353struct ev_resume_data_alert : sc::event< ev_resume_data_alert > {}; 
     54struct ev_resume_data_failed_alert : sc::event< ev_resume_data_alert > {}; 
    5455 
    5556} // namespace hal 
  • trunk/src/halTorrentIntStates.cpp

    r688 r689  
    7474        p.auto_managed = false;//t_i.managed_; 
    7575 
    76         t_i.handle_ = t_i.the_session_->add_torrent(p);          
     76        t_i.handle_ = t_i.the_session_->add_torrent(p); 
    7777        assert(t_i.handle_.is_valid()); 
    7878        t_i.in_session_ = true; 
     
    100100} 
    101101 
    102 sc::result active::react(const ev_pause& evt) 
    103 { 
    104         return transit< pausing >(); 
    105 } 
    106  
    107 sc::result active::react(const ev_stop& evt) 
    108 { 
    109         return transit< stopping >(); 
    110 } 
    111  
    112102pausing::pausing(base_type::my_context ctx) : 
    113103        base_type::my_base(ctx) 
     
    131121        torrent_internal& t_i = context<torrent_internal>(); 
    132122        t_i.state(torrent_details::torrent_paused); 
     123 
     124        post_event(ev_write_resume_data()); 
    133125} 
    134126 
     
    138130} 
    139131 
     132sc::result paused::react(const ev_stop& evt) 
     133{ 
     134        if (state_downcast<const resume_data_waiting*>() != 0 ) 
     135                return transit< stopping >(); 
     136        else 
     137                return transit< stopped >(); 
     138} 
     139 
    140140sc::result paused::react(const ev_resume& evt) 
    141141{ 
     
    159159} 
    160160 
    161 /*sc::result stopping::react(const ev_paused_alert& evt) 
    162 { 
    163         context<torrent_internal>().handle_.save_resume_data(); 
     161sc::result stopping::react(const ev_paused_alert& evt) 
     162{ 
     163        TORRENT_STATE_LOG(L"React stopping::react(const ev_paused_alert& evt)"); 
     164 
     165        post_event(ev_write_resume_data()); 
    164166 
    165167        return discard_event(); 
    166 }*/ 
     168} 
    167169 
    168170stopped::stopped(base_type::my_context ctx) : 
  • trunk/src/halTorrentIntStates.hpp

    r688 r689  
    8181 
    8282        typedef mpl::list< 
    83                 sc::transition< ev_resume_data_alert, resume_data_idling > 
     83                sc::transition< ev_resume_data_alert, resume_data_idling >, 
     84                sc::transition< ev_resume_data_failed_alert, resume_data_idling > 
    8485        > reactions; 
    8586 
     
    9394 
    9495        typedef mpl::list< 
    95                 sc::custom_reaction< ev_pause >, 
    96                 sc::custom_reaction< ev_stop >, 
     96                sc::transition< ev_stop, stopping >, 
     97                sc::transition< ev_pause, pausing >, 
    9798                sc::transition< ev_paused_alert, paused > 
    9899        > reactions; 
     
    120121 
    121122        typedef mpl::list< 
    122                 sc::transition< ev_stop, stopping >, 
     123                sc::custom_reaction< ev_stop >, 
    123124                sc::custom_reaction< ev_resume > 
    124125        > reactions; 
     
    127128        ~paused(); 
    128129 
     130        sc::result react(const ev_stop& evt); 
    129131        sc::result react(const ev_resume& evt); 
    130132}; 
     
    135137 
    136138        typedef mpl::list< 
    137         //      sc::custom_reaction< ev_paused_alert >, 
    138                 sc::transition< ev_paused_alert, stopped > 
     139                sc::custom_reaction< ev_paused_alert >, 
     140                sc::transition< ev_resume_data_alert, stopped >, 
     141                sc::transition< ev_resume_data_failed_alert, stopped > 
    139142        > reactions; 
    140143 
     
    142145        ~stopping(); 
    143146 
    144         //sc::result react(const ev_paused_alert& evt); 
     147        sc::result react(const ev_paused_alert& evt); 
    145148}; 
    146149 
  • trunk/src/halTorrentInternal.hpp

    r688 r689  
    295295        public sc::state_machine<torrent_internal, out_of_session> 
    296296{ 
    297         friend class bit_impl;   
     297//      friend class bit_impl;   
    298298        friend class bit::torrent::exec_around_ptr::proxy; 
    299299 
     
    334334        } 
    335335         
    336                 torrent_internal(wpath filename, wpath saveDirectory, bit::allocations alloc, wpath move_to_directory=L"") : 
     336        torrent_internal(wpath filename, wpath saveDirectory, bit::allocations alloc, wpath move_to_directory=L"") : 
    337337                TORRENT_INTERNALS_DEFAULTS, 
    338338                save_directory_(saveDirectory.string()), 
     
    350350 
    351351        #undef TORRENT_INTERNALS_DEFAULTS 
     352 
     353        void locked_process_event(const sc::event_base & e) 
     354        { 
     355                mutex_t::scoped_lock l(mutex_); 
     356                process_event(e); 
     357        } 
    352358 
    353359        ~torrent_internal() 
     
    11901196                mutex_t::scoped_lock l(mutex_); 
    11911197                return signals_; 
    1192         } 
     1198        }        
     1199         
     1200        unsigned state() const  
     1201        {  
     1202                if (in_session()) 
     1203                { 
     1204/*                      if (handle_.is_paused()) 
     1205                        { 
     1206                                if (state_ != torrent_details::torrent_paused) 
     1207                                {                        
     1208                                        HAL_DEV_MSG(L"Should really be paused!"); 
     1209                                        state_ = torrent_details::torrent_paused; 
     1210                                } 
     1211                        } 
     1212                        else                             
     1213                        {                        
     1214                                if (state_ != torrent_details::torrent_active && 
     1215                                        state_ != torrent_details::torrent_pausing && 
     1216                                        state_ != torrent_details::torrent_stopping) 
     1217                                {                        
     1218                                        HAL_DEV_MSG(L"Should really be active!"); 
     1219                                        state_ = torrent_details::torrent_active; 
     1220                                } 
     1221                        }                       */               
     1222                } 
     1223                else 
     1224                { 
     1225                        if (state_ != torrent_details::torrent_stopped) 
     1226                        {                        
     1227                                HAL_DEV_MSG(L"Should really be stopped!"); 
     1228                                state_ = torrent_details::torrent_stopped; 
     1229                        } 
     1230                } 
     1231                 
     1232                return state_;  
     1233        } 
     1234 
     1235        static libt::session* the_session_;      
    11931236 
    11941237private:         
     
    13791422                }; 
    13801423                state_ = s; 
    1381         }        
    1382          
    1383         unsigned state() const  
    1384         {  
    1385                 if (in_session()) 
    1386                 { 
    1387                         if (handle_.is_paused()) 
    1388                         { 
    1389                                 if (state_ != torrent_details::torrent_paused) 
    1390                                 {                        
    1391                                         HAL_DEV_MSG(L"Should really be paused!"); 
    1392                                         state_ = torrent_details::torrent_paused; 
    1393                                 } 
    1394                         } 
    1395                         else                             
    1396                         {                        
    1397                                 if (state_ != torrent_details::torrent_active && 
    1398                                         state_ != torrent_details::torrent_pausing && 
    1399                                         state_ != torrent_details::torrent_stopping) 
    1400                                 {                        
    1401                                         HAL_DEV_MSG(L"Should really be active!"); 
    1402                                         state_ = torrent_details::torrent_active; 
    1403                                 } 
    1404                         }                        
    1405                 } 
    1406                 else 
    1407                 { 
    1408                         if (state_ != torrent_details::torrent_stopped) 
    1409                         {                        
    1410                                 HAL_DEV_MSG(L"Should really be stopped!"); 
    1411                                 state_ = torrent_details::torrent_stopped; 
    1412                         } 
    1413                 } 
    1414                  
    1415                 return state_;  
    1416         } 
    1417                  
    1418         static libt::session* the_session_;      
     1424        } 
     1425                 
    14191426        mutable mutex_t mutex_; 
    14201427 
Note: See TracChangeset for help on using the changeset viewer.