1 h.sterling 1.1 //%2005////////////////////////////////////////////////////////////////////////
2 //
3 // Copyright (c) 2000, 2001, 2002 BMC Software; Hewlett-Packard Development
4 // Company, L.P.; IBM Corp.; The Open Group; Tivoli Systems.
5 // Copyright (c) 2003 BMC Software; Hewlett-Packard Development Company, L.P.;
6 // IBM Corp.; EMC Corporation, The Open Group.
7 // Copyright (c) 2004 BMC Software; Hewlett-Packard Development Company, L.P.;
8 // IBM Corp.; EMC Corporation; VERITAS Software Corporation; The Open Group.
9 // Copyright (c) 2005 Hewlett-Packard Development Company, L.P.; IBM Corp.;
10 // EMC Corporation; VERITAS Software Corporation; The Open Group.
11 //
12 // Permission is hereby granted, free of charge, to any person obtaining a copy
13 // of this software and associated documentation files (the "Software"), to
14 // deal in the Software without restriction, including without limitation the
15 // rights to use, copy, modify, merge, publish, distribute, sublicense, and/or
16 // sell copies of the Software, and to permit persons to whom the Software is
17 // furnished to do so, subject to the following conditions:
18 //
19 // THE ABOVE COPYRIGHT NOTICE AND THIS PERMISSION NOTICE SHALL BE INCLUDED IN
20 // ALL COPIES OR SUBSTANTIAL PORTIONS OF THE SOFTWARE. THE SOFTWARE IS PROVIDED
21 // "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT
22 h.sterling 1.1 // LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR
23 // PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
24 // HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
25 // ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
26 // WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
27 //
28 //==============================================================================
29 //
30 // Author: Heather Sterling (hsterl@us.ibm.com)
31 //
32 // Modified By:
33 //
34 //%/////////////////////////////////////////////////////////////////////////////
35
36 #include "DynamicListener.h"
37 #include "ListenerService.h"
38 #include "ConsumerManager.h"
39
40 #include <Pegasus/Common/Config.h>
41 #include <Pegasus/Common/Exception.h>
42 #include <Pegasus/Common/SSLContext.h>
43 h.sterling 1.1 #include <Pegasus/Common/Monitor.h>
44 #include <Pegasus/Common/HTTPAcceptor.h>
45 #include <Pegasus/Common/PegasusVersion.h>
46 #include <Pegasus/Common/Tracer.h>
47
48 #include <Pegasus/Common/HashTable.h>
49 #include <Pegasus/Common/FileSystem.h>
50
51 #include <Pegasus/ExportServer/CIMExportResponseEncoder.h>
52 #include <Pegasus/ExportServer/CIMExportRequestDecoder.h>
53
54 PEGASUS_NAMESPACE_BEGIN
55 PEGASUS_USING_STD;
56
57
58 const Boolean DynamicListener::DEFAULT_CONSUMER_UNLOAD = true;
59 const Uint32 DynamicListener::DEFAULT_IDLE_TIMEOUT = 300000; //ms
60 const Boolean DynamicListener::DEFAULT_FORCE_SHUTDOWN = false;
61 const Uint32 DynamicListener::DEFAULT_SHUTDOWN_TIMEOUT = 10000; //ms
62
63
64 h.sterling 1.1 /////////////////////////////////////////////////////////////////////////////
65 // DynamicListenerRep
66 /////////////////////////////////////////////////////////////////////////////
67
68 //This class is used to stabilize the DynamicListener external interface.
69
70 class DynamicListenerRep
71 {
72 public:
73
74 DynamicListenerRep(Uint32 portNumber,
75 const String& consumerDir,
76 const String& consumerConfigDir,
77 SSLContext* sslContext,
78 Boolean enableConsumerUnload,
79 Uint32 consumerIdleTimeout,
80 Uint32 shutdownTimeout);
81
82 ~DynamicListenerRep();
83
84 void start();
85 h.sterling 1.1
86 void stop(Boolean forceShutdown);
87
88 Boolean isAlive();
89
90 Boolean addConsumer(const String& consumerName, const String& location = String::EMPTY);
91
92 Boolean removeConsumer(const String& consumerName);
93
94 Uint32 getPortNumber();
95
96 String getConsumerDir();
97
98 String getConsumerConfigDir();
99
100 void setEnableConsumerUnload(Boolean consumerUnload);
101
102 Boolean getEnableConsumerUnload();
103
104 void setIdleTimeout(const Uint32 idleTimeout);
105
106 h.sterling 1.1 Uint32 getIdleTimeout();
107
108 private:
109
110 // core components
111 ListenerService* _listenerService;
112 ConsumerManager* _consumerManager;
113
114 // config properties -- do we want to separate these out????
115 Uint32 _port;
116 SSLContext* _sslContext;
117 };
118
119 DynamicListenerRep::DynamicListenerRep(Uint32 portNumber,
120 const String& consumerDir, //consumer mgr
121 const String& consumerConfigDir, //consumer mgr
122 SSLContext* sslContext, //listener svc
123 Boolean enableConsumerUnload, //consumer mgr
124 Uint32 consumerIdleTimeout, //consumer mgr
125 Uint32 shutdownTimeout) : //???
126 _port(portNumber),
127 h.sterling 1.1 _sslContext(sslContext)
128 {
129 PEG_METHOD_ENTER(TRC_LISTENER, "DynamicListenerRep::DynamicListenerRep");
130
131 _consumerManager = new ConsumerManager(consumerDir, consumerConfigDir, enableConsumerUnload, consumerIdleTimeout);
132
133 _listenerService = new ListenerService(_consumerManager);
134
135 PEG_METHOD_EXIT();
136 }
137
138 DynamicListenerRep::~DynamicListenerRep()
139 {
140 PEG_METHOD_ENTER(TRC_LISTENER, "DynamicListenerRep::~DynamicListenerRep");
141
142 if (_consumerManager)
143 delete _consumerManager;
144
145 if (_listenerService)
146 delete _listenerService;
147
148 h.sterling 1.1 PEG_METHOD_EXIT();
149 }
150
151 void DynamicListenerRep::start()
152 {
153 PEG_METHOD_ENTER(TRC_LISTENER, "DynamicListenerRep::start");
154
155 if (_sslContext)
156 {
157 _listenerService->initializeListener(_port, true, _sslContext);
158
159 } else
160 {
161 _listenerService->initializeListener(_port, false, 0);
162 }
163
164 _listenerService->runListener();
165
166 PEG_METHOD_EXIT();
167 }
168
169 h.sterling 1.1 void DynamicListenerRep::stop(Boolean forceShutdown)
170 {
171 PEG_METHOD_ENTER(TRC_LISTENER, "DynamicListenerRep::stop");
172
173 _listenerService->shutdownListener();
174
175 PEG_METHOD_EXIT();
176 }
177
178 Boolean DynamicListenerRep::isAlive()
179 {
180 return _listenerService->isAlive();
181 }
182
183 //TODO:
184 Boolean DynamicListenerRep::addConsumer(const String& consumerName, const String& location)
185 {
186 return true;
187 //return _consumerManager->addConsumer(consumerName, location);
188 }
189
190 h.sterling 1.1 //TODO:
191 Boolean DynamicListenerRep::removeConsumer(const String& consumerName)
192 {
193 return true;
194 //return _consumerManager->unloadConsumer(consumerName);
195 }
196
197 Uint32 DynamicListenerRep::getPortNumber()
198 {
199 return _listenerService->getPortNumber();
200 }
201
202 String DynamicListenerRep::getConsumerDir()
203 {
204 return _consumerManager->getConsumerDir();
205 }
206
207 String DynamicListenerRep::getConsumerConfigDir()
208 {
209 return _consumerManager->getConsumerConfigDir();
210 }
211 h.sterling 1.1
212 Boolean DynamicListenerRep::getEnableConsumerUnload()
213 {
214 return _consumerManager->getEnableConsumerUnload();
215 }
216
217 void DynamicListenerRep::setEnableConsumerUnload(Boolean enableConsumerUnload)
218 {
219 //do nothing for now
220 }
221
222 Uint32 DynamicListenerRep::getIdleTimeout()
223 {
224 return _consumerManager->getIdleTimeout();
225 }
226
227 void DynamicListenerRep::setIdleTimeout(Uint32 idleTimeout)
228 {
229 //do nothing for now
230 }
231
232 h.sterling 1.1
233 /////////////////////////////////////////////////////////////////////////////
234 // DynamicListener
235 /////////////////////////////////////////////////////////////////////////////
236
237 DynamicListener::DynamicListener(Uint32 portNumber,
238 const String& consumerDir,
239 const String& consumerConfigDir,
240 Boolean enableConsumerUnload,
241 Uint32 consumerIdleTimeout,
242 Uint32 shutdownTimeout)
243 {
244 _rep = new DynamicListenerRep(portNumber,
245 consumerDir,
246 consumerConfigDir,
247 0,
248 enableConsumerUnload,
249 consumerIdleTimeout,
250 shutdownTimeout);
251 }
252
253 h.sterling 1.1 #ifdef PEGASUS_HAS_SSL
254 DynamicListener::DynamicListener(Uint32 portNumber,
255 const String& consumerDir,
256 const String& consumerConfigDir,
257 Boolean useSSL,
258 const String& keyPath,
259 const String& certPath,
260 Boolean enableConsumerUnload,
261 Uint32 consumerIdleTimeout,
262 Uint32 shutdownTimeout) //ONLY IF PEGASUS_HAS_SSL
263 {
264 SSLContext* sslContext = 0;
265 if (useSSL)
266 {
267 sslContext = new SSLContext(String::EMPTY, certPath, keyPath, 0, String::EMPTY);//randFile);
268 }
269
270 _rep = new DynamicListenerRep(portNumber,
271 consumerDir,
272 consumerConfigDir,
273 sslContext,
274 h.sterling 1.1 enableConsumerUnload,
275 consumerIdleTimeout,
276 shutdownTimeout);
277 }
278
279 DynamicListener::DynamicListener(Uint32 portNumber,
280 const String& consumerDir,
281 const String& consumerConfigDir,
282 Boolean useSSL,
283 SSLContext* sslContext,
284 Boolean enableConsumerUnload,
285 Uint32 consumerIdleTimeout,
286 Uint32 shutdownTimeout) //ONLY IF PEGASUS_HAS_SSL
287 {
288 _rep = new DynamicListenerRep(portNumber,
289 consumerDir,
290 consumerConfigDir,
291 sslContext,
292 enableConsumerUnload,
293 consumerIdleTimeout,
294 shutdownTimeout);
295 h.sterling 1.1 }
296 #endif
297
298 DynamicListener::~DynamicListener()
299 {
300 if (_rep!=NULL)
301 delete static_cast<DynamicListenerRep*>(_rep);
302
303 _rep=NULL;
304 }
305
306 void DynamicListener::start()
307 {
308 static_cast<DynamicListenerRep*>(_rep)->start();
309 }
310
311 void DynamicListener::stop(Boolean forceShutdown)
312 {
313 static_cast<DynamicListenerRep*>(_rep)->stop(forceShutdown);
314 }
315
316 h.sterling 1.1 Boolean DynamicListener::isAlive()
317 {
318 return static_cast<DynamicListenerRep*>(_rep)->isAlive();
319 }
320
321 Boolean DynamicListener::addConsumer(const String& consumerName, const String& location)
322 {
323 return static_cast<DynamicListenerRep*>(_rep)->addConsumer(consumerName, location);
324 }
325
326 Boolean DynamicListener::removeConsumer(const String& consumerName)
327 {
328 return static_cast<DynamicListenerRep*>(_rep)->removeConsumer(consumerName);
329 }
330
331 Uint32 DynamicListener::getPortNumber()
332 {
333 return static_cast<DynamicListenerRep*>(_rep)->getPortNumber();
334 }
335
336 String DynamicListener::getConsumerDir()
337 h.sterling 1.1 {
338 return static_cast<DynamicListenerRep*>(_rep)->getConsumerDir();
339 }
340
341 String DynamicListener::getConsumerConfigDir()
342 {
343 return static_cast<DynamicListenerRep*>(_rep)->getConsumerConfigDir();
344 }
345
346 void DynamicListener::setEnableConsumerUnload(const Boolean consumerUnload)
347 {
348 static_cast<DynamicListenerRep*>(_rep)->setEnableConsumerUnload(consumerUnload);
349 }
350
351 Boolean DynamicListener::getEnableConsumerUnload()
352 {
353 return static_cast<DynamicListenerRep*>(_rep)->getEnableConsumerUnload();
354 }
355
356 Uint32 DynamicListener::getIdleTimeout()
357 {
358 h.sterling 1.1 return static_cast<DynamicListenerRep*>(_rep)->getIdleTimeout();
359 }
360
361 void DynamicListener::setIdleTimeout(Uint32 idleTimeout)
362 {
363 static_cast<DynamicListenerRep*>(_rep)->setIdleTimeout(idleTimeout);
364 }
365
366
367 PEGASUS_NAMESPACE_END
368
|
Return to
DynamicListener.cpp
CVS log
Up to [Pegasus] / pegasus / src / Pegasus / DynListener