Changeset 678


Ignore:
Timestamp:
01/02/09 21:52:04 (10 years ago)
Author:
Eoin
Message:
 
Location:
branch_service
Files:
6 edited

Legend:

Unmodified
Added
Removed
  • branch_service/sln/halTorrent/halConfig.cpp

    r674 r678  
    1010#include "Halite.hpp" 
    1111 
     12#include "global/string_conv.hpp" 
     13#include "global/wtl_app.hpp" 
     14 
     15#include "halIni.hpp" 
    1216#include "halConfig.hpp" 
    13 #include "ProgressDialog.hpp" 
    1417 
    1518namespace hal 
    1619{ 
     20 
     21Config::Config() : 
     22        hal::IniBase<Config>("globals/bittorrent", "Config"), 
     23        globals_(), 
     24        torrent_defaults_(), 
     25        port_range_(6881,6881), 
     26        use_port_range_(false), 
     27        randomize_port_(false), 
     28        enable_dht_(true), 
     29        dht_settings_(), 
     30        dht_random_port_(0), 
     31        dht_upper_port_(0), 
     32        dht_radio_(1), 
     33        enable_ip_filter_(false), 
     34        enableProxy(false), 
     35        proxyPort(0), 
     36        default_save_folder_((hal::app().exe_path().parent_path()/L"incoming").string()), 
     37        default_move_folder_((hal::app().exe_path().parent_path()/L"completed").string()), 
     38        use_move_to_(false), 
     39        save_prompt_(true), 
     40        enable_pe_(false), 
     41        pe_settings_(), 
     42        half_connections_(true), 
     43        half_connections_limit_(10), 
     44        mapping_upnp_(false), 
     45        mapping_nat_pmp_(false), 
     46        resolve_countries_(false), 
     47        metadata_plugin_(false), 
     48        ut_metadata_plugin_(false), 
     49        ut_pex_plugin_(false), 
     50        smart_ban_plugin_(false) 
     51{ 
     52        queue_settings_ = hal::bittorrent().get_queue_settings(); 
     53        timeouts_ = hal::bittorrent().get_timeouts(); 
     54} 
    1755 
    1856bool Config::settingsChanged() 
     
    84122        if (enable_ip_filter_) 
    85123        { 
    86                 ProgressDialog progDlg(L"Loading IP filters...", bind( 
    87                         &bit::ensure_ip_filter_on, &bittorrent(), _1)); 
    88                 progDlg.DoModal(); 
     124//              ProgressDialog progDlg(L"Loading IP filters...", bind( 
     125//                      &bit::ensure_ip_filter_on, &bittorrent(), _1)); 
     126//              progDlg.DoModal(); 
    89127        } 
    90128        else 
  • branch_service/sln/halTorrent/halConfig.hpp

    r674 r678  
    77#pragma once 
    88 
    9 #include "global/string_conv.hpp" 
    10 #include "global/wtl_app.hpp" 
    11  
    12 #include "halIni.hpp" 
    13  
    149class BitTorrentOptions; 
    1510class SecurityOptions; 
     
    2015{ 
    2116 
     17struct queue_settings 
     18{ 
     19        friend class boost::serialization::access; 
     20        template<class Archive> 
     21        void serialize(Archive& ar, const unsigned int version) 
     22        {        
     23                ar & BOOST_SERIALIZATION_NVP(auto_manage_interval); 
     24                ar & BOOST_SERIALIZATION_NVP(active_downloads); 
     25                ar & BOOST_SERIALIZATION_NVP(active_seeds); 
     26                ar & BOOST_SERIALIZATION_NVP(seeds_hard_limit); 
     27                ar & BOOST_SERIALIZATION_NVP(seed_ratio_limit); 
     28                ar & BOOST_SERIALIZATION_NVP(seed_ratio_time_limit); 
     29                ar & BOOST_SERIALIZATION_NVP(seed_time_limit); 
     30                ar & BOOST_SERIALIZATION_NVP(dont_count_slow_torrents); 
     31                ar & BOOST_SERIALIZATION_NVP(auto_scrape_min_interval); 
     32                ar & BOOST_SERIALIZATION_NVP(auto_scrape_interval); 
     33                ar & BOOST_SERIALIZATION_NVP(close_redundant_connections); 
     34        } 
     35 
     36        bool operator==(const queue_settings& s) const 
     37        { 
     38                return (auto_manage_interval == s.auto_manage_interval && 
     39                        active_downloads == s.active_downloads && 
     40                        active_seeds == s.active_seeds && 
     41                        seeds_hard_limit == s.seeds_hard_limit && 
     42                        seed_ratio_limit == s.seed_ratio_limit && 
     43                        seed_ratio_time_limit == s.seed_ratio_time_limit && 
     44                        seed_time_limit == s.seed_time_limit && 
     45                        dont_count_slow_torrents == s.dont_count_slow_torrents && 
     46                        auto_scrape_min_interval == s.auto_scrape_min_interval && 
     47                        auto_scrape_interval == s.auto_scrape_interval && 
     48                        close_redundant_connections == s.close_redundant_connections); 
     49        } 
     50         
     51        bool operator!=(const queue_settings& s) const 
     52        { 
     53                return !(*this == s); 
     54        } 
     55 
     56        int auto_manage_interval; 
     57 
     58        int active_downloads; 
     59        int active_seeds; 
     60        int seeds_hard_limit; 
     61        float seed_ratio_limit; 
     62        float seed_ratio_time_limit; 
     63        int seed_time_limit; 
     64        bool dont_count_slow_torrents; 
     65 
     66        int auto_scrape_min_interval; 
     67        int auto_scrape_interval; 
     68        bool close_redundant_connections; 
     69}; 
     70 
     71struct timeouts 
     72{ 
     73        friend class boost::serialization::access; 
     74        template<class Archive> 
     75        void serialize(Archive& ar, const unsigned int version) 
     76        {        
     77                ar & BOOST_SERIALIZATION_NVP(tracker_completion_timeout); 
     78                ar & BOOST_SERIALIZATION_NVP(tracker_receive_timeout); 
     79                ar & BOOST_SERIALIZATION_NVP(stop_tracker_timeout); 
     80 
     81                ar & BOOST_SERIALIZATION_NVP(request_queue_time); 
     82                ar & BOOST_SERIALIZATION_NVP(piece_timeout); 
     83                ar & BOOST_SERIALIZATION_NVP(min_reconnect_time); 
     84 
     85                ar & BOOST_SERIALIZATION_NVP(peer_timeout); 
     86                ar & BOOST_SERIALIZATION_NVP(urlseed_timeout); 
     87                ar & BOOST_SERIALIZATION_NVP(peer_connect_timeout); 
     88                ar & BOOST_SERIALIZATION_NVP(inactivity_timeout); 
     89                ar & BOOST_SERIALIZATION_NVP(handshake_timeout); 
     90        } 
     91 
     92        int tracker_completion_timeout; 
     93        int tracker_receive_timeout; 
     94        int stop_tracker_timeout; 
     95 
     96        float request_queue_time; 
     97        int piece_timeout; 
     98        int min_reconnect_time; 
     99 
     100        int peer_timeout; 
     101        int urlseed_timeout; 
     102        int peer_connect_timeout; 
     103        int inactivity_timeout; 
     104        int handshake_timeout; 
     105}; 
     106 
     107struct dht_settings 
     108{ 
     109        dht_settings() : 
     110                max_peers_reply(50), 
     111                search_branching(5), 
     112                service_port(6881), 
     113                max_fail_count(20) 
     114        {} 
     115 
     116        friend class boost::serialization::access; 
     117        template<class Archive> 
     118        void serialize(Archive& ar, const unsigned int version) 
     119        {        
     120                ar & BOOST_SERIALIZATION_NVP(max_peers_reply); 
     121                ar & BOOST_SERIALIZATION_NVP(search_branching); 
     122                ar & BOOST_SERIALIZATION_NVP(service_port); 
     123                ar & BOOST_SERIALIZATION_NVP(max_fail_count); 
     124        } 
     125 
     126        int max_peers_reply; 
     127        int search_branching; 
     128        int service_port; 
     129        int max_fail_count; 
     130}; 
     131 
     132struct cache_settings 
     133{ 
     134        cache_settings() : 
     135                cache_size(512), 
     136                cache_expiry(60) 
     137        {} 
     138 
     139        friend class boost::serialization::access; 
     140        template<class Archive> 
     141        void serialize(Archive& ar, const unsigned int version) 
     142        {        
     143                ar & BOOST_SERIALIZATION_NVP(cache_size); 
     144                ar & BOOST_SERIALIZATION_NVP(cache_expiry); 
     145        } 
     146 
     147        int cache_size; 
     148        int cache_expiry; 
     149}; 
     150 
     151struct pe_settings 
     152{ 
     153        pe_settings() : 
     154                encrypt_level(0), 
     155                prefer_rc4(false), 
     156                conn_in_policy(1), 
     157                conn_out_policy(1) 
     158        {} 
     159 
     160        friend class boost::serialization::access; 
     161        template<class Archive> 
     162        void serialize(Archive& ar, const unsigned int version) 
     163        {        
     164                ar & BOOST_SERIALIZATION_NVP(encrypt_level); 
     165                ar & BOOST_SERIALIZATION_NVP(prefer_rc4); 
     166                ar & BOOST_SERIALIZATION_NVP(conn_in_policy); 
     167                ar & BOOST_SERIALIZATION_NVP(conn_out_policy); 
     168        } 
     169 
     170    int encrypt_level; 
     171    bool prefer_rc4; 
     172    int conn_in_policy; 
     173    int conn_out_policy; 
     174}; 
     175 
     176struct connections 
     177{ 
     178        connections() : 
     179                total(50), 
     180                uploads(10), 
     181                download_rate(-1), 
     182                upload_rate(-1) 
     183        {} 
     184 
     185        friend class boost::serialization::access; 
     186        template<class Archive> 
     187        void serialize(Archive& ar, const unsigned int version) 
     188        {        
     189                ar & BOOST_SERIALIZATION_NVP(total); 
     190                ar & BOOST_SERIALIZATION_NVP(uploads); 
     191                ar & BOOST_SERIALIZATION_NVP(download_rate); 
     192                ar & BOOST_SERIALIZATION_NVP(upload_rate); 
     193        } 
     194 
     195    int total; 
     196    int uploads; 
     197    float download_rate; 
     198    float upload_rate; 
     199}; 
     200 
     201struct cache_details 
     202{ 
     203        cache_details() : 
     204                blocks_written(-1), 
     205                writes(-1), 
     206                blocks_read(-1), 
     207                blocks_read_hit(-1), 
     208                reads(-1), 
     209                cache_size(-1), 
     210                read_cache_size(-1), 
     211                write_ratio(-1), 
     212                read_ratio(-1), 
     213                write_cache_size(-1) 
     214        {} 
     215 
     216        cache_details(size_type b_w, 
     217                        size_type w, 
     218                        size_type b_r, 
     219                        size_type b_r_h, 
     220                        size_type r, 
     221                        int c_s, 
     222                        int r_c_s) : 
     223                blocks_written(b_w), 
     224                writes(w), 
     225                blocks_read(b_r), 
     226                blocks_read_hit(b_r_h), 
     227                reads(r), 
     228                cache_size(c_s), 
     229                read_cache_size(r_c_s), 
     230                write_cache_size(cache_size-read_cache_size) 
     231        { 
     232                write_ratio = (blocks_written == 0) ? 0 : 
     233                        static_cast<double>(blocks_written-writes) / blocks_written; 
     234 
     235                read_ratio = (blocks_read == 0) ? 0 : 
     236                        static_cast<double>(blocks_read_hit) / blocks_read;} 
     237 
     238    size_type blocks_written; 
     239    size_type writes; 
     240    size_type blocks_read; 
     241    size_type blocks_read_hit; 
     242    size_type reads; 
     243    int cache_size; 
     244    int read_cache_size; 
     245 
     246        double write_ratio; 
     247        double read_ratio; 
     248        int write_cache_size; 
     249}; 
     250         
    22251class Config : 
    23252        public hal::IniBase<Config>, 
     
    25254{ 
    26255public: 
    27         Config() : 
    28                 hal::IniBase<Config>("globals/bittorrent", "Config"), 
    29                 globals_(), 
    30                 torrent_defaults_(), 
    31                 port_range_(6881,6881), 
    32                 use_port_range_(false), 
    33                 randomize_port_(false), 
    34                 enable_dht_(true), 
    35                 dht_settings_(), 
    36                 dht_random_port_(0), 
    37                 dht_upper_port_(0), 
    38                 dht_radio_(1), 
    39                 enable_ip_filter_(false), 
    40                 enableProxy(false), 
    41                 proxyPort(0), 
    42                 default_save_folder_((hal::app().exe_path().parent_path()/L"incoming").string()), 
    43                 default_move_folder_((hal::app().exe_path().parent_path()/L"completed").string()), 
    44                 use_move_to_(false), 
    45                 save_prompt_(true), 
    46                 enable_pe_(false), 
    47                 pe_settings_(), 
    48                 half_connections_(true), 
    49                 half_connections_limit_(10), 
    50                 mapping_upnp_(false), 
    51                 mapping_nat_pmp_(false), 
    52                 resolve_countries_(false), 
    53                 metadata_plugin_(false), 
    54                 ut_metadata_plugin_(false), 
    55                 ut_pex_plugin_(false), 
    56                 smart_ban_plugin_(false) 
    57         { 
    58                 queue_settings_ = hal::bittorrent().get_queue_settings(); 
    59                 timeouts_ = hal::bittorrent().get_timeouts(); 
    60         } 
     256        Config(); 
    61257         
    62258        friend class boost::serialization::access; 
  • branch_service/sln/halTorrent/halEvent.hpp

    r674 r678  
    4242#else 
    4343#       define HAL_DEV_MSG(msg) 
     44#endif 
     45 
     46#ifdef HAL_SORT_LOGGING 
     47#       define HAL_DEV_SORT_MSG(msg) \ 
     48        hal::event_log.post(boost::shared_ptr<hal::EventDetail>( \ 
     49                        new hal::EventMsg(msg, hal::event_logger::dev)))  
     50#else 
     51#       define HAL_DEV_SORT_MSG(msg) 
    4452#endif 
    4553 
     
    8593                debugEvent = HAL_EVENT_DEBUG, 
    8694                devEvent = HAL_EVENT_DEV, 
    87                 invalidTorrent = HAL_EVENT_INVTORRENT, 
     95                invalid_torrent = HAL_EVENT_INVTORRENT, 
    8896                torrentException = HAL_EVENT_TORRENTEXP, 
    8997                generalException = HAL_EVENT_EXP, 
  • branch_service/sln/halTorrent/halTorrent.vcproj

    r674 r678  
    286286                        > 
    287287                        <File 
     288                                RelativePath=".\halConfig.cpp" 
     289                                > 
     290                                <FileConfiguration 
     291                                        Name="Debug|Win32" 
     292                                        > 
     293                                        <Tool 
     294                                                Name="VCCLCompilerTool" 
     295                                                PrecompiledHeaderThrough="stdAfx.hpp" 
     296                                        /> 
     297                                </FileConfiguration> 
     298                                <FileConfiguration 
     299                                        Name="Debug|x64" 
     300                                        > 
     301                                        <Tool 
     302                                                Name="VCCLCompilerTool" 
     303                                                PrecompiledHeaderThrough="stdAfx.hpp" 
     304                                        /> 
     305                                </FileConfiguration> 
     306                                <FileConfiguration 
     307                                        Name="Release|Win32" 
     308                                        > 
     309                                        <Tool 
     310                                                Name="VCCLCompilerTool" 
     311                                                PrecompiledHeaderThrough="stdAfx.hpp" 
     312                                        /> 
     313                                </FileConfiguration> 
     314                                <FileConfiguration 
     315                                        Name="Release|x64" 
     316                                        > 
     317                                        <Tool 
     318                                                Name="VCCLCompilerTool" 
     319                                                PrecompiledHeaderThrough="stdAfx.hpp" 
     320                                        /> 
     321                                </FileConfiguration> 
     322                        </File> 
     323                        <File 
    288324                                RelativePath=".\halPeers.cpp" 
    289325                                > 
     
    293329                                        <Tool 
    294330                                                Name="VCCLCompilerTool" 
    295                                                 PrecompiledHeaderThrough="StdAfx.hpp" 
     331                                                PrecompiledHeaderThrough="stdAfx.hpp" 
    296332                                        /> 
    297333                                </FileConfiguration> 
     
    301337                                        <Tool 
    302338                                                Name="VCCLCompilerTool" 
    303                                                 PrecompiledHeaderThrough="StdAfx.hpp" 
     339                                                PrecompiledHeaderThrough="stdAfx.hpp" 
    304340                                        /> 
    305341                                </FileConfiguration> 
     
    309345                                        <Tool 
    310346                                                Name="VCCLCompilerTool" 
    311                                                 PrecompiledHeaderThrough="StdAfx.hpp" 
     347                                                PrecompiledHeaderThrough="stdAfx.hpp" 
    312348                                        /> 
    313349                                </FileConfiguration> 
     
    317353                                        <Tool 
    318354                                                Name="VCCLCompilerTool" 
    319                                                 PrecompiledHeaderThrough="StdAfx.hpp" 
     355                                                PrecompiledHeaderThrough="stdAfx.hpp" 
    320356                                        /> 
    321357                                </FileConfiguration> 
     
    329365                                        <Tool 
    330366                                                Name="VCCLCompilerTool" 
    331                                                 PrecompiledHeaderThrough="StdAfx.hpp" 
     367                                                PrecompiledHeaderThrough="stdAfx.hpp" 
    332368                                        /> 
    333369                                </FileConfiguration> 
     
    337373                                        <Tool 
    338374                                                Name="VCCLCompilerTool" 
    339                                                 PrecompiledHeaderThrough="StdAfx.hpp" 
     375                                                PrecompiledHeaderThrough="stdAfx.hpp" 
    340376                                        /> 
    341377                                </FileConfiguration> 
     
    345381                                        <Tool 
    346382                                                Name="VCCLCompilerTool" 
    347                                                 PrecompiledHeaderThrough="StdAfx.hpp" 
     383                                                PrecompiledHeaderThrough="stdAfx.hpp" 
    348384                                        /> 
    349385                                </FileConfiguration> 
     
    353389                                        <Tool 
    354390                                                Name="VCCLCompilerTool" 
    355                                                 PrecompiledHeaderThrough="StdAfx.hpp" 
     391                                                PrecompiledHeaderThrough="stdAfx.hpp" 
    356392                                        /> 
    357393                                </FileConfiguration> 
     
    365401                                        <Tool 
    366402                                                Name="VCCLCompilerTool" 
    367                                                 PrecompiledHeaderThrough="StdAfx.hpp" 
     403                                                PrecompiledHeaderThrough="stdAfx.hpp" 
    368404                                        /> 
    369405                                </FileConfiguration> 
     
    373409                                        <Tool 
    374410                                                Name="VCCLCompilerTool" 
    375                                                 PrecompiledHeaderThrough="StdAfx.hpp" 
     411                                                PrecompiledHeaderThrough="stdAfx.hpp" 
    376412                                        /> 
    377413                                </FileConfiguration> 
     
    381417                                        <Tool 
    382418                                                Name="VCCLCompilerTool" 
    383                                                 PrecompiledHeaderThrough="StdAfx.hpp" 
     419                                                PrecompiledHeaderThrough="stdAfx.hpp" 
    384420                                        /> 
    385421                                </FileConfiguration> 
     
    389425                                        <Tool 
    390426                                                Name="VCCLCompilerTool" 
    391                                                 PrecompiledHeaderThrough="StdAfx.hpp" 
     427                                                PrecompiledHeaderThrough="stdAfx.hpp" 
    392428                                        /> 
    393429                                </FileConfiguration> 
     
    401437                                        <Tool 
    402438                                                Name="VCCLCompilerTool" 
    403                                                 PrecompiledHeaderThrough="StdAfx.hpp" 
     439                                                PrecompiledHeaderThrough="stdAfx.hpp" 
    404440                                        /> 
    405441                                </FileConfiguration> 
     
    409445                                        <Tool 
    410446                                                Name="VCCLCompilerTool" 
    411                                                 PrecompiledHeaderThrough="StdAfx.hpp" 
     447                                                PrecompiledHeaderThrough="stdAfx.hpp" 
    412448                                        /> 
    413449                                </FileConfiguration> 
     
    417453                                        <Tool 
    418454                                                Name="VCCLCompilerTool" 
    419                                                 PrecompiledHeaderThrough="StdAfx.hpp" 
     455                                                PrecompiledHeaderThrough="stdAfx.hpp" 
    420456                                        /> 
    421457                                </FileConfiguration> 
     
    425461                                        <Tool 
    426462                                                Name="VCCLCompilerTool" 
    427                                                 PrecompiledHeaderThrough="StdAfx.hpp" 
     463                                                PrecompiledHeaderThrough="stdAfx.hpp" 
    428464                                        /> 
    429465                                </FileConfiguration> 
     
    476512                        > 
    477513                        <File 
     514                                RelativePath=".\halConfig.hpp" 
     515                                > 
     516                        </File> 
     517                        <File 
     518                                RelativePath=".\halIni.hpp" 
     519                                > 
     520                        </File> 
     521                        <File 
    478522                                RelativePath=".\halPeers.hpp" 
    479523                                > 
  • branch_service/src/Halite.hpp

    r557 r678  
    1919using boost::filesystem::wpath; 
    2020using boost::noncopyable; 
    21  
    22 template<class Archive> 
    23 void serialize(Archive& ar, WTL::CRect& rect, const unsigned int version) 
    24 { 
    25         ar & BOOST_SERIALIZATION_NVP(rect.top); 
    26         ar & BOOST_SERIALIZATION_NVP(rect.bottom); 
    27         ar & BOOST_SERIALIZATION_NVP(rect.left); 
    28         ar & BOOST_SERIALIZATION_NVP(rect.right); 
    29 } 
    3021 
    3122namespace hal 
  • branch_service/src/stdAfx.hpp

    r647 r678  
    114114#pragma warning (pop) 
    115115 
     116template<class Archive> 
     117void serialize(Archive& ar, WTL::CRect& rect, const unsigned int version) 
     118{ 
     119        ar & BOOST_SERIALIZATION_NVP(rect.top); 
     120        ar & BOOST_SERIALIZATION_NVP(rect.bottom); 
     121        ar & BOOST_SERIALIZATION_NVP(rect.left); 
     122        ar & BOOST_SERIALIZATION_NVP(rect.right); 
     123} 
     124 
    116125#include <boost/date_time/posix_time/time_serialize.hpp> 
Note: See TracChangeset for help on using the changeset viewer.