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
|
// $Id$
#include "tao/ORB_Core.h"
#include "tao/Server_Strategy_Factory.h"
#include "tao/poa_macros.h"
#include "tao/POAManager.h"
#if !defined (__ACE_INLINE__)
# include "tao/POAManager.i"
#endif /* ! __ACE_INLINE__ */
TAO_POA_Manager::TAO_POA_Manager (void)
: state_ (PortableServer::POAManager::HOLDING),
closing_down_ (0),
lock_ (0),
poa_collection_ ()
{
this->lock_ = TAO_ORB_Core_instance ()->server_factory ()->create_poa_mgr_lock ();
}
TAO_POA_Manager::~TAO_POA_Manager (void)
{
delete this->lock_;
}
void
TAO_POA_Manager::activate_i (CORBA::Environment &ACE_TRY_ENV)
{
// This operation changes the state of the POA manager to active. If
// issued while the POA manager is in the inactive state, the
// AdapterInactive exception is raised. Entering the active state
// enables the associated POAs to process requests.
if (this->state_ == PortableServer::POAManager::INACTIVE)
ACE_THROW (PortableServer::POAManager::AdapterInactive ());
else
this->state_ = PortableServer::POAManager::ACTIVE;
}
#if !defined (TAO_HAS_MINIMUM_CORBA)
void
TAO_POA_Manager::hold_requests_i (CORBA::Boolean wait_for_completion,
CORBA::Environment &ACE_TRY_ENV)
{
// This operation changes the state of the POA manager to
// holding. If issued while the POA manager is in the inactive
// state, the AdapterInactive exception is raised. Entering the
// holding state causes the associated POAs to queue incoming
// requests. Any requests that have been queued but have not
// started executing will continue to be queued while in the holding
// state.
if (this->state_ == PortableServer::POAManager::INACTIVE)
ACE_THROW (PortableServer::POAManager::AdapterInactive ());
else
this->state_ = PortableServer::POAManager::HOLDING;
// If the wait_for_completion parameter is FALSE, this operation
// returns immediately after changing the state. If the parameter is
// TRUE, this operation does not return until either there are no
// actively executing requests in any of the POAs associated with
// this POA manager (that is, all requests that were started prior
// to the state change have completed) or the state of the POA
// manager is changed to a state other than holding.
ACE_UNUSED_ARG (wait_for_completion);
}
void
TAO_POA_Manager::discard_requests_i (CORBA::Boolean wait_for_completion,
CORBA::Environment &ACE_TRY_ENV)
{
// This operation changes the state of the POA manager to
// discarding. If issued while the POA manager is in the inactive
// state, the AdapterInactive exception is raised. Entering the
// discarding state causes the associated POAs to discard incoming
// requests. In addition, any requests that have been queued but
// have not started executing are discarded. When a request is
// discarded, a TRANSIENT system exception is returned to the
// client.
if (this->state_ == PortableServer::POAManager::INACTIVE)
ACE_THROW (PortableServer::POAManager::AdapterInactive ());
else
this->state_ = PortableServer::POAManager::DISCARDING;
// If the wait_for_completion parameter is FALSE, this operation
// returns immediately after changing the state. If the parameter is
// TRUE, this operation does not return until either there are no
// actively executing requests in any of the POAs associated with
// this POA manager (that is, all requests that were started prior
// to the state change have completed) or the state of the POA
// manager is changed to a state other than discarding.
ACE_UNUSED_ARG (wait_for_completion);
}
void
TAO_POA_Manager::deactivate_i (CORBA::Boolean etherealize_objects,
CORBA::Boolean wait_for_completion,
CORBA::Environment &ACE_TRY_ENV)
{
this->closing_down_ = 1;
// This operation changes the state of the POA manager to
// inactive. If issued while the POA manager is in the inactive
// state, the AdapterInactive exception is raised. Entering the
// inactive state causes the associated POAs to reject requests that
// have not begun to be executed as well as any new requests.
if (this->state_ == PortableServer::POAManager::INACTIVE)
ACE_THROW (PortableServer::POAManager::AdapterInactive ());
else
this->state_ = PortableServer::POAManager::INACTIVE;
// After changing the state, if the etherealize_objects parameter is:
//
// a) TRUE - the POA manager will cause all associated POAs that
// have the RETAIN and USE_SERVANT_MANAGER policies to perform the
// etherealize operation on the associated servant manager for all
// active objects.
//
// b) FALSE - the etherealize operation is not called. The purpose
// is to provide developers with a means to shut down POAs in a
// crisis (for example, unrecoverable error) situation.
for (POA_COLLECTION::iterator iterator = this->poa_collection_.begin ();
iterator != this->poa_collection_.end ();
++iterator)
{
TAO_POA *poa = *iterator;
poa->destroy (etherealize_objects,
wait_for_completion,
ACE_TRY_ENV);
// poa->etherealize_servants (etherealize_objects,
// wait_for_completion,
// ACE_TRY_ENV);
ACE_CHECK;
}
// If the wait_for_completion parameter is FALSE, this operation
// will return immediately after changing the state. If the
// parameter is TRUE, this operation does not return until there are
// no actively executing requests in any of the POAs associated with
// this POA manager (that is, all requests that were started prior
// to the state change have completed) and, in the case of a TRUE
// etherealize_objects, all invocations of etherealize have
// completed for POAs having the RETAIN and USE_SERVANT_MANAGER
// policies.
// If the ORB::shutdown operation is called, it makes a call on
// deactivate with a TRUE etherealize_objects parameter for each POA
// manager known in the process; the wait_for_completion parameter
// to deactivate will be the same as the similarly named parameter
// of ORB::shutdown.
}
#endif /* TAO_HAS_MINIMUM_CORBA */
PortableServer::POAManager::State
TAO_POA_Manager::get_state (CORBA::Environment &ACE_TRY_ENV)
{
// Lock access to the POAManager for the duration of this transaction
TAO_POA_READ_GUARD_RETURN (ACE_Lock, monitor, this->lock (), this->state_, ACE_TRY_ENV);
return this->state_;
}
void
TAO_POA_Manager::remove_poa (TAO_POA *poa,
CORBA::Environment &ACE_TRY_ENV)
{
// If we are not closing down, we must remove this poa from our
// collection.
if (!this->closing_down_)
{
// Lock access to the POAManager for the duration of this transaction
TAO_POA_WRITE_GUARD (ACE_Lock, monitor, this->lock (), ACE_TRY_ENV);
this->remove_poa_i (poa,
ACE_TRY_ENV);
}
// If we are closing down, we are currently iterating over our poa
// collection and there is not need to remove this poa from our
// collection.
// @@ This may cause segfault if another thread gets a hold at this
// POAManager but gets blocked on register POA waiting for
// remove_poa to complete. I think we need to use the client side mapping
// to refcount this.
if (this->poa_collection_.is_empty ())
this->destroy ();
}
void
TAO_POA_Manager::remove_poa_i (TAO_POA *poa,
CORBA::Environment &ACE_TRY_ENV)
{
int result = this->poa_collection_.remove (poa);
if (result != 0)
ACE_THROW (CORBA::OBJ_ADAPTER (CORBA::COMPLETED_NO));
}
void
TAO_POA_Manager::register_poa (TAO_POA *poa,
CORBA::Environment &ACE_TRY_ENV)
{
// Lock access to the POAManager for the duration of this transaction
TAO_POA_WRITE_GUARD (ACE_Lock, monitor, this->lock (), ACE_TRY_ENV);
this->register_poa_i (poa,
ACE_TRY_ENV);
}
void
TAO_POA_Manager::register_poa_i (TAO_POA *poa,
CORBA::Environment &ACE_TRY_ENV)
{
int result = this->poa_collection_.insert (poa);
if (result != 0)
ACE_THROW (CORBA::OBJ_ADAPTER (CORBA::COMPLETED_NO));
}
|
