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
|
/* -*- C++ -*- */
// $Id$
// ============================================================================
//
// = LIBRARY
// gateway
//
// = FILENAME
// Options.h
//
// = AUTHOR
// Douglas C. Schmidt
//
// ============================================================================
#if !defined (OPTIONS_H)
#define OPTIONS_H
#include "ace/Synch.h"
class ACE_Svc_Export Options
{
// = TITLE
// Singleton that consolidates all Options for a gatewayd.
public:
// = Options that can be enabled/disabled.
enum
{
// = The types of threading strategies.
REACTIVE = 0,
OUTPUT_MT = 1,
INPUT_MT = 2,
VERBOSE = 01,
DEBUG = 02,
SUPPLIER_ACCEPTOR = 04,
CONSUMER_ACCEPTOR = 010,
SUPPLIER_CONNECTOR = 020,
CONSUMER_CONNECTOR = 040
};
static Options *instance (void);
// Return Singleton.
~Options (void);
// Termination.
int parse_args (int argc, char *argv[]);
// Parse the arguments and set the options.
// = Accessor methods.
int enabled (int option) const;
// Determine if an option is enabled.
ACE_Lock_Adapter<ACE_SYNCH_MUTEX> *locking_strategy (void) const;
// Gets the locking strategy used for serializing access to the
// reference count in <ACE_Message_Block>. If it's 0, then there's
// no locking strategy and we're using a REACTIVE concurrency
// strategy.
void locking_strategy (ACE_Lock_Adapter<ACE_SYNCH_MUTEX> *);
// Set the locking strategy used for serializing access to the
// reference count in <ACE_Message_Block>.
int performance_window (void) const;
// Number of seconds after connection establishment to report
// throughput.
int blocking_semantics (void) const;
// 0 == blocking connects, ACE_NONBLOCK == non-blocking connects.
int socket_queue_size (void) const;
// Size of the socket queue (0 means "use default").
u_long threading_strategy (void) const;
// i.e., REACTIVE, OUTPUT_MT, and/or INPUT_MT.
u_short supplier_acceptor_port (void) const;
// Our acceptor port number, i.e., the one that we passively listen
// on for connections to arrive from a gatewayd and create a
// Supplier.
u_short consumer_acceptor_port (void) const;
// Our acceptor port number, i.e., the one that we passively listen
// on for connections to arrive from a gatewayd and create a
// Consumer.
u_short supplier_connector_port (void) const;
// The connector port number, i.e., the one that we use to actively
// establish connections with a gatewayd and create a Supplier.
u_short consumer_connector_port (void) const;
// The connector port number, i.e., the one that we use to actively
// establish connections with a gatewayd and create a Consumer.
const char *connector_host (void) const;
// Our connector port host, i.e., the host running the gatewayd
// process.
const char *connection_config_file (void) const;
// Name of the connection configuration file.
const char *consumer_config_file (void) const;
// Name of the consumer map configuration file.
long max_timeout (void) const;
// The maximum retry timeout delay.
long max_queue_size (void) const;
// The maximum size of the queue.
private:
enum
{
MAX_QUEUE_SIZE = 1024 * 1024 * 16,
// We'll allow up to 16 megabytes to be queued per-output proxy.
MAX_TIMEOUT = 32
// The maximum timeout for trying to re-establish connections.
};
Options (void);
// Initialization.
static Options *instance_;
// Options Singleton instance.
ACE_Lock_Adapter<ACE_SYNCH_MUTEX> *locking_strategy_;
// Points to the locking strategy used for serializing access to the
// reference count in <ACE_Message_Block>. If it's 0, then there's
// no locking strategy and we're using a REACTIVE concurrency
// strategy.
int performance_window_;
// Number of seconds after connection establishment to report
// throughput.
int blocking_semantics_;
// 0 == blocking connects, ACE_NONBLOCK == non-blocking connects.
int socket_queue_size_;
// Size of the socket queue (0 means "use default").
u_long threading_strategy_;
// i.e., REACTIVE, OUTPUT_MT, and/or INPUT_MT.
u_long options_;
// Flag to indicate if we want verbose diagnostics.
u_short supplier_acceptor_port_;
// The acceptor port number, i.e., the one that we passively listen
// on for connections to arrive from a gatewayd and create a
// Supplier.
u_short consumer_acceptor_port_;
// The acceptor port number, i.e., the one that we passively listen
// on for connections to arrive from a gatewayd and create a
// Consumer.
u_short supplier_connector_port_;
// The connector port number, i.e., the one that we use to actively
// establish connections with a gatewayd and create a Supplier.
u_short consumer_connector_port_;
// The connector port number, i.e., the one that we use to actively
// establish connections with a gatewayd and create a Consumer.
long max_timeout_;
// The maximum retry timeout delay.
long max_queue_size_;
// The maximum size of the queue.
char connection_config_file_[MAXPATHLEN + 1];
// Name of the connection configuration file.
char consumer_config_file_[MAXPATHLEN + 1];
// Name of the consumer map configuration file.
};
#endif /* OPTIONS_H */
|
