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
239
240
241
242
243
244
245
246
247
248
249
|
/* -*- C++ -*- */
// $Id$
// ============================================================================
//
// = LIBRARY
// ace
//
// = FILENAME
// Cached_Connect_Strategy_T.h
//
// = AUTHOR
// Kirthika Parameswaran
//
// ============================================================================
#ifndef CACHED_CONNECT_STRATEGY_T_H
#define CACHED_CONNECT_STRATEGY_T_H
#include "ace/Strategies_T.h"
#include "ace/Hash_Map_Manager_T.h"
#include "Optimal_Cache_Map_Manager_T.h"
#include "Caching_Strategies_T.h"
#include "ace/Functor_T.h"
#include "ace/Pair_T.h"
#include "ace/Synch.h"
template <class SVC_HANDLER, ACE_PEER_CONNECTOR_1, class CACHING_STRATEGY, class MUTEX>
class ACE_Cached_Connect_Strategy_Ex : public ACE_Connection_Recycling_Strategy, public ACE_Connect_Strategy<SVC_HANDLER, ACE_PEER_CONNECTOR_2>
{
// = TITLE
// A connection strategy which caches connections to peers
// (represented by <SVC_HANDLER> instances), thereby allowing
// subsequent re-use of unused, but available, connections.
//
// = DESCRIPTION
// <Mem_Cached_Connect_Strategy> is intended to be used as a
// plug-in connection strategy for <ACE_Strategy_Connector>.
// It's added value is re-use of established connections.
//
// = USAGE
// In order to use this appropriately, the user must provide
// a template specialization for <ACE_Hash_Addr::compare_i()> and
// <ACE_Hash_Addr::hash_i()> based on the address type and the
// service handler type. For example, a specialization using
// <ACE_INET_Addr> and <My_Service_Handler> might be:
// = BEGIN<NOFILL>
// = BEGIN<CODE>
// size_t
// ACE_Hash_Addr<ACE_INET_Addr, My_Service_Handler>::hash_i(const ACE_INET_Addr &a)
// {
// return ...;
// }
// = END<CODE>
// = END<NOFILL>
//
// = SEE ALSO
// <ACE_Hash_Addr>.
public:
ACE_Cached_Connect_Strategy_Ex (ACE_Creation_Strategy<SVC_HANDLER> *cre_s = 0,
ACE_Concurrency_Strategy<SVC_HANDLER> *con_s = 0,
ACE_Recycling_Strategy<SVC_HANDLER> *rec_s = 0);
// Constructor
virtual ~ACE_Cached_Connect_Strategy_Ex (void);
// Destructor
virtual int open (ACE_Creation_Strategy<SVC_HANDLER> *cre_s,
ACE_Concurrency_Strategy<SVC_HANDLER> *con_s,
ACE_Recycling_Strategy<SVC_HANDLER> *rec_s);
// This methods allow you to change the strategies used by the
// cached connector.
virtual int make_svc_handler (SVC_HANDLER *&sh);
// Template method for making a new <svc_handler>
virtual int activate_svc_handler (SVC_HANDLER *svc_handler);
// Template method for activating a new <svc_handler>
virtual int assign_recycler (SVC_HANDLER *svc_handler,
ACE_Connection_Recycling_Strategy *recycler,
const void *recycling_act);
// Template method for setting the recycler information of the
// svc_handler.
virtual int prepare_for_recycling (SVC_HANDLER *svc_handler);
// Template method for preparing the svc_handler for recycling.
virtual int connect_svc_handler (SVC_HANDLER *&sh,
const ACE_PEER_CONNECTOR_ADDR &remote_addr,
ACE_Time_Value *timeout,
const ACE_PEER_CONNECTOR_ADDR &local_addr,
int reuse_addr,
int flags,
int perms);
virtual int connect_svc_handler (SVC_HANDLER *&sh,
SVC_HANDLER *&sh_copy,
const ACE_PEER_CONNECTOR_ADDR &remote_addr,
ACE_Time_Value *timeout,
const ACE_PEER_CONNECTOR_ADDR &local_addr,
int reuse_addr,
int flags,
int perms);
// Checks to see if there is already a <SVC_HANDLER> in the cache
// connected to the <remote_addr>. If so, we return this pointer.
// Otherwise we establish the connection, put it into the cache, and
// return the <SVC_HANDLER> pointer. <[NOTE]>: the <{reuse_addr}>
// argument does NOT control re-use of addresses in the cache.
// Rather, if the underlying protocol requires a "dead time" prior
// to re-use of its addresses (TCP is a classic example of this),
// <{and}> the protocol provides a means by which to defeat the dead
// time, setting this argument to non-zero will defeat the dead-time
// requirement. <{Dev. Note: We might want to consider enhancing
// the interface at some point so that this also controls re-use of
// the cache.}>
virtual int purge (const void *recycling_act);
// Remove from cache.
virtual int cache (const void *recycling_act);
// Add to cache.
virtual int mark_as_closed (const void *recycling_act);
// Mark as closed.
virtual int cleanup_hint (const void *recycling_act);
// Cleanup hint.
// = Define some useful typedefs.
typedef ACE_Creation_Strategy<SVC_HANDLER>
CREATION_STRATEGY;
typedef ACE_Concurrency_Strategy<SVC_HANDLER>
CONCURRENCY_STRATEGY;
typedef ACE_Recycling_Strategy<SVC_HANDLER>
RECYCLING_STRATEGY;
// = Super class
typedef ACE_Connect_Strategy<SVC_HANDLER, ACE_PEER_CONNECTOR_2>
CONNECT_STRATEGY;
// = Typedefs for managing the map
typedef ACE_Refcounted_Hash_Recyclable<ACE_PEER_CONNECTOR_ADDR>
REFCOUNTED_HASH_RECYCLABLE_ADDRESS;
typedef ACE_Optimal_Cache_Map_Manager<REFCOUNTED_HASH_RECYCLABLE_ADDRESS, SVC_HANDLER *, ACE_Hash<REFCOUNTED_HASH_RECYCLABLE_ADDRESS>, ACE_Equal_To<REFCOUNTED_HASH_RECYCLABLE_ADDRESS>, CACHING_STRATEGY>
CONNECTION_CACHE;
typedef ACE_Optimal_Cache_Map_Iterator<REFCOUNTED_HASH_RECYCLABLE_ADDRESS, SVC_HANDLER *, ACE_Hash<REFCOUNTED_HASH_RECYCLABLE_ADDRESS>, ACE_Equal_To<REFCOUNTED_HASH_RECYCLABLE_ADDRESS>, CACHING_STRATEGY>
CONNECTION_CACHE_ITERATOR;
typedef ACE_Optimal_Cache_Map_Reverse_Iterator<REFCOUNTED_HASH_RECYCLABLE_ADDRESS, SVC_HANDLER *, ACE_Hash<REFCOUNTED_HASH_RECYCLABLE_ADDRESS>, ACE_Equal_To<REFCOUNTED_HASH_RECYCLABLE_ADDRESS>, CACHING_STRATEGY>
CONNECTION_CACHE_REVERSE_ITERATOR;
typedef ACE_TYPENAME CONNECTION_CACHE::CACHE_ENTRY
CONNECTION_CACHE_ENTRY;
// = Strategy accessors
virtual ACE_Creation_Strategy<SVC_HANDLER> *creation_strategy (void) const;
virtual ACE_Recycling_Strategy<SVC_HANDLER> *recycling_strategy (void) const;
virtual ACE_Concurrency_Strategy<SVC_HANDLER> *concurrency_strategy (void) const;
protected:
virtual int purge_i (const void *recycling_act);
// Remove from cache (non-locking version).
virtual int cache_i (const void *recycling_act);
// Add to cache (non-locking version).
virtual int mark_as_closed_i (const void *recycling_act);
// Mark as closed (non-locking version).
virtual int cleanup_hint_i (const void *recycling_act);
// Cleanup hint.
// = Helpers
int check_hint_i (SVC_HANDLER *&sh,
const ACE_PEER_CONNECTOR_ADDR &remote_addr,
ACE_Time_Value *timeout,
const ACE_PEER_CONNECTOR_ADDR &local_addr,
int reuse_addr,
int flags,
int perms,
ACE_Cached_Connect_Strategy_Ex<SVC_HANDLER, ACE_PEER_CONNECTOR_2, CACHING_STRATEGY, MUTEX>::CONNECTION_CACHE_ENTRY *&entry,
int &found);
int connect_svc_handler_i (SVC_HANDLER *&sh,
const ACE_PEER_CONNECTOR_ADDR &remote_addr,
ACE_Time_Value *timeout,
const ACE_PEER_CONNECTOR_ADDR &local_addr,
int reuse_addr,
int flags,
int perms,
int &found);
int find_or_create_svc_handler_i (SVC_HANDLER *&sh,
const ACE_PEER_CONNECTOR_ADDR &remote_addr,
ACE_Time_Value *timeout,
const ACE_PEER_CONNECTOR_ADDR &local_addr,
int reuse_addr,
int flags,
int perms,
ACE_Cached_Connect_Strategy_Ex<SVC_HANDLER, ACE_PEER_CONNECTOR_2, CACHING_STRATEGY, MUTEX>::CONNECTION_CACHE_ENTRY *&entry,
int &found);
CONNECTION_CACHE connection_cache_;
// Table that maintains the cache of connected <SVC_HANDLER>s.
MUTEX lock_;
// Mutual exclusion for this object.
// = Strategy objects.
CREATION_STRATEGY *creation_strategy_;
// Creation strategy for an <Connector>.
int delete_creation_strategy_;
// 1 if <Connector> created the creation strategy and thus should
// delete it, else 0.
CONCURRENCY_STRATEGY *concurrency_strategy_;
// Concurrency strategy for an <Connector>.
int delete_concurrency_strategy_;
// 1 if <Connector> created the concurrency strategy and thus should
// delete it, else 0.
RECYCLING_STRATEGY *recycling_strategy_;
// Recycling strategy for an <Connector>.
int delete_recycling_strategy_;
// 1 if <Connector> created the recycling strategy and thus should
// delete it, else 0.
};
#if !defined (ACE_LACKS_INLINE_FUNCTIONS)
#include "Cached_Connect_Strategy_T.i"
#endif /* ACE_LACKS_INLINE_FUNCTIONS */
#if defined (ACE_TEMPLATES_REQUIRE_SOURCE)
#include "Cached_Connect_Strategy_T.cpp"
#endif /* ACE_TEMPLATES_REQUIRE_SOURCE */
#if defined (ACE_TEMPLATES_REQUIRE_PRAGMA)
#pragma implementation ("Cached_Connect_Strategy_T.cpp")
#endif /* ACE_TEMPLATES_REQUIRE_PRAGMA */
#endif /* CACHED_CONNECT_STRATEGY_T_H */
|
