Ignore:
Timestamp:
07/16/08 18:55:41 (11 years ago)
Author:
Eoin
Message:

Cleaned up trunk alert handler code.

File:
1 edited

Legend:

Unmodified
Added
Removed
  • trunk/src/halSession.cpp

    r496 r503  
    88 
    99#define TORRENT_MAX_ALERT_TYPES 32 
     10 
     11#include <boost/utility/in_place_factory.hpp> 
     12#include <boost/none.hpp> 
    1013 
    1114#include <libtorrent/alert_types.hpp> 
     
    2730namespace hal 
    2831{ 
     32 
     33bit_impl::bit_impl() : 
     34        session_(libt::fingerprint(HALITE_FINGERPRINT)), 
     35        keepChecking_(false), 
     36        bittorrentIni(L"BitTorrent.xml"), 
     37        the_torrents_(bittorrentIni), 
     38        defTorrentMaxConn_(-1), 
     39        defTorrentMaxUpload_(-1), 
     40        defTorrentDownload_(-1), 
     41        defTorrentUpload_(-1), 
     42        ip_filter_on_(false), 
     43        ip_filter_loaded_(false), 
     44        ip_filter_changed_(false), 
     45        ip_filter_count_(0), 
     46        dht_on_(false) 
     47{ 
     48        torrent_internal::the_session_ = &session_; 
     49        torrent_internal::workingDir_ = workingDir(); 
     50         
     51        session_.set_severity_level(libt::alert::debug);                 
     52        session_.add_extension(&libt::create_metadata_plugin); 
     53        session_.add_extension(&libt::create_ut_pex_plugin); 
     54        session_.set_max_half_open_connections(10); 
     55         
     56        hal::event_log.post(shared_ptr<hal::EventDetail>( 
     57                new hal::EventMsg(L"Loading BitTorrent.xml.", hal::event_logger::info)));                
     58        bittorrentIni.load_data(); 
     59        hal::event_log.post(shared_ptr<hal::EventDetail>( 
     60                new hal::EventMsg(L"Loading torrent parameters.", hal::event_logger::info)));    
     61        the_torrents_.load_from_ini(); 
     62        hal::event_log.post(shared_ptr<hal::EventDetail>( 
     63                new hal::EventMsg(L"Loading done!", hal::event_logger::info))); 
     64         
     65        try 
     66        {                                                
     67        if (fs::exists(workingDirectory/L"Torrents.xml")) 
     68        { 
     69                { 
     70                fs::wifstream ifs(workingDirectory/L"Torrents.xml"); 
     71         
     72                event_log.post(shared_ptr<EventDetail>(new EventMsg(L"Loading old Torrents.xml"))); 
     73         
     74                TorrentMap torrents; 
     75                boost::archive::xml_wiarchive ia(ifs);   
     76                ia >> boost::serialization::make_nvp("torrents", torrents); 
     77                 
     78                the_torrents_ = torrents; 
     79                } 
     80                 
     81                event_log.post(shared_ptr<EventDetail>(new EventMsg( 
     82                        wformat(L"Total %1%.") % the_torrents_.size())));                                
     83                 
     84                fs::rename(workingDirectory/L"Torrents.xml", workingDirectory/L"Torrents.xml.safe.to.delete"); 
     85        }                        
     86        } 
     87        catch(const std::exception& e) 
     88        { 
     89                event_log.post(shared_ptr<EventDetail>( 
     90                        new EventStdException(event_logger::fatal, e, L"Loading Old Torrents.xml"))); 
     91        }                
     92                         
     93        if (exists(workingDirectory/L"DHTState.bin")) 
     94        { 
     95                try 
     96                { 
     97                        dht_state_ = haldecode(workingDirectory/L"DHTState.bin"); 
     98                }                
     99                catch(const std::exception& e) 
     100                { 
     101                        event_log.post(shared_ptr<EventDetail>( 
     102                                new EventStdException(event_logger::critical, e, L"Loading DHTState.bin"))); 
     103                } 
     104        } 
     105         
     106        {       libt::session_settings settings = session_.settings(); 
     107                settings.user_agent = string("Halite ") + HALITE_VERSION_STRING; 
     108                session_.set_settings(settings); 
     109        } 
     110         
     111        start_alert_handler(); 
     112} 
     113 
     114bit_impl::~bit_impl() 
     115{ 
     116        stop_alert_handler(); 
     117         
     118        //save_torrent_data(); 
     119         
     120        try 
     121        { 
     122         
     123        if (ip_filter_changed_) 
     124        {        
     125                fs::ofstream ofs(workingDirectory/L"IPFilter.bin", std::ios::binary); 
     126//                      boost::archive::binary_oarchive oba(ofs); 
     127                 
     128                libt::ip_filter::filter_tuple_t vectors = ip_filter_.export_filter();    
     129                 
     130                std::vector<libt::ip_range<asio::ip::address_v4> > v4(vectors.get<0>()); 
     131                std::vector<libt::ip_range<asio::ip::address_v6> > v6(vectors.get<1>()); 
     132                 
     133                v4.erase(std::remove(v4.begin(), v4.end(), 0), v4.end()); 
     134                v6.erase(std::remove(v6.begin(), v6.end(), 0), v6.end()); 
     135 
     136                write_vec_range(ofs, v4); 
     137//                      write_vec_range(ofs, v6); 
     138        }        
     139        } 
     140        catch(std::exception& e) 
     141        { 
     142                hal::event_log.post(boost::shared_ptr<hal::EventDetail>( 
     143                        new hal::EventStdException(event_logger::critical, e, L"~BitTorrent_impl")));  
     144        } 
     145} 
    29146 
    30147void bit_impl::ip_filter_count() 
     
    162279} 
    163280 
     281void bit_impl::start_alert_handler() 
     282{ 
     283        mutex_t::scoped_lock l(mutex_); 
     284 
     285        boost::function<void (void)> f = bind(&bit_impl::alert_handler, this); 
     286 
     287        keepChecking_ = true; 
     288        alert_checker_ = boost::in_place<boost::function<void (void)> >(bind(&bit_impl::alert_handler, this)); 
     289} 
     290         
    164291void bit_impl::stop_alert_handler() 
    165292{ 
     
    167294 
    168295        keepChecking_ = false; 
     296 
     297        if (alert_checker_) 
     298        { 
     299                alert_checker_->interrupt(); 
     300                alert_checker_ = boost::none; 
     301        } 
    169302} 
    170303         
    171304void bit_impl::alert_handler() 
    172305{ 
    173         mutex_t::scoped_lock l(mutex_); 
    174  
    175         if (keepChecking_) 
     306        while (keepChecking_) 
    176307        { 
    177308         
     
    442573                try 
    443574                { 
     575                mutex_t::scoped_lock l(mutex_); 
    444576                 
    445577                libt::handle_alert< 
     
    482614                 
    483615                p_alert = session_.pop_alert(); 
    484         } 
    485          
    486         timer_.expires_from_now(boost::posix_time::seconds(2)); 
    487         timer_.async_wait(bind(&bit_impl::alert_handler, this)); 
    488         } 
    489 } 
    490  
    491 } 
     616 
     617                boost::this_thread::sleep(boost::posix_time::seconds(5)); 
     618        }        
     619         
     620        } 
     621} 
     622 
     623} 
Note: See TracChangeset for help on using the changeset viewer.