blob: 43994062fd0220b88221ae1f4af82b807c4ffedd (
plain)
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
|
/* -*- C++ -*- */
//=============================================================================
/**
* @file CEC_Reactive_ConsumerControl.h
*
* $Id$
*
* @author Carlos O'Ryan (coryan@cs.wustl.edu)
*
* More details can be found in:
*
* http://doc.ece.uci.edu/~coryan/EC/
*/
//=============================================================================
#ifndef TAO_CEC_REACTIVE_CONSUMERCONTROL_H
#define TAO_CEC_REACTIVE_CONSUMERCONTROL_H
#include /**/ "ace/pre.h"
#include "CEC_ConsumerControl.h"
#include "orbsvcs/ESF/ESF_Worker.h"
#include "tao/ORB.h"
#include "ace/Event_Handler.h"
#if !defined (ACE_LACKS_PRAGMA_ONCE)
# pragma once
#endif /* ACE_LACKS_PRAGMA_ONCE */
class TAO_CEC_EventChannel;
class TAO_CEC_Reactive_ConsumerControl;
#if defined (TAO_HAS_TYPED_EVENT_CHANNEL)
class TAO_CEC_TypedEventChannel;
#endif /* TAO_HAS_TYPED_EVENT_CHANNEL */
/**
* @class TAO_CEC_ConsumerControl_Adapter
*
* @brief Forwards timeout events to the Reactive ConsumerControl
*
* The Reactive ConsumerControl strategy uses the reactor to
* periodically wakeup and verify the state of the consumers
* registered with the Event Channel.
*/
class TAO_Event_Serv_Export TAO_CEC_ConsumerControl_Adapter : public ACE_Event_Handler
{
public:
/// Constructor
TAO_CEC_ConsumerControl_Adapter (TAO_CEC_Reactive_ConsumerControl *adaptee);
// = Documented in ACE_Event_Handler.
virtual int handle_timeout (const ACE_Time_Value &tv,
const void *arg = 0);
private:
/// The adapted object
TAO_CEC_Reactive_ConsumerControl *adaptee_;
};
/**
* @class TAO_CEC_Reactive_ConsumerControl
*
* @brief ConsumerControl
*
* Defines the interface for the consumer control strategy.
* This strategy handles misbehaving or failing consumers.
* = MEMORY MANAGMENT
* = LOCKING
* = TODO
*/
class TAO_Event_Serv_Export TAO_CEC_Reactive_ConsumerControl
: public TAO_CEC_ConsumerControl
{
public:
/// Constructor. It does not assume ownership of the <event_channel>
/// parameter.
TAO_CEC_Reactive_ConsumerControl (const ACE_Time_Value &rate,
const ACE_Time_Value &timeout,
unsigned int retries,
TAO_CEC_EventChannel *event_channel,
CORBA::ORB_ptr orb);
/// Constructor for the typed ec.
#if defined (TAO_HAS_TYPED_EVENT_CHANNEL)
TAO_CEC_Reactive_ConsumerControl (
const ACE_Time_Value &rate,
const ACE_Time_Value &timeout,
unsigned int retries,
TAO_CEC_TypedEventChannel *typed_event_channel,
CORBA::ORB_ptr orb
);
#endif /* TAO_HAS_TYPED_EVENT_CHANNEL */
/// destructor...
virtual ~TAO_CEC_Reactive_ConsumerControl (void);
/// Receive the timeout from the adapter
void handle_timeout (const ACE_Time_Value &tv,
const void* arg);
// = Documented in TAO_CEC_ConsumerControl
virtual int activate (void);
virtual int shutdown (void);
virtual void consumer_not_exist (TAO_CEC_ProxyPushSupplier *proxy
ACE_ENV_ARG_DECL_NOT_USED);
virtual void consumer_not_exist (TAO_CEC_ProxyPullSupplier *proxy
ACE_ENV_ARG_DECL_NOT_USED);
virtual void system_exception (TAO_CEC_ProxyPushSupplier *proxy,
CORBA::SystemException &
ACE_ENV_ARG_DECL_NOT_USED);
/// Do we need to disconnect this supplier? The parameter type for
/// proxy is PortableServer::ServantBase* due to the fact that this
/// method will be used for TAO_CEC_ProxyPushSupplier's and
/// TAO_CEC_ProxyPullSupplier's.
virtual bool need_to_disconnect (PortableServer::ServantBase* proxy);
/// Allow others to inform us when a send or receive was successful.
virtual void successful_transmission (PortableServer::ServantBase* proxy);
private:
/// Check if the consumers still exists. It is a helper method for
/// handle_timeout() to isolate the exceptions.
void query_consumers (ACE_ENV_SINGLE_ARG_DECL);
private:
/// The polling rate
ACE_Time_Value rate_;
/// The polling timeout
ACE_Time_Value timeout_;
/// The number of retries per proxy until it is disconnected
unsigned int retries_;
/// The Adapter for the reactor events
TAO_CEC_ConsumerControl_Adapter adapter_;
/// The event channel
TAO_CEC_EventChannel *event_channel_;
/// The typed event channel
#if defined (TAO_HAS_TYPED_EVENT_CHANNEL)
TAO_CEC_TypedEventChannel *typed_event_channel_;
#endif /* TAO_HAS_TYPED_EVENT_CHANNEL */
/// The ORB
CORBA::ORB_var orb_;
/// To control the timeout policy in the thread
CORBA::PolicyCurrent_var policy_current_;
/// Precomputed policy list to the set timeout.
CORBA::PolicyList policy_list_;
/// The ORB reactor
ACE_Reactor *reactor_;
#if defined (TAO_HAS_CORBA_MESSAGING) && TAO_HAS_CORBA_MESSAGING != 0
/// The timer id
int timer_id_;
#endif /* TAO_HAS_CORBA_MESSAGING */
};
// ****************************************************************
class TAO_CEC_Ping_Push_Consumer
: public TAO_ESF_Worker<TAO_CEC_ProxyPushSupplier>
{
public:
TAO_CEC_Ping_Push_Consumer (TAO_CEC_ConsumerControl *control);
virtual void work (TAO_CEC_ProxyPushSupplier *supplier
ACE_ENV_ARG_DECL);
private:
TAO_CEC_ConsumerControl *control_;
};
// ****************************************************************
class TAO_CEC_Ping_Pull_Consumer
: public TAO_ESF_Worker<TAO_CEC_ProxyPullSupplier>
{
public:
TAO_CEC_Ping_Pull_Consumer (TAO_CEC_ConsumerControl *control);
virtual void work (TAO_CEC_ProxyPullSupplier *supplier
ACE_ENV_ARG_DECL);
private:
TAO_CEC_ConsumerControl *control_;
};
#if defined (__ACE_INLINE__)
#include "CEC_Reactive_ConsumerControl.i"
#endif /* __ACE_INLINE__ */
#include /**/ "ace/post.h"
#endif /* TAO_CEC_CONSUMERCONTROL_H */
|
