source: trunk/src/halConfig.hpp @ 660

Revision 660, 10.9 KB checked in by Eoin, 11 years ago (diff)

FileDetail? struct converted to file_details along with other related naming changes.

Line 
1
2//         Copyright Eóin O'Callaghan 2006 - 2008.
3// Distributed under the Boost Software License, Version 1.0.
4//    (See accompanying file LICENSE_1_0.txt or copy at
5//          http://www.boost.org/LICENSE_1_0.txt)
6
7#pragma once
8
9class BitTorrentOptions;
10class SecurityOptions;
11class ProxyOptions;
12class TorrentsOptions;
13       
14namespace hal
15{
16
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       
251class Config :
252        public hal::IniBase<Config>,
253        private boost::noncopyable
254{
255public:
256        Config();
257       
258        friend class boost::serialization::access;
259        template<class Archive>
260        void serialize(Archive& ar, const unsigned int version)
261        {       
262                using boost::serialization::make_nvp;
263                switch (version)
264                {
265                case 6:
266                ar      & make_nvp("globals", globals_)
267                        & make_nvp("default_save_folder", default_save_folder_)
268                        & make_nvp("default_move_folder", default_move_folder_)
269                        & make_nvp("use_move_to", use_move_to_)
270                        & make_nvp("save_prompt", save_prompt_)
271                        & make_nvp("randomize_port", randomize_port_)                   
272                        & make_nvp("torrent_defaults", torrent_defaults_)
273                        & make_nvp("queue_settings", queue_settings_)
274                        & make_nvp("timeouts", timeouts_)
275                        & make_nvp("enable_dht", enable_dht_)
276                        & make_nvp("dht_settings", dht_settings_)
277                        & make_nvp("dht_settings/random_port", dht_random_port_)
278                        & make_nvp("dht_settings/upper_port", dht_upper_port_)
279                        & make_nvp("dht_radio", dht_radio_)
280                        & make_nvp("enable_pe", enable_pe_)
281                        & make_nvp("enable_ip_filter", enable_ip_filter_)
282                        & make_nvp("pe_settings", pe_settings_)
283                        & make_nvp("port_range", port_range_)
284                        & make_nvp("use_port_range", use_port_range_)
285                        & make_nvp("half_connections", half_connections_)
286                        & make_nvp("half_connections_limit", half_connections_limit_)
287                        & make_nvp("mapping_upnp", mapping_upnp_)
288                        & make_nvp("mapping_nat_pmp", mapping_nat_pmp_)
289                        & make_nvp("cache_settings", cache_settings_)
290                        & make_nvp("resolve_countries", resolve_countries_)
291                        & make_nvp("plugins/metadata", metadata_plugin_)
292                        & make_nvp("plugins/ut_metadata", ut_metadata_plugin_)
293                        & make_nvp("plugins/ut_pex", ut_pex_plugin_)
294                        & make_nvp("plugins/smart_ban", smart_ban_plugin_);
295                break;
296
297                case 4:
298                ar      & make_nvp("defaultMoveToFolder", default_move_folder_)
299                        & make_nvp("useMoveTo", use_move_to_);
300
301                case 3:
302                case 2:
303                ar      & make_nvp("halfConn", half_connections_)
304                        & make_nvp("halfConnLimit", half_connections_limit_);
305
306                case 1:
307                ar      & make_nvp("enablePe", enable_pe_)
308                        & make_nvp("peEncLevel", pe_settings_.encrypt_level)
309                        & make_nvp("pePerferRc4", pe_settings_.prefer_rc4)
310                        & make_nvp("peConInPolicy", pe_settings_.conn_in_policy)
311                        & make_nvp("peConOutPolicy", pe_settings_.conn_out_policy);
312
313                case 0:
314                ar      & make_nvp("maxConnections", globals_.total)
315                        & make_nvp("maxUploads", globals_.uploads)
316                        & make_nvp("downRate", globals_.download_rate)
317                        & make_nvp("upRate", globals_.upload_rate)
318                        & make_nvp("portFrom", port_range_.first)
319                        & make_nvp("portTo", port_range_.second);
320               
321                ar      & make_nvp("enableDHT", enable_dht_)
322                        & make_nvp("dhtMaxPeersReply", dht_settings_.max_peers_reply)
323                        & make_nvp("dhtSearchBranching", dht_settings_.search_branching)
324                        & make_nvp("dhtServicePort", dht_settings_.service_port)
325                        & make_nvp("dhtMaxFailCount", dht_settings_.max_fail_count);
326               
327                ar      & make_nvp("peerTimeout", timeouts_.peer_connect_timeout)
328                        & make_nvp("trackerTimeout", timeouts_.tracker_receive_timeout);
329
330                ar      & make_nvp("enableIPFilter", enable_ip_filter_)
331                        & make_nvp("portRange", use_port_range_)
332                        & make_nvp("torrentMaxConnections", torrent_defaults_.total)
333                        & make_nvp("torrentMaxUploads", torrent_defaults_.uploads)
334                        & make_nvp("torrentDownRate", torrent_defaults_.download_rate)
335                        & make_nvp("torrentUpRate", torrent_defaults_.upload_rate)
336                        & make_nvp("defaultSaveFolder", default_save_folder_)
337                        & make_nvp("savePrompt", save_prompt_);
338                }
339        }
340       
341        bool settingsChanged();
342       
343        friend class HaliteWindow;
344        friend class BitTorrentOptions;
345        friend class SecurityOptions;
346        friend class ProxyOptions;
347        friend class TorrentsOptions;
348        friend class GlobalOptions;
349        friend class PortOptions;
350
351private:
352        bool settingsThread();
353       
354        hal::connections globals_;
355
356        std::pair<int, int> port_range_;
357        bool use_port_range_;
358        bool randomize_port_;
359
360        hal::connections torrent_defaults_;
361
362        std::wstring default_save_folder_;
363        std::wstring default_move_folder_;
364        bool use_move_to_;
365        bool save_prompt_;
366       
367        bool enable_dht_;
368        hal::dht_settings dht_settings_;
369        bool dht_random_port_;
370        unsigned dht_upper_port_;
371        int dht_radio_;
372       
373        bool enable_ip_filter_;
374       
375        bool enableProxy;
376        std::wstring proxyHost;
377        int proxyPort;
378        std::wstring proxyUsername;
379        std::wstring proxyPassword;
380       
381    bool enable_pe_;
382        hal::pe_settings pe_settings_;
383       
384        bool half_connections_;
385        int half_connections_limit_;
386
387        bool mapping_upnp_;
388        bool mapping_nat_pmp_;
389
390        bool resolve_countries_;
391        bool metadata_plugin_;
392        bool ut_metadata_plugin_;
393        bool ut_pex_plugin_;
394        bool smart_ban_plugin_;
395
396        hal::cache_settings cache_settings_;
397
398        hal::queue_settings queue_settings_;
399        hal::timeouts timeouts_;
400};
401
402Config& config();
403
404} // namespace hal
405
406BOOST_CLASS_VERSION(hal::Config, 6)
Note: See TracBrowser for help on using the repository browser.