Changeset 746


Ignore:
Timestamp:
04/19/09 16:12:04 (10 years ago)
Author:
Eoin
Message:

Adding a session state_machine.

Location:
trunk
Files:
2 added
5 edited

Legend:

Unmodified
Added
Removed
  • trunk/sln/Halite/Halite.vcproj

    r741 r746  
    15381538                        </File> 
    15391539                        <File 
     1540                                RelativePath="..\..\src\halCatchDefines.hpp" 
     1541                                > 
     1542                        </File> 
     1543                        <File 
    15401544                                RelativePath="..\..\src\halConfig.hpp" 
    15411545                                > 
     
    16031607                        <File 
    16041608                                RelativePath="..\..\src\halSession.hpp" 
     1609                                > 
     1610                        </File> 
     1611                        <File 
     1612                                RelativePath="..\..\src\halSessionStates.hpp" 
    16051613                                > 
    16061614                        </File> 
  • trunk/src/halSession.cpp

    r745 r746  
    3232 
    3333bit_impl::bit_impl() : 
    34         session_(libt::fingerprint(HALITE_FINGERPRINT)), 
    3534        keepChecking_(false), 
    3635        bittorrent_ini_(L"BitTorrent.xml"), 
     
    4746        dht_on_(false) 
    4847{ 
     48        session_ = boost::in_place(libt::fingerprint(HALITE_FINGERPRINT)); 
     49 
    4950        try 
    5051        { 
     
    5253        torrent_internal::the_session_ = &session_; 
    5354 
    54         session_.session::set_alert_mask(libt::alert::all_categories);           
    55         session_.add_extension(&libt::create_metadata_plugin); 
    56         session_.add_extension(&libt::create_ut_pex_plugin); 
    57         session_.set_max_half_open_connections(10); 
     55        session_->session::set_alert_mask(libt::alert::all_categories);          
     56        session_->add_extension(&libt::create_metadata_plugin); 
     57        session_->add_extension(&libt::create_ut_pex_plugin); 
     58        session_->set_max_half_open_connections(10); 
    5859         
    5960        hal::event_log().post(shared_ptr<hal::EventDetail>( 
     
    111112        } 
    112113         
    113         {       libt::session_settings settings = session_.settings(); 
     114        {       libt::session_settings settings = session_->settings(); 
    114115                settings.user_agent = string("Halite ") + HALITE_VERSION_STRING; 
    115                 session_.set_settings(settings); 
     116                session_->set_settings(settings); 
    116117        } 
    117118         
     
    405406        { 
    406407         
    407         std::auto_ptr<libt::alert> p_alert = session_.pop_alert(); 
     408        std::auto_ptr<libt::alert> p_alert = session_->pop_alert(); 
    408409         
    409410        class AlertHandler 
     
    780781                } 
    781782                 
    782                 p_alert = session_.pop_alert(); 
     783                p_alert = session_->pop_alert(); 
    783784 
    784785                boost::this_thread::interruption_point(); 
  • trunk/src/halSession.hpp

    r745 r746  
    4343#include "halTorrentManager.hpp" 
    4444#include "halSignaler.hpp" 
     45#include "halCatchDefines.hpp" 
    4546 
    4647namespace boost { 
     
    222223} 
    223224 
    224 #define HAL_GENERIC_TORRENT_PROP_EXCEPTION_CATCH(FUNCTION) \ 
    225 catch (const libt::invalid_handle&) \ 
    226 {\ 
    227         event_log().post(shared_ptr<EventDetail>( \ 
    228                 new EventInvalidTorrent(event_logger::info, event_logger::invalid_torrent, name, std::string(FUNCTION)))); \ 
    229 }\ 
    230 catch (const invalid_torrent& t) \ 
    231 { \ 
    232         event_log().post(shared_ptr<EventDetail>( \ 
    233                 new EventInvalidTorrent(event_logger::info, event_logger::invalid_torrent, t.who(), std::string(FUNCTION)))); \ 
    234 } \ 
    235 catch (const access_violation& e) \ 
    236 { \ 
    237         hal::event_log().post(shared_ptr<hal::EventDetail>( \ 
    238                 new hal::EventMsg(hal::wform(L"Torrent property %1% access_violation (code %2$x) at %3$x. Bad address %4$x") % hal::from_utf8(FUNCTION) % e.code() % (unsigned)e.where() % (unsigned)e.badAddress(), \ 
    239                         hal::event_logger::critical))); \ 
    240 } \ 
    241 catch (const win32_exception& e) \ 
    242 { \ 
    243         hal::event_log().post(shared_ptr<hal::EventDetail>( \ 
    244                 new hal::EventMsg(hal::wform(L"Torrent property %1% win32_exception (code %2$x) at %3$x") % hal::from_utf8(FUNCTION) % e.code() % (unsigned)e.where(), \ 
    245                         hal::event_logger::critical))); \ 
    246 } \ 
    247 catch (const std::exception& e) \ 
    248 { \ 
    249         event_log().post(shared_ptr<EventDetail>( \ 
    250                 new EventTorrentException(event_logger::critical, event_logger::torrentException, std::string(e.what()), name, std::string(FUNCTION)))); \ 
    251 } \ 
    252 catch(...) \ 
    253 { \ 
    254         hal::event_log().post(shared_ptr<hal::EventDetail>( \ 
    255                 new hal::EventMsg(hal::wform(L"%1% catch all") % hal::from_utf8(FUNCTION), \ 
    256                         hal::event_logger::critical))); \ 
    257 } 
    258  
    259 #define HAL_GENERIC_TORRENT_EXCEPTION_CATCH(TORRENT, FUNCTION) \ 
    260 catch (const libt::invalid_handle&) \ 
    261 {\ 
    262         event_log().post(shared_ptr<EventDetail>( \ 
    263                 new EventInvalidTorrent(event_logger::info, event_logger::invalid_torrent, TORRENT, std::string(FUNCTION)))); \ 
    264 }\ 
    265 catch (const invalid_torrent& t) \ 
    266 {\ 
    267         event_log().post(shared_ptr<EventDetail>( \ 
    268                 new EventInvalidTorrent(event_logger::info, event_logger::invalid_torrent, t.who(), std::string(FUNCTION)))); \ 
    269 }\ 
    270 catch (const access_violation& e) \ 
    271 { \ 
    272         hal::event_log().post(shared_ptr<hal::EventDetail>( \ 
    273                 new hal::EventMsg(hal::wform(L"Generic Torrent %1% access_violation (code %2$x) at %3$x. Bad address %4$x (%5%)") % hal::from_utf8(FUNCTION) % e.code() % (unsigned)e.where() % (unsigned)e.badAddress() % TORRENT, \ 
    274                         hal::event_logger::critical))); \ 
    275 } \ 
    276 catch (const win32_exception& e) \ 
    277 { \ 
    278         hal::event_log().post(shared_ptr<hal::EventDetail>( \ 
    279                 new hal::EventMsg(hal::wform(L"Generic Torrent %1% win32_exception (code %2$x) at %3$x (%4%)") % hal::from_utf8(FUNCTION) % e.code() % (unsigned)e.where() % TORRENT, \ 
    280                         hal::event_logger::critical))); \ 
    281 } \ 
    282 catch (const std::exception& e) \ 
    283 { \ 
    284         event_log().post(shared_ptr<EventDetail>( \ 
    285                 new EventTorrentException(event_logger::critical, event_logger::torrentException, std::string(e.what()), TORRENT, std::string(FUNCTION)))); \ 
    286 } \ 
    287 catch (...) \ 
    288 { \ 
    289         hal::event_log().post(shared_ptr<hal::EventDetail>( \ 
    290                 new hal::EventMsg(hal::wform(L"Generic Torrent %1% catch all") % hal::from_utf8(FUNCTION), \ 
    291                         hal::event_logger::critical))); \ 
    292 } 
    293  
    294 #define HAL_GENERIC_PIMPL_EXCEPTION_CATCH(FUNCTION) \ 
    295 catch (const access_violation& e) \ 
    296 { \ 
    297         hal::event_log().post(shared_ptr<hal::EventDetail>( \ 
    298                 new hal::EventMsg(hal::wform(L"Generic Session Pimpl %1% access_violation (code %2$x) at %3$x. Bad address %4$x") % hal::from_utf8(FUNCTION) % e.code() % (unsigned)e.where() % (unsigned)e.badAddress(), \ 
    299                         hal::event_logger::critical))); \ 
    300 } \ 
    301 catch (const win32_exception& e) \ 
    302 { \ 
    303         hal::event_log().post(shared_ptr<hal::EventDetail>( \ 
    304                 new hal::EventMsg(hal::wform(L"Generic Session Pimpl %1% win32_exception (code %2$x) at %3$x") % hal::from_utf8(FUNCTION) % e.code() % (unsigned)e.where(), \ 
    305                         hal::event_logger::critical))); \ 
    306 } \ 
    307 catch (const std::exception& e) \ 
    308 { \ 
    309         hal::event_log().post(shared_ptr<hal::EventDetail>( \ 
    310         new hal::EventMsg(hal::wform(L"Generic Session Pimpl %1% std_exception: %2%") % hal::from_utf8(FUNCTION) % hal::from_utf8(e.what()), \ 
    311                         hal::event_logger::critical))); \ 
    312 } \ 
    313 catch (...) \ 
    314 { \ 
    315         hal::event_log().post(shared_ptr<hal::EventDetail>( \ 
    316                 new hal::EventMsg(hal::wform(L"Generic Session Pimpl %1% catch all") % hal::from_utf8(FUNCTION), \ 
    317                         hal::event_logger::critical))); \ 
    318 } 
     225struct uninitialized; 
    319226 
    320227class bit_impl : 
    321         public sc::state_machine<bit_impl, out_of_session> 
     228        public sc::state_machine<bit_impl, uninitialized> 
    322229{ 
    323230        friend class bit; 
    324231 
    325232private: 
    326         bit_impl();      
     233        bit_impl(); 
     234 
    327235public:  
    328236        ~bit_impl(); 
     
    333241                { 
    334242                 
    335                 if (!session_.is_listening()) 
    336                 { 
    337                         return session_.listen_on(range); 
     243                if (!session_->is_listening()) 
     244                { 
     245                        return session_->listen_on(range); 
    338246                } 
    339247                else 
    340248                { 
    341                         int port = session_.listen_port(); 
     249                        int port = session_->listen_port(); 
    342250                         
    343251                        if (port < range.first || port > range.second) 
    344                                 return session_.listen_on(range);        
     252                                return session_->listen_on(range);       
    345253                        else 
    346254                        { 
     
    367275        int is_listening_on()  
    368276        { 
    369                 if (!session_.is_listening()) 
     277                if (!session_->is_listening()) 
    370278                        return -1;       
    371279                else 
    372                         return session_.listen_port(); 
     280                        return session_->listen_port(); 
    373281        } 
    374282 
     
    376284        { 
    377285                ensure_dht_off(); 
    378                 session_.listen_on(std::make_pair(0, 0)); 
     286                session_->listen_on(std::make_pair(0, 0)); 
    379287        } 
    380288 
     
    392300                { 
    393301                        dht_settings_ = settings; 
    394                         session_.set_dht_settings(dht_settings_); 
     302                        session_->set_dht_settings(dht_settings_); 
    395303                } 
    396304 
     
    399307                        try 
    400308                        { 
    401                         session_.start_dht(dht_state_); 
     309                        session_->start_dht(dht_state_); 
    402310                        dht_on_ = true; 
    403311                        } 
     
    412320                if (dht_on_) 
    413321                { 
    414                         session_.stop_dht();             
     322                        session_->stop_dht();            
    415323                        dht_on_ = false; 
    416324                } 
     
    423331                        event_log().post(shared_ptr<EventDetail>(new EventMsg(L"Starting UPnP mapping."))); 
    424332 
    425                         upnp_ = session_.start_upnp(); 
     333                        upnp_ = session_->start_upnp(); 
    426334                } 
    427335                else 
     
    429337                        event_log().post(shared_ptr<EventDetail>(new EventMsg(L"Stopping UPnP mapping."))); 
    430338 
    431                         session_.stop_upnp(); 
     339                        session_->stop_upnp(); 
    432340                        upnp_ = NULL; 
    433341                } 
     
    437345                        event_log().post(shared_ptr<EventDetail>(new EventMsg(L"Starting NAT-PMP mapping."))); 
    438346 
    439                         natpmp_ = session_.start_natpmp(); 
     347                        natpmp_ = session_->start_natpmp(); 
    440348                } 
    441349                else 
     
    443351                        event_log().post(shared_ptr<EventDetail>(new EventMsg(L"Stopping NAT-PMP mapping."))); 
    444352 
    445                         session_.stop_natpmp(); 
     353                        session_->stop_natpmp(); 
    446354                        natpmp_ = NULL; 
    447355                } 
     
    458366        void set_timeouts(int peers, int tracker) 
    459367        { 
    460                 libt::session_settings settings = session_.settings(); 
     368                libt::session_settings settings = session_->settings(); 
    461369                settings.peer_connect_timeout = peers; 
    462370                settings.tracker_completion_timeout = tracker; 
    463371 
    464                 session_.set_settings(settings); 
     372                session_->set_settings(settings); 
    465373 
    466374                event_log().post(shared_ptr<EventDetail>(new EventMsg( 
     
    470378        cache_settings get_cache_settings() 
    471379        { 
    472                 libt::session_settings settings = session_.settings(); 
     380                libt::session_settings settings = session_->settings(); 
    473381                cache_settings cache; 
    474382 
     
    481389        void set_cache_settings(const cache_settings& cache) 
    482390        { 
    483                 libt::session_settings settings = session_.settings(); 
     391                libt::session_settings settings = session_->settings(); 
    484392 
    485393                settings.cache_size = cache.cache_size; 
    486394                settings.cache_expiry = cache.cache_expiry; 
    487395 
    488                 session_.set_settings(settings); 
     396                session_->set_settings(settings); 
    489397 
    490398                event_log().post(shared_ptr<EventDetail>(new EventMsg( 
     
    495403        queue_settings get_queue_settings() 
    496404        {                
    497                 libt::session_settings settings = session_.settings(); 
     405                libt::session_settings settings = session_->settings(); 
    498406                queue_settings queue; 
    499407 
     
    515423        void set_queue_settings(const queue_settings& queue) 
    516424        { 
    517                 libt::session_settings settings = session_.settings(); 
     425                libt::session_settings settings = session_->settings(); 
    518426 
    519427                settings.auto_manage_interval = queue.auto_manage_interval; 
     
    529437                settings.close_redundant_connections = queue.close_redundant_connections; 
    530438 
    531                 session_.set_settings(settings); 
     439                session_->set_settings(settings); 
    532440 
    533441                event_log().post(shared_ptr<EventDetail>(new EventMsg( 
     
    538446        timeouts get_timeouts() 
    539447        {                
    540                 libt::session_settings settings = session_.settings(); 
     448                libt::session_settings settings = session_->settings(); 
    541449                timeouts times; 
    542450 
     
    560468        void set_timeouts(const timeouts& times) 
    561469        { 
    562                 libt::session_settings settings = session_.settings(); 
     470                libt::session_settings settings = session_->settings(); 
    563471 
    564472                settings.tracker_completion_timeout = times.tracker_completion_timeout; 
     
    576484                settings.handshake_timeout = times.handshake_timeout; 
    577485 
    578                 session_.set_settings(settings); 
     486                session_->set_settings(settings); 
    579487 
    580488                event_log().post(shared_ptr<EventDetail>(new EventMsg( 
     
    585493        void set_session_limits(int maxConn, int maxUpload) 
    586494        {                
    587                 session_.set_max_uploads(maxUpload); 
    588                 session_.set_max_connections(maxConn); 
     495                session_->set_max_uploads(maxUpload); 
     496                session_->set_max_connections(maxConn); 
    589497                 
    590498                event_log().post(shared_ptr<EventDetail>(new EventMsg( 
     
    596504        { 
    597505                int down = (download > 0) ? static_cast<int>(download*1024) : -1; 
    598                 session_.set_download_rate_limit(down); 
     506                session_->set_download_rate_limit(down); 
    599507                int up = (upload > 0) ? static_cast<int>(upload*1024) : -1; 
    600                 session_.set_upload_rate_limit(up); 
     508                session_->set_upload_rate_limit(up); 
    601509                 
    602510                event_log().post(shared_ptr<EventDetail>(new EventMsg( 
    603511                        hal::wform(L"Set session rates at download %1% and upload %2%.")  
    604                                 % session_.download_rate_limit() % session_.upload_rate_limit()))); 
     512                                % session_->download_rate_limit() % session_->upload_rate_limit()))); 
    605513        } 
    606514 
    607515        cache_details get_cache_details() const 
    608516        { 
    609                 libt::cache_status cs = session_.get_cache_status(); 
     517                libt::cache_status cs = session_->get_cache_status(); 
    610518 
    611519                return cache_details(cs.blocks_written, cs.writes,  
     
    627535                if (!ip_filter_on_) 
    628536                { 
    629                         session_.set_ip_filter(ip_filter_); 
     537                        session_->set_ip_filter(ip_filter_); 
    630538                        ip_filter_on_ = true; 
    631539                        ip_filter_count(); 
     
    648556        void ensure_ip_filter_off() 
    649557        { 
    650                 session_.set_ip_filter(libt::ip_filter()); 
     558                session_->set_ip_filter(libt::ip_filter()); 
    651559                ip_filter_on_ = false; 
    652560                 
     
    721629                { 
    722630                 
    723                 session_.set_pe_settings(pe); 
     631                session_->set_pe_settings(pe); 
    724632                 
    725633                } 
     
    744652                pe.prefer_rc4 = true; 
    745653                 
    746                 session_.set_pe_settings(pe); 
     654                session_->set_pe_settings(pe); 
    747655 
    748656                event_log().post(shared_ptr<EventDetail>(new EventMsg(L"Protocol encryption off."))); 
     
    768676        void start_smart_ban_plugin() 
    769677        { 
    770                 session_.add_extension(&libt::create_smart_ban_plugin); 
     678                session_->add_extension(&libt::create_smart_ban_plugin); 
    771679                event_log().post(shared_ptr<EventDetail>(new EventMsg(L"Started smart ban plugin."))); 
    772680        } 
     
    774682        void start_ut_pex_plugin() 
    775683        { 
    776                 session_.add_extension(&libt::create_ut_pex_plugin); 
     684                session_->add_extension(&libt::create_ut_pex_plugin); 
    777685                event_log().post(shared_ptr<EventDetail>(new EventMsg(L"Started uTorrent peer exchange plugin."))); 
    778686        } 
     
    780688        void start_ut_metadata_plugin() 
    781689        { 
    782                 session_.add_extension(&libt::create_ut_metadata_plugin); 
     690                session_->add_extension(&libt::create_ut_metadata_plugin); 
    783691                event_log().post(shared_ptr<EventDetail>(new EventMsg(L"Started uTorrent metadata plugin."))); 
    784692        } 
     
    786694        void start_metadata_plugin() 
    787695        { 
    788                 session_.add_extension(&libt::create_metadata_plugin); 
     696                session_->add_extension(&libt::create_metadata_plugin); 
    789697                event_log().post(shared_ptr<EventDetail>(new EventMsg(L"Started metadata plugin."))); 
    790698        } 
     
    812720        { 
    813721                ip_filter_ = libt::ip_filter(); 
    814                 session_.set_ip_filter(libt::ip_filter());       
     722                session_->set_ip_filter(libt::ip_filter());      
    815723                ip_filter_changed_ = true; 
    816724                ip_filter_count(); 
     
    997905                event_log().post(shared_ptr<EventDetail>(new EventInfo(L"Stopping all torrents..."))); 
    998906 
    999                 session_.pause();                
     907                session_->pause();               
    1000908 
    1001909                // Ok this polling loop here is a bit curde, but a blocking wait is actually appropiate.                 
     
    1047955                if (dht_on_)  
    1048956                {        
    1049                         halencode(hal::app().get_working_directory()/L"DHTState.bin", session_.dht_state()); 
     957                        halencode(hal::app().get_working_directory()/L"DHTState.bin", session_->dht_state()); 
    1050958                } 
    1051959                 
     
    1066974        bool create_torrent(const create_torrent_params& params, fs::wpath out_file, progress_callback fn); 
    1067975         
    1068         libt::session session_;  
     976        boost::optional<libt::session> session_;         
    1069977        mutable mutex_t mutex_; 
    1070978 
     
    11011009 
    11021010} 
     1011 
     1012#include "halSessionStates.hpp" 
  • trunk/src/halTorrent.cpp

    r745 r746  
    2424namespace hal  
    2525{ 
    26         libtorrent::session* torrent_internal::the_session_ = 0; 
     26        boost::optional<libt::session>* torrent_internal::the_session_ = 0; 
    2727} 
    2828 
     
    521521        SessionDetail details; 
    522522         
    523         details.port = pimpl()->session_.is_listening() ? pimpl()->session_.listen_port() : -1; 
    524          
    525         libt::session_status status = pimpl()->session_.status(); 
     523        details.port = pimpl()->session_->is_listening() ? pimpl()->session_->listen_port() : -1; 
     524         
     525        libt::session_status status = pimpl()->session_->status(); 
    526526         
    527527        details.speed = std::pair<double, double>(status.download_rate, status.upload_rate); 
     
    539539void bit::set_session_half_open_limit(int halfConn) 
    540540{ 
    541         pimpl()->session_.set_max_half_open_connections(halfConn); 
     541        pimpl()->session_->set_max_half_open_connections(halfConn); 
    542542 
    543543        event_log().post(shared_ptr<EventDetail>(new EventMsg( 
    544                 hal::wform(L"Set half-open connections limit to %1%.") % pimpl()->session_.max_half_open_connections()))); 
     544                hal::wform(L"Set half-open connections limit to %1%.") % pimpl()->session_->max_half_open_connections()))); 
    545545} 
    546546 
  • trunk/src/halTorrentInternal.hpp

    r745 r746  
    425425                mutex_t::scoped_lock l(mutex_); 
    426426 
    427                 return (in_session_ && the_session_ != 0 && handle_.is_valid()); 
     427                return (in_session_ && the_session_ && handle_.is_valid()); 
    428428        } 
    429429 
     
    848848        } 
    849849 
    850         static libt::session* the_session_;      
     850        static boost::optional<libt::session>* the_session_;     
    851851 
    852852        friend class torrent_manager; 
Note: See TracChangeset for help on using the changeset viewer.