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
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
|
/* -*- C++ -*- */
// $Id$
// ============================================================================
//
// = LIBRARY
// ace
//
// = FILENAME
// CORBA_Handler.h
//
// = AUTHOR
// Douglas C. Schmidt (schmidt@cs.wustl.edu) and
// Irfan Pyarali (irfan@wuerl.wustl.edu).
//
// ============================================================================
#if !defined (_CORBA_HANDLER_H)
#define _CORBA_HANDLER_H
#include "ace/Service_Config.h"
#include "ace/Pipe.h"
#if defined (ACE_HAS_ORBIX) || defined (ACE_HAS_MT_ORBIX)
#define EXCEPTIONS
#define WANT_ORBIX_FDS
#include /**/ <CORBA.h>
// #include /**/ <daemon.hh>
#undef EXCEPTIONS
#undef WANT_ORBIX_FDS
#if defined (ACE_WIN32)
#define ACE_CORBA_1(NAME) CORBA_##NAME
#define ACE_CORBA_2(TYPE, NAME) CORBA_##TYPE##_##NAME
#define ACE_CORBA_3(TYPE, NAME) CORBA_##TYPE##::##NAME
#else
#define ACE_CORBA_1(NAME) CORBA::##NAME
#define ACE_CORBA_2(TYPE, NAME) CORBA::##TYPE##::##NAME
#define ACE_CORBA_3(TYPE, NAME) CORBA::##TYPE##::##NAME
#endif /* ACE_WIN32 */
class ACE_Export ACE_CORBA_Handler : public ACE_Service_Object
// = TITLE
// Handle CORBA requests in conjunction with the ACE ACE_Reactor.
// Note, do *NOT* inherit from this class! Instead, use the
// ACE_MT_CORBA_HAndler and ACE_ST_CORBA_Handler as Singletons.
{
public:
// = Activation and deactivation methods.
virtual int activate_service (const char *service_name,
const char *marker_name = 0,
const char *service_location = 0);
// Activate and register <service_name> with the Orbix daemon. If
// <marker_name> and <service_location> are != 0 then do a "putit"
// to register this service with orbixd. This method also
// increments the reference count of active services using the
// ACE_ST_CORBA_Handler.
virtual int deactivate_service (const char *service_name = 0,
const char *marker_name = 0);
// Decrement the reference count and free up all the
// resources if this is the last service to be using
// the ACE_ST_CORBA_Handler...
void dump (void) const;
// Dump the state of an object.
ACE_ALLOC_HOOK_DECLARE;
// Declare the dynamic allocation hooks.
void reactor (ACE_Reactor *);
// Set the reactor instance.
ACE_Reactor *reactor (void) ;
// Get the reactor instance.
protected:
ACE_CORBA_Handler (void);
// Make this into an "abstract" class...
virtual ~ACE_CORBA_Handler (void);
// Note virtual destructor...
virtual int register_service (const char *service_name,
const char *marker_name,
const char *service_location);
// Register <service_name> by doing a "putit" to register
// the <service_name> using the <marker_name> at <service_location>
// with orbixd.
virtual int remove_service (const char *service_name,
const char *marker_name = 0);
// Register <service_name> by doing a "putit" to register
// <service_name> using the <marker_name> with orbixd.
ACE_Reactor *reactor_;
// Event demultiplexor used by ACE_ST_CORBA_Handler
ssize_t reference_count_;
// Keep track of the number of active CORBA_Handlers.
private:
// = Disallow assignment and initialization (this applies to derived
// classes, as well!)
ACE_CORBA_Handler (const ACE_CORBA_Handler &rhs);
const ACE_CORBA_Handler &operator= (const ACE_CORBA_Handler &rhs);
};
class ACE_Export ACE_ST_CORBA_Handler : public ACE_CORBA_Handler
// = TITLE
// Handle single-threaded CORBA requests in conjunction with the
// ACE_Reactor.
{
public:
static ACE_CORBA_Handler *instance (void);
// Returns a Singleton.
virtual int handle_input (ACE_HANDLE);
// Process the next Orbix event.
void dump (void) const;
// Dump the state of an object.
ACE_ALLOC_HOOK_DECLARE;
// Declare the dynamic allocation hooks.
// = The iterations are dictate how many processNextEvent() calls
// are run per-callback.
size_t iterations (void);
// Get the current iteration.
void iterations (size_t);
// Set the current iteration.
// = Dynamic linking hooks.
virtual int suspend (void);
// Atomically suspend all the threads associated with the <thr_mgr ()>.
virtual int resume (void);
// Atomically resume all the threads associated with the <thr_mgr ()_>.
protected:
void get_orbix_descriptors (void);
// Preinitialize any descriptors that Orbix is using. This is
// called in instance ().
ACE_ST_CORBA_Handler (void);
// Constructors (ensure Singleton...).
virtual ~ACE_ST_CORBA_Handler (void);
// Destructor cleans up resources.
static void insert_handle (ACE_HANDLE);
// Insert a descriptor into the ACE_Reactor that Orbix has just added.
static void remove_handle (ACE_HANDLE);
// Remove a descriptor from the ACE_Reactor that Orbix has just deleted.
static ACE_ST_CORBA_Handler *instance_;
// ACE_ST_CORBA_Handler is a singleton object.
size_t iterations_;
// Number of iterations to process per processNextEvent() call.
};
#if defined (ACE_HAS_MT_ORBIX)
class ACE_Export ACE_MT_CORBA_Handler : public ACE_CORBA_Handler, public ACE_CORBA_1 (ThreadFilter)
// = TITLE
// Handle multi-threaded CORBA requests in conjunction with the
// ACE Reactor.
{
public:
static ACE_CORBA_Handler *instance (void);
// Returns a Singleton.
virtual int handle_input (ACE_HANDLE);
// Process the next Orbix event.
void thr_mgr (ACE_Thread_Manager *tm);
// Set the Thread_Manager used by ACE_MT_CORBA_Handler
ACE_Thread_Manager *thr_mgr (void) const;
// Get the Thread_Manager used by ACE_MT_CORBA_Handler
void dump (void) const;
// Dump the state of an object.
ACE_ALLOC_HOOK_DECLARE;
// Declare the dynamic allocation hooks.
// = Dynamic linking hooks.
virtual int suspend (void);
// Atomically suspend all the threads associated with the <thr_mgr ()>.
virtual int resume (void);
// Atomically resume all the threads associated with the <thr_mgr ()>.
protected:
static void *process_events (void *);
// function executed by new thread
ACE_MT_CORBA_Handler (void);
// Constructors (ensure Singleton...).
virtual ~ACE_MT_CORBA_Handler (void);
// Destructor cleans up resources.
virtual int inRequestPreMarshal (ACE_CORBA_1 (Request) &r,
ACE_CORBA_1 (Environment) &IT_env = ACE_CORBA_1 (default_environment));
// Take the incoming request and pass it to this->handle_input() but
// through the Reactor.
static ACE_MT_CORBA_Handler *instance_;
// ACE_MT_CORBA_Handler is a singleton object.
ACE_Thread_Manager *thr_mgr_;
// Event demultiplexor used by ACE_ST_CORBA_Handler.
ACE_Pipe pipe_;
// Used to send CORBA::Requests through the server
#if defined (ACE_MT_SAFE)
static ACE_Thread_Mutex ace_mt_corba_handler_lock_;
// Double-Check lock.
#endif /* ACE_MT_SAFE */
};
#endif /* ACE_HAS_MT_ORBIX */
#if defined (__ACE_INLINE__)
#include "ace/CORBA_Handler.i"
#endif /* __ACE_INLINE__ */
#endif /* ACE_HAS_ORBIX */
#endif /* ACE_CORBA_HANDLER_H */
|
