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
|
// This may look like C, but it's really -*- C++ -*-
// $Id$
// ============================================================================
//
// = LIBRARY
// TAO
//
// = FILENAME
// default_server.h
//
// = AUTHOR
// Chris Cleeland
//
// ============================================================================
#ifndef TAO_DEFAULT_SERVER_FACTORY_H
# define TAO_DEFAULT_SERVER_FACTORY_H
#include "tao/corba.h"
#include "tao/ORB_Strategies_T.h"
class TAO_Default_Server_Creation_Strategy : public TAO_Server_Strategy_Factory::CREATION_STRATEGY
{
public:
TAO_Default_Server_Creation_Strategy (ACE_Thread_Manager * = 0);
// ctor
// = Factory method.
virtual int make_svc_handler (TAO_Server_Connection_Handler *&sh);
};
class TAO_Default_Server_Strategy_Factory : public TAO_Server_Strategy_Factory
{
// = TITLE
// This is the default strategy factory for CORBA servers. It
// allows developers to choose strategies via argument flags.
// This design gives substantial freedom for experimentation.
public:
// = Initialization and termination methods.
TAO_Default_Server_Strategy_Factory (void);
virtual ~TAO_Default_Server_Strategy_Factory (void);
virtual int open (void);
// Call <open> for our strategies.
// = Server-side ORB Strategy Factory Methods.
virtual CREATION_STRATEGY *creation_strategy (void);
// Return concrete creation strategy.
virtual CONCURRENCY_STRATEGY *concurrency_strategy (void);
virtual TAO_Object_Table_Impl *create_object_table (int user_id_policy);
// Return a new id-->object table. If <user_id_policy> is true, the
// request is being made for a POA with USER ID policy. Otherwise,
// the SYSTEM_ID policy is being used.
virtual ACE_Lock *create_poa_lock (void);
// Creates and returns a lock for POA based on the setting for
// <-ORBpoalock>. A setting of <thread> returns an
// <ACE_Lock_Adapter\<ACE_Thread_Mutex\>>; a setting of <null>
// returns an <ACE_Lock_Adapter\<ACE_NULL_Mutex\>>.
virtual ACE_Lock *create_poa_mgr_lock (void);
// Creates and returns a lock for a POA Manager based on the setting
// for <-ORBpoamgrlock>. A setting of <thread> returns an
// <ACE_Lock_Adapter\<ACE_Thread_Mutex\>>; a setting of <null>
// returns an <ACE_Lock_Adapter\<ACE_NULL_Mutex\>>.
virtual ACE_Lock *create_servant_lock (void);
// Creates and returns a lock for servants based on the setting of
// POA, and concurrency strategy as follows:
// 1. If concurrency policy is reactive and POA is TSS
// then return ACE_Null_Mutex via ACE_Lock_Adapter.
//
// 2. If concurrency policy is non-reactive then
// return ACE_Thread_Mutex ...
//
// 3. If the POA is global then, return
// ACE_Null_Mutex iff ORB_init count == 1,
// else if ORB_init count > 1 return
// ACE_Thread_Mutex.
virtual ACE_Lock *create_event_loop_lock (void);
// Creates and returns a lock for the event loop.
// If the ORB is single threaded or some form of ORB-per-thread then
// it is more efficient to use a Null_Mutex for the variables
// controlling the event loop (termination). Otherwise a
// Recursive_Thread_Mutex or Thread_Mutex may be required.
virtual ACE_Lock *create_collocation_table_lock (void);
// Creates and returns the lock for the global collocation table.
virtual ACE_Lock *create_cached_connector_lock (void);
// Creates and returns the lock for the global collocation table.
// = Service Configurator hooks.
virtual int init (int argc, char *argv[]);
// Initialize the ORB when it's linked dynamically.
virtual u_long object_table_size (void) const;
// Return the object table size
int parse_args (int argc, char *argv[]);
// Arguments are in the form of -ORBxxx. Valid arguments are:
// <-ORBconcurrency> <{which}>
// where <{which}> is one of <reactive> or <thread-per-connection>.
// <-ORBtablesize> <{num}>
// to set the table size
// <-ORBdemuxstrategy> <{which}>
// where <{which}> is one of <dynamic>, <linear>, or <active>
// <-ORBpoalock> <{which}>
// where <{which}> is one of <thread> or <null> (default <thread>)
// <-ORBpoamgrlock> <{which}>
// where <{which}> is one of <thread> or <null> (default <thread>)
// <-ORBeventlock> <{which}>
// where <{which}> is one of <thread> or <null> (default <null>)
protected:
void tokenize (char *flag_string);
// = Helpers for <create_object_table>
TAO_Object_Table_Impl *create_user_id_policy_object_table (void);
TAO_Object_Table_Impl *create_system_id_policy_object_table (void);
TAO_Object_Table_Impl *create_object_table_i (TAO_Demux_Strategy table_type);
u_long thread_flags_;
// Default thread flags passed to thr_create().
u_long object_table_size_;
// Default size of object lookup table.
TAO_Demux_Strategy object_lookup_strategy_for_user_id_policy_;
// The type of lookup/demultiplexing strategy being used for user id
// policy
TAO_Demux_Strategy object_lookup_strategy_for_system_id_policy_;
// The type of lookup/demultiplexing strategy being used for system
// id policy
enum Lock_Type
{
TAO_NULL_LOCK,
TAO_THREAD_LOCK
};
Lock_Type poa_lock_type_;
// The type of lock to be returned by <create_poa_lock()>.
Lock_Type poa_mgr_lock_type_;
// The type of lock to be returned by <create_poa_mgr_lock()>.
Lock_Type event_loop_lock_type_;
// The type of lock to be returned by <create_event_loop_lock()>.
Lock_Type collocation_table_lock_type_;
// Type of lock used by the collocation table.
Lock_Type cached_connector_lock_type_;
// Type of lock used by the cached connector.
// = Strategies Used.
TAO_Reactive_Strategy<TAO_Server_Connection_Handler> reactive_strategy_;
// A strategy for passively establishing connections which utilizes
// the Reactor.
ACE_Thread_Strategy<TAO_Server_Connection_Handler> threaded_strategy_;
// The threaded strategy used for passively establishing
// connections.
CREATION_STRATEGY *creation_strategy_;
// concrete creation strategy.
CONCURRENCY_STRATEGY *concurrency_strategy_;
// concrete concurrency strategy.
TAO_Default_Server_Creation_Strategy default_creation_strategy_;
// The default creation strategy for the server side connection
// handlers
#if 0
// Someday we'll need these!
ACCEPT_STRATEGY *accept_strategy_;
SCHEDULING_STRATEGY *scheduling_strategy_;
#endif /* 0 */
};
#if defined (__ACE_INLINE__)
# include "tao/default_server.i"
#endif /* __ACE_INLINE__ */
ACE_FACTORY_DECLARE (TAO, TAO_Default_Server_Strategy_Factory)
#endif /* TAO_DEFAULT_SERVER_FACTORY_H */
|
