source: trunk/src/halEvent.hpp @ 565

Revision 565, 9.0 KB checked in by Eoin, 12 years ago (diff)

Win32 exception catchers backported to branch.

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
9#define HAL_EVENT_BEGIN                                 81000
10#define HAL_EVENT_EXP                   HAL_EVENT_BEGIN + 1
11#define HAL_EVENT_XML_EXP               HAL_EVENT_BEGIN + 2
12#define HAL_EVENT_UNICODE_EXP           HAL_EVENT_BEGIN + 3
13#define HAL_EVENT_DEBUG                 HAL_EVENT_BEGIN + 4
14#define HAL_EVENT_UNCLASSIFIED          HAL_EVENT_BEGIN + 5
15#define HAL_EVENT_PEER                  HAL_EVENT_BEGIN + 6
16#define HAL_EVENT_TRACKER               HAL_EVENT_BEGIN + 7
17#define HAL_EVENT_TORRENTEXP            HAL_EVENT_BEGIN + 8
18#define HAL_EVENT_INVTORRENT            HAL_EVENT_BEGIN + 9
19#define HAL_EVENT_DEV                   HAL_EVENT_BEGIN + 10
20
21#ifndef RC_INVOKED
22
23#include <string>
24#include <vector>
25
26#include <boost/date_time/posix_time/posix_time.hpp>
27#include <boost/smart_ptr.hpp>
28
29#include "global/wtl_app.hpp"
30#include "global/string_conv.hpp"
31
32#include <boost/preprocessor/cat.hpp>
33#include <boost/preprocessor/stringize.hpp>
34#include "win32_exception.hpp"
35
36#include "halTorrent.hpp"
37
38#ifdef TORRENT_LOGGING
39#       define HAL_DEV_MSG(msg) \
40        hal::event_log.post(boost::shared_ptr<hal::EventDetail>( \
41                        new hal::EventMsg(msg, hal::event_logger::dev)))
42#else
43#       define HAL_DEV_MSG(msg)
44#endif
45
46#define HAL_GENERIC_FN_EXCEPTION_CATCH(FUNCTION)
47catch (const access_violation& e) 
48{
49        hal::event_log.post(shared_ptr<hal::EventDetail>(
50                new hal::EventGeneral(hal::event_logger::warning, hal::event_logger::unclassified, 
51                (hal::wform(BOOST_PP_STRINGIZE(BOOST_PP_CAT(FUNCTION, L" access_violation (code %1$x) at %2$x. Bad address %3$x"))) % e.code() % (unsigned)e.where() % (unsigned)e.badAddress()).str())));
52}
53catch (const win32_exception& e) 
54{
55        hal::event_log.post(shared_ptr<hal::EventDetail>(
56                new hal::EventGeneral(hal::event_logger::warning, hal::event_logger::unclassified, 
57                (hal::wform(L"Alert handler win32_exception (code %1$x) at %2$x") % e.code() % (unsigned)e.where()).str())));
58}
59catch(std::exception& e)
60{
61        hal::event_log.post(shared_ptr<hal::EventDetail>(\
62                new hal::EventStdException(hal::event_logger::debug, e, L"SplashThread()")));
63}
64catch(...)
65{
66        HAL_DEV_MSG(L"SplashThread() catch all");
67}
68
69namespace hal
70{
71
72struct event_impl;
73
74class event_logger : private boost::noncopyable
75{       
76public: 
77        enum eventLevel { dev, xml_dev, debug, info, warning, critical, fatal, none };
78       
79        enum codes {
80                noEvent = 0,
81                unclassified = HAL_EVENT_UNCLASSIFIED,
82                debugEvent = HAL_EVENT_DEBUG,
83                devEvent = HAL_EVENT_DEV,
84                invalidTorrent = HAL_EVENT_INVTORRENT,
85                torrentException = HAL_EVENT_TORRENTEXP,
86                generalException = HAL_EVENT_EXP,
87                xmlException = HAL_EVENT_XML_EXP,
88                unicodeException = HAL_EVENT_UNICODE_EXP,
89                peer = HAL_EVENT_PEER,
90                tracker = HAL_EVENT_TRACKER,
91                infoCode
92        };
93       
94        event_logger();
95        ~event_logger();
96
97        void init();
98
99        bool is_active() { return pimpl_; }
100
101        boost::signals::connection attach(boost::function<void (boost::shared_ptr<EventDetail>)> fn);
102        void dettach(const boost::signals::connection& c);
103
104        void post(boost::shared_ptr<EventDetail> e);
105       
106        static std::wstring eventLevelToStr(eventLevel);
107
108private:
109        boost::shared_ptr<event_impl> pimpl_;
110};
111
112#ifndef HAL_EVENT_IMPL_UNIT
113static event_logger event_log;
114#endif
115
116class EventDetail
117{
118public:
119        EventDetail(event_logger::eventLevel l, boost::posix_time::ptime t, event_logger::codes c) :
120                level_(l),
121                timeStamp_(t),
122                code_(c)
123        {}
124        virtual ~EventDetail() 
125        {}
126       
127        virtual std::wstring msg()
128        {
129                return (wform(L"Code %1%") % code()).str();
130        }
131
132        event_logger::eventLevel level() { return level_; }
133        boost::posix_time::ptime timeStamp() { return timeStamp_; }
134        event_logger::codes code() { return code_; }
135       
136private:       
137        event_logger::eventLevel level_;
138        boost::posix_time::ptime timeStamp_;
139        event_logger::codes code_;
140};
141
142class EventLibtorrent : public EventDetail
143{
144public:
145        EventLibtorrent(event_logger::eventLevel l, boost::posix_time::ptime t, event_logger::codes c, std::wstring m) :
146                EventDetail(l, t, c),
147                msg_(m)
148        {}
149       
150        virtual std::wstring msg()
151        {
152                return (wform(hal::app().res_wstr(code())) % msg_).str();
153        }
154       
155private:
156        std::wstring msg_;
157};
158
159class EventGeneral : public EventDetail
160{
161public:
162        EventGeneral(event_logger::eventLevel l, event_logger::codes c, std::wstring m) :
163                EventDetail(l, boost::posix_time::second_clock::universal_time(), c),
164                msg_(m)
165        {}
166       
167        EventGeneral(event_logger::eventLevel l, boost::posix_time::ptime t, std::wstring m) :
168                EventDetail(l, t, event_logger::noEvent),
169                msg_(m)
170        {}
171       
172        template<typename str_t>
173        EventGeneral(event_logger::eventLevel l, str_t m) :
174                EventDetail(l, boost::posix_time::second_clock::universal_time(), event_logger::noEvent),
175                msg_(hal::to_wstr_shim(m))
176        {}
177       
178        template<typename str_t>       
179        EventGeneral(event_logger::eventLevel l, boost::posix_time::ptime t, str_t m) :
180                EventDetail(l, t, event_logger::noEvent),
181                msg_(hal::to_wstr_shim(m))
182        {}
183       
184        virtual std::wstring msg()
185        {
186                if (event_logger::noEvent != code())
187                        return (wform(hal::app().res_wstr(code())) % msg_).str();
188                else
189                        return msg_;
190        }
191       
192private:
193        std::wstring msg_;
194};
195
196class EventMsg : public EventDetail
197{
198public:
199        template<typename str_t>
200        EventMsg(str_t m, event_logger::eventLevel l=event_logger::debug, 
201                boost::posix_time::ptime t=boost::posix_time::second_clock::universal_time(), event_logger::codes c=event_logger::noEvent) :
202                EventDetail(l, t, c),
203                msg_(hal::to_wstr_shim(m))
204        {}
205       
206        virtual std::wstring msg()
207        {
208                if (event_logger::noEvent != code())
209                        return (wform(hal::app().res_wstr(code())) % msg_).str();
210                else
211                        return msg_;
212        }
213       
214private:
215        std::wstring msg_;
216};
217
218class EventPeerAlert : public EventDetail
219{
220public:
221        EventPeerAlert(event_logger::eventLevel l, boost::posix_time::ptime t, std::wstring m) :
222                EventDetail(l, t, event_logger::peer),
223                msg_(m)
224        {}
225       
226        virtual std::wstring msg()
227        {
228                return (wform(hal::app().res_wstr(code())) % msg_).str();
229        }
230       
231private:
232        std::wstring msg_;
233};
234
235class EventXmlException : public EventDetail
236{
237public:
238        EventXmlException(std::wstring e, std::wstring m) :
239                EventDetail(event_logger::warning, boost::posix_time::second_clock::universal_time(), event_logger::xmlException),
240                exp_(e),
241                msg_(m)
242        {}
243       
244        virtual std::wstring msg()
245        {
246                return (wform(hal::app().res_wstr(HAL_EVENT_XML_EXP)) % exp_ % msg_).str();
247        }
248       
249private:
250        std::wstring exp_;
251        std::wstring msg_;
252};
253
254class EventInvalidTorrent : public EventDetail
255{
256public:
257        template<typename t_str, typename f_str>
258        EventInvalidTorrent(event_logger::eventLevel l, event_logger::codes code, t_str t, f_str f) :
259                EventDetail(l, boost::posix_time::second_clock::universal_time(), code),
260                torrent_(hal::to_wstr_shim(t)),
261                function_(hal::to_wstr_shim(f))
262        {}
263       
264        virtual std::wstring msg()
265        {
266                return (wform(hal::app().res_wstr(code())) % torrent_ % function_).str();
267        }
268       
269private:
270        std::wstring function_;
271        std::wstring torrent_;
272        std::wstring exception_;
273};
274
275class EventTorrentException : public EventDetail
276{
277public:
278        template<typename e_str, typename t_str, typename f_str>
279        EventTorrentException(event_logger::eventLevel l, event_logger::codes code, e_str e, t_str t, f_str f) :
280                EventDetail(l, boost::posix_time::second_clock::universal_time(), code),
281                torrent_(hal::to_wstr_shim(t)),
282                function_(hal::to_wstr_shim(f)),
283                exception_(hal::to_wstr_shim(e))
284        {}
285       
286        virtual std::wstring msg()
287        {
288                return (wform(hal::app().res_wstr(code())) % torrent_ % exception_ % function_).str();
289        }
290       
291private:
292        std::wstring torrent_;
293        std::wstring function_;
294        std::wstring exception_;
295};
296
297class EventStdException : public EventDetail
298{
299public:
300        EventStdException(event_logger::eventLevel l, const std::exception& e, std::wstring from) :
301                EventDetail(l, boost::posix_time::second_clock::universal_time(), event_logger::generalException),
302                exception_(hal::from_utf8(e.what())),
303                from_(from)
304        {}
305       
306        virtual std::wstring msg()
307        {
308                return (wform(hal::app().res_wstr(code())) % exception_ % from_).str();
309        }
310       
311private:
312        std::wstring exception_;
313        std::wstring from_;
314};
315
316class EventDebug : public EventDetail
317{
318public:
319        EventDebug(event_logger::eventLevel l, std::wstring msg) :
320                EventDetail(l, boost::posix_time::second_clock::universal_time(), event_logger::debugEvent),
321                msg_(msg)
322        {}
323       
324        virtual std::wstring msg()
325        {
326                return (wform(hal::app().res_wstr(code())) % msg_).str();
327        }
328       
329private:
330        std::wstring msg_;
331};
332
333class EventInfo : public EventDetail
334{
335public:
336        template<typename T>
337        EventInfo(T msg) :
338                EventDetail(event_logger::info, boost::posix_time::second_clock::universal_time(), event_logger::infoCode),
339                msg_(to_wstr_shim(msg))
340        {}
341       
342        virtual std::wstring msg() { return msg_; }
343       
344private:
345        std::wstring msg_;
346};
347
348class EventSession : public EventDetail
349{
350
351};
352
353}// namespace hal
354
355#endif
Note: See TracBrowser for help on using the repository browser.