1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
|
/*
** $Id$
**
** Copyright 2002 Addison Wesley. All Rights Reserved.
*/
#include "ace/config-all.h"
#if defined (ACE_WIN32)
#include "ace/Reactor.h"
#include "ace/WFMO_Reactor.h"
#include "ace/Thread_Manager.h"
#include "ace/OS_NS_string.h"
#include "Reactor_Logging_Server_T.h"
#include "Logging_Acceptor_Ex.h"
#include "Logging_Event_Handler_Ex.h"
class Quit_Handler : public ACE_Event_Handler {
private:
ACE_Manual_Event quit_seen_;
public:
Quit_Handler (ACE_Reactor *r) : ACE_Event_Handler (r) {
SetConsoleMode (ACE_STDIN, ENABLE_LINE_INPUT
| ENABLE_ECHO_INPUT
| ENABLE_PROCESSED_INPUT);
if (reactor ()->register_handler
(this, quit_seen_.handle ()) == -1
|| ACE_Event_Handler::register_stdin_handler
(this, r, ACE_Thread_Manager::instance ()) == -1)
r->end_reactor_event_loop ();
}
~Quit_Handler () {
ACE_Event_Handler::remove_stdin_handler
(reactor (), ACE_Thread_Manager::instance ());
reactor ()->remove_handler (quit_seen_.handle (),
ACE_Event_Handler::DONT_CALL);
}
virtual int handle_input (ACE_HANDLE h) {
CHAR user_input[BUFSIZ];
DWORD count;
if (!ReadFile (h, user_input, BUFSIZ, &count, 0))
return -1;
user_input[count] = '\0';
if (ACE_OS::strncmp (user_input, "quit", 4) == 0)
return -1;
return 0;
}
virtual int handle_close (ACE_HANDLE, ACE_Reactor_Mask) {
quit_seen_.signal ();
return 0;
}
virtual int handle_signal (int, siginfo_t *, ucontext_t *) {
reactor ()->end_reactor_event_loop ();
return 0;
}
};
class Logging_Event_Handler_WFMO : public Logging_Event_Handler_Ex
{
public:
Logging_Event_Handler_WFMO (ACE_Reactor *r)
: Logging_Event_Handler_Ex (r) {}
protected:
int handle_input (ACE_HANDLE) {
ACE_GUARD_RETURN (ACE_SYNCH_MUTEX, monitor, lock_, -1);
return logging_handler_.log_record ();
}
ACE_Thread_Mutex lock_; // Serialize threads in thread pool.
};
class Logging_Acceptor_WFMO : public Logging_Acceptor_Ex
{
public:
// Simple constructor to pass ACE_Reactor to base class.
Logging_Acceptor_WFMO (ACE_Reactor *r = ACE_Reactor::instance ())
: Logging_Acceptor_Ex (r) {};
protected:
virtual int handle_input (ACE_HANDLE) {
Logging_Event_Handler_WFMO *peer_handler = 0;
ACE_NEW_RETURN (peer_handler,
Logging_Event_Handler_WFMO (reactor ()),
-1);
if (acceptor_.accept (peer_handler->peer ()) == -1) {
delete peer_handler;
return -1;
} else if (peer_handler->open () == -1) {
peer_handler->handle_close ();
return -1;
}
return 0;
}
};
static ACE_THR_FUNC_RETURN event_loop (void *arg) {
ACE_Reactor *reactor = static_cast<ACE_Reactor *> (arg);
reactor->owner (ACE_OS::thr_self ());
reactor->run_reactor_event_loop ();
return 0;
}
typedef Reactor_Logging_Server<Logging_Acceptor_WFMO>
Server_Logging_Daemon;
int ACE_TMAIN (int argc, ACE_TCHAR *argv[])
{
const size_t N_THREADS = 4;
ACE_WFMO_Reactor wfmo_reactor;
ACE_Reactor reactor (&wfmo_reactor);
Server_Logging_Daemon *server;
// Ignore argv[0]...
--argc; ++argv;
ACE_NEW_RETURN (server,
Server_Logging_Daemon (argc, argv, &reactor),
1);
Quit_Handler quit_handler (&reactor);
ACE_Thread_Manager::instance ()->spawn_n
(N_THREADS, event_loop, &reactor);
return ACE_Thread_Manager::instance ()->wait ();
}
#else /* !ACE_WIN32 */
int ACE_TMAIN (int, ACE_TCHAR *[])
{
return 0;
}
#endif /* ACE_WIN32 */
|
