PEP # ?: Pegasus CIMOMHandle |
Type | Status | Approveers |
---|---|---|
Architecture | Draft | Pegasus architecture team |
Version | Date | Author | Comments |
---|---|---|---|
1.0 | Thu Feb 13 11:58:12 2003 | Mike Day | initial submission |
The CIMOMHandle in Pegasus is the object that providers must use to gain access to Pegasus services including the repository and other providers. A functioning CIMOMHandle is necessary for association support.
The CIMOMhandle also serves a useful role for asynchronous providers in that it facilitates communication of status between Pegasus and its providers. For example, some providers must always remain loaded, or must ensure they are not unloaded during a critical or time consuming operation. They need the CIMOMHandle to indicate this status back to Pegasus.
The CIMOMHandle in Pegasus does not work right now. This document proposes a redesign of the CIMOMHandle to ensure it works and fulfills present and future requirements.
Pegasus requires the CIMOMHandle to provide the following facilities:
This document proposes adding a new Server component to Pegasus that acts as a binary request encoder/decoder. The CIMOMHandle presents providers with what is logically a CIMClient interface. However, instead of generating CIM/XML operations, the CIMOMHandle enqueues binary CIMRequest/Response messages to the new Server component.
The new Server component fulfills the role of both request decoder and response encoder. Except that it does not encode/decode; it only passes the preformed messages through the normal execution path and forwards the response back to the CIMOMHandle.
CIMOMHandle client requests originate as CIMMessage objects. They don't need to be decoded. They follow the exact same processing path as decoded client operations.
Responses to CIMOMHandle operations follow the exact same processing paths as Client responses, up to the encoding step. Instead of being encoded and transmitted, they are enqueued back to the CIMOMhandle. The CIMOMHandle marshals the response data and returns from the method call back to the provider.
The advantages to this proposal include the following:
The alternative I considered was to use the CIMClient class to invoke the client interface from the CIMOMHandle. However, this approach has the following disadvantages:
This proposal is already implemented. Source code is included at the end of this document. It can be committed to the head of the repository immediately upon acceptance by the Architecture Team.
To Mimimize risk, I have already implemented and tested this proposal in the mday-2-0-patches branch of the CVS repository.
1 //%///-*-c++-*-///////////////////////////////////////////////////////////////// 2 // 3 // Copyright (c) 2000, 2001, 2002 BMC Software, Hewlett-Packard Company, IBM, 4 // The Open Group, Tivoli Systems 5 // 6 // Permission is hereby granted, free of charge, to any person obtaining a copy 7 // of this software and associated documentation files (the "Software"), to 8 // deal in the Software without restriction, including without limitation the 9 // rights to use, copy, modify, merge, publish, distribute, sublicense, and/or 10 // sell copies of the Software, and to permit persons to whom the Software is 11 // furnished to do so, subject to the following conditions: 12 // 13 // THE ABOVE COPYRIGHT NOTICE AND THIS PERMISSION NOTICE SHALL BE INCLUDED IN 14 // ALL COPIES OR SUBSTANTIAL PORTIONS OF THE SOFTWARE. THE SOFTWARE IS PROVIDED 15 // "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT 16 // LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR 17 // PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT 18 // HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN 19 // ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION 20 // WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. 21 // 22 //============================================================================== 23 // 24 // Author: Chip Vincent (cvincent@us.ibm.com) 25 // 26 // Modified By: Mike Brasher (mbrasher@bmc.com) 27 // Yi Zhou, Hewlett-Packard Company (yi_zhou@hp.com) 28 // Roger Kumpf, Hewlett-Packard Company (roger_kumpf@hp.com) 29 // Mike Day, IBM (mdday@us.ibm.com) 30 // 31 //%///////////////////////////////////////////////////////////////////////////// 32 33 34 #ifndef Pegasus_CIMOMHandle_h 35 #define Pegasus_CIMOMHandle_h 36 37 #include <Pegasus/Common/Config.h> 38 #include <Pegasus/Common/ModuleController.h> 39 #include <Pegasus/Common/OperationContext.h> 40 #include <Pegasus/Common/CIMObject.h> 41 #include <Pegasus/Common/CIMObjectPath.h> 42 #include <Pegasus/Common/CIMClass.h> 43 #include <Pegasus/Common/CIMInstance.h> 44 #include <Pegasus/Common/CIMPropertyList.h> 45 #include <Pegasus/Common/ResponseHandler.h> 46 #include "Linkage.h" 47 48 PEGASUS_NAMESPACE_BEGIN 49 50 class ProviderManager; 51 class Provider; 52 53 class cimom_handle_op_semaphore; 54 class PEGASUS_PROVIDER_LINKAGE CIMOMHandle 55 { 56 57 public: 58 59 /** */ 60 CIMOMHandle(void); 61 CIMOMHandle(const CIMOMHandle &); 62 63 /** */ 64 virtual ~CIMOMHandle(void); 65 66 CIMOMHandle & operator=(const CIMOMHandle & handle); 67 68 virtual CIMClass getClass( 69 const OperationContext & context, 70 const CIMNamespaceName& nameSpace, 71 const CIMName& className, 72 Boolean localOnly, 73 Boolean includeQualifiers, 74 Boolean includeClassOrigin, 75 const CIMPropertyList& propertyList); 76 77 virtual void getClassAsync( 78 const OperationContext & context, 79 const CIMNamespaceName& nameSpace, 80 const CIMName& className, 81 Boolean localOnly, 82 Boolean includeQualifiers, 83 Boolean includeClassOrigin, 84 const CIMPropertyList& propertyList, 85 ClassResponseHandler & handler); 86 87 virtual Array<CIMClass> enumerateClasses( 88 const OperationContext & context, 89 const CIMNamespaceName& nameSpace, 90 const CIMName& className, 91 Boolean deepInheritance, 92 Boolean localOnly, 93 Boolean includeQualifiers, 94 Boolean includeClassOrigin); 95 96 virtual void enumerateClassesAsync( 97 const OperationContext & context, 98 const CIMNamespaceName& nameSpace, 99 const CIMName& className, 100 Boolean deepInheritance, 101 Boolean localOnly, 102 Boolean includeQualifiers, 103 Boolean includeClassOrigin, 104 ClassResponseHandler & handler); 105 106 virtual Array<CIMName> enumerateClassNames( 107 const OperationContext & context, 108 const CIMNamespaceName& nameSpace, 109 const CIMName& className, 110 Boolean deepInheritance); 111 112 virtual void enumerateClassNamesAsync( 113 const OperationContext & context, 114 const CIMNamespaceName& nameSpace, 115 const CIMName& className, 116 Boolean deepInheritance, 117 ObjectPathResponseHandler & handler); 118 119 virtual void createClass( 120 const OperationContext & context, 121 const CIMNamespaceName& nameSpace, 122 const CIMClass& newClass); 123 124 virtual void createClassAsync( 125 const OperationContext & context, 126 const CIMNamespaceName& nameSpace, 127 const CIMClass& newClass, 128 ResponseHandler & handler); 129 130 virtual void modifyClass( 131 const OperationContext & context, 132 const CIMNamespaceName& nameSpace, 133 const CIMClass& modifiedClass); 134 135 virtual void modifyClassAsync( 136 const OperationContext & context, 137 const CIMNamespaceName& nameSpace, 138 const CIMClass& modifiedClass, 139 ResponseHandler& handler); 140 141 virtual void deleteClass( 142 const OperationContext & context, 143 const CIMNamespaceName& nameSpace, 144 const CIMName& className); 145 146 virtual void deleteClassAsync( 147 const OperationContext & context, 148 const CIMNamespaceName& nameSpace, 149 const CIMName& className, 150 ResponseHandler & handler); 151 152 virtual CIMInstance getInstance( 153 const OperationContext & context, 154 const CIMNamespaceName& nameSpace, 155 const CIMObjectPath& instanceName, 156 Boolean localOnly, 157 Boolean includeQualifiers, 158 Boolean includeClassOrigin, 159 const CIMPropertyList& propertyList); 160 161 virtual void getInstanceAsync( 162 const OperationContext & context, 163 const CIMNamespaceName& nameSpace, 164 const CIMObjectPath& instanceName, 165 Boolean localOnly, 166 Boolean includeQualifiers, 167 Boolean includeClassOrigin, 168 const CIMPropertyList& propertyList, 169 InstanceResponseHandler & handler); 170 171 virtual Array<CIMInstance> enumerateInstances( 172 const OperationContext & context, 173 const CIMNamespaceName& nameSpace, 174 const CIMName& className, 175 Boolean deepInheritance, 176 Boolean localOnly, 177 Boolean includeQualifiers, 178 Boolean includeClassOrigin, 179 const CIMPropertyList& propertyList); 180 181 virtual void enumerateInstancesAsync( 182 const OperationContext & context, 183 const CIMNamespaceName& nameSpace, 184 const CIMName& className, 185 Boolean deepInheritance, 186 Boolean localOnly, 187 Boolean includeQualifiers, 188 Boolean includeClassOrigin, 189 const CIMPropertyList& propertyList, 190 InstanceResponseHandler & handler); 191 192 virtual Array<CIMObjectPath> enumerateInstanceNames( 193 const OperationContext & context, 194 const CIMNamespaceName& nameSpace, 195 const CIMName& className); 196 197 virtual void enumerateInstanceNamesAsync( 198 const OperationContext & context, 199 const CIMNamespaceName& nameSpace, 200 const CIMName& className, 201 ObjectPathResponseHandler & handler); 202 203 virtual CIMObjectPath createInstance( 204 const OperationContext & context, 205 const CIMNamespaceName& nameSpace, 206 const CIMInstance& newInstance); 207 208 virtual void createInstanceAsync( 209 const OperationContext & context, 210 const CIMNamespaceName& nameSpace, 211 const CIMInstance& newInstance, 212 ResponseHandler& handler); 213 214 virtual void modifyInstance( 215 const OperationContext & context, 216 const CIMNamespaceName& nameSpace, 217 const CIMInstance& modifiedInstance, 218 Boolean includeQualifiers, 219 const CIMPropertyList& propertyList); 220 221 virtual void modifyInstanceAsync( 222 const OperationContext & context, 223 const CIMNamespaceName& nameSpace, 224 const CIMInstance& modifiedInstance, 225 Boolean includeQualifiers, 226 const CIMPropertyList& propertyList, 227 ResponseHandler& handler); 228 229 virtual void deleteInstance( 230 const OperationContext & context, 231 const CIMNamespaceName& nameSpace, 232 const CIMObjectPath& instanceName); 233 234 virtual void deleteInstanceAsync( 235 const OperationContext & context, 236 const CIMNamespaceName& nameSpace, 237 const CIMObjectPath& instanceName, 238 ResponseHandler& handler); 239 240 virtual Array<CIMObject> execQuery( 241 const OperationContext & context, 242 const CIMNamespaceName& nameSpace, 243 const String& queryLanguage, 244 const String& query); 245 246 virtual void execQueryAsync( 247 const OperationContext & context, 248 const CIMNamespaceName& nameSpace, 249 const String& queryLanguage, 250 const String& query, 251 ObjectResponseHandler & handler); 252 253 virtual Array<CIMObject> associators( 254 const OperationContext & context, 255 const CIMNamespaceName& nameSpace, 256 const CIMObjectPath& objectName, 257 const String& assocClass, 258 const String& resultClass, 259 const String& role, 260 const String& resultRole, 261 Boolean includeQualifiers, 262 Boolean includeClassOrigin, 263 const CIMPropertyList& propertyList); 264 265 virtual void associatorsAsync( 266 const OperationContext & context, 267 const CIMNamespaceName& nameSpace, 268 const CIMObjectPath& objectName, 269 const String& assocClass, 270 const String& resultClass, 271 const String& role, 272 const String& resultRole, 273 Boolean includeQualifiers, 274 Boolean includeClassOrigin, 275 const CIMPropertyList& propertyList, 276 ObjectResponseHandler & handler); 277 278 virtual Array<CIMObjectPath> associatorNames( 279 const OperationContext & context, 280 const CIMNamespaceName& nameSpace, 281 const CIMObjectPath& objectName, 282 const String& assocClass, 283 const String& resultClass, 284 const String& role, 285 const String& resultRole); 286 287 virtual void associatorNamesAsync( 288 const OperationContext & context, 289 const CIMNamespaceName& nameSpace, 290 const CIMObjectPath& objectName, 291 const String& assocClass, 292 const String& resultClass, 293 const String& role, 294 const String& resultRole, 295 ObjectPathResponseHandler & handler); 296 297 virtual Array<CIMObject> references( 298 const OperationContext & context, 299 const CIMNamespaceName& nameSpace, 300 const CIMObjectPath& objectName, 301 const String& resultClass, 302 const String& role, 303 Boolean includeQualifiers, 304 Boolean includeClassOrigin, 305 const CIMPropertyList& propertyList); 306 307 virtual void referencesAsync( 308 const OperationContext & context, 309 const CIMNamespaceName& nameSpace, 310 const CIMObjectPath& objectName, 311 const String& resultClass, 312 const String& role, 313 Boolean includeQualifiers, 314 Boolean includeClassOrigin, 315 const CIMPropertyList& propertyList, 316 ObjectResponseHandler & handler); 317 318 virtual Array<CIMObjectPath> referenceNames( 319 const OperationContext & context, 320 const CIMNamespaceName& nameSpace, 321 const CIMObjectPath& objectName, 322 const String& resultClass, 323 const String& role); 324 325 virtual void referenceNamesAsync( 326 const OperationContext & context, 327 const CIMNamespaceName& nameSpace, 328 const CIMObjectPath& objectName, 329 const String& resultClass, 330 const String& role, 331 ObjectPathResponseHandler& handler); 332 333 // property operations 334 virtual CIMValue getProperty( 335 const OperationContext & context, 336 const CIMNamespaceName& nameSpace, 337 const CIMObjectPath& instanceName, 338 const String& propertyName); 339 340 virtual void getPropertyAsync( 341 const OperationContext & context, 342 const CIMNamespaceName& nameSpace, 343 const CIMObjectPath& instanceName, 344 const String& propertyName, 345 ValueResponseHandler & handler); 346 347 virtual void setProperty( 348 const OperationContext & context, 349 const CIMNamespaceName& nameSpace, 350 const CIMObjectPath& instanceName, 351 const String& propertyName, 352 const CIMValue& newValue); 353 354 virtual void setPropertyAsync( 355 const OperationContext & context, 356 const CIMNamespaceName& nameSpace, 357 const CIMObjectPath& instanceName, 358 const String& propertyName, 359 const CIMValue& newValue, 360 ValueResponseHandler& handler); 361 362 virtual void get_idle_timer(struct timeval *); 363 virtual void update_idle_timer(void); 364 virtual Uint32 get_operation_timeout(void); 365 virtual void set_operation_timeout(Uint32); 366 virtual Boolean pending_operation(void); 367 virtual Boolean unload_ok(void); 368 369 virtual Uint32 get_output_qid(void); 370 virtual void set_output_qid(Uint32); 371 virtual Uint32 get_return_qid(void); 372 virtual void set_return_qid(Uint32); 373 374 // force provider manager to keep in memory 375 virtual void protect(void); 376 // allow provider manager to unload when idle 377 virtual void unprotect(void); 378 379 // virtual CIMValue invokeMethod( 380 // const OperationContext & context, 381 // const CIMNamespaceName& nameSpace, 382 // const CIMObjectPath& instanceName, 383 // const String& methodName, 384 // const Array<CIMParamValue>& inParameters, 385 // Array<CIMParamValue>& outParameters); 386 387 // virtual void invokeMethodAsync( 388 // const OperationContext & context, 389 // const CIMNamespaceName& nameSpace, 390 // const CIMObjectPath& instanceName, 391 // const String& methodName, 392 // const Array<CIMParamValue>& inParameters, 393 // Array<CIMParamValue>& outParameters, 394 // ResponseHandler<CIMValue> & handler); 395 396 397 // static void async_callback(Uint32 user_data, Message *reply, void *parm); 398 399 400 class _cimom_handle_rep; 401 _cimom_handle_rep *_rep; 402 private: 403 friend class Provider; 404 friend class cimom_handle_op_semaphore; 405 406 }; 407 408 409 410 411 412 PEGASUS_NAMESPACE_END 413 414 #endif
1 //%///////////////////////////////////////////////////////////////////////////// 2 // 3 // Copyright (c) 2000, 2001, 2002 BMC Software, Hewlett-Packard Company, IBM, 4 // The Open Group, Tivoli Systems 5 // 6 // Permission is hereby granted, free of charge, to any person obtaining a copy 7 // of this software and associated documentation files (the "Software"), to 8 // deal in the Software without restriction, including without limitation the 9 // rights to use, copy, modify, merge, publish, distribute, sublicense, and/or 10 // sell copies of the Software, and to permit persons to whom the Software is 11 // furnished to do so, subject to the following conditions: 12 // 13 // THE ABOVE COPYRIGHT NOTICE AND THIS PERMISSION NOTICE SHALL BE INCLUDED IN 14 // ALL COPIES OR SUBSTANTIAL PORTIONS OF THE SOFTWARE. THE SOFTWARE IS PROVIDED 15 // "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT 16 // LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR 17 // PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT 18 // HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN 19 // ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION 20 // WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. 21 // 22 //============================================================================== 23 // 24 // Author: Chip Vincent (cvincent@us.ibm.com) 25 // 26 // Modified By: Carol Ann Krug Graves, Hewlett-Packard Company 27 // (carolann_graves@hp.com) 28 // Mike Day, IBM (mdday@us.ibm.com) 29 // 30 //%///////////////////////////////////////////////////////////////////////////// 31 32 #include "CIMOMHandle.h" 33 #include <Pegasus/Common/Constants.h> 34 #include <Pegasus/Common/XmlWriter.h> 35 #include <Pegasus/Common/Message.h> 36 #include <Pegasus/Common/Exception.h> 37 #include <Pegasus/Common/IPC.h> 38 #include <Pegasus/Common/Thread.h> 39 #include <Pegasus/Common/AsyncOpNode.h> 40 #include <Pegasus/Common/DQueue.h> 41 #include <Pegasus/Common/Cimom.h> 42 #include <Pegasus/Common/CimomMessage.h> 43 #include <Pegasus/Common/MessageQueueService.h> 44 #include <Pegasus/Common/peg_authorization.h> 45 #include <Pegasus/Common/CIMMessage.h> 46 #include <Pegasus/Common/Destroyer.h> 47 #include <Pegasus/Common/System.h> 48 #include <Pegasus/Common/TraceComponents.h> 49 #include <Pegasus/Common/Tracer.h> 50 #include <Pegasus/Common/Sharable.h> 51 52 PEGASUS_NAMESPACE_BEGIN 53 54 55 //ThreadPool *MessageQueueService::get_thread_pool(void); 56 57 58 class CIMOMHandle; 59 class cimom_handle_op_semaphore; 60 class CIMOMHandle::_cimom_handle_rep : public MessageQueue, public Sharable 61 { 62 private: 63 Uint32 _output_qid; 64 Uint32 _return_qid; 65 AtomicInt _response_type; 66 Mutex _recursion; 67 Mutex _idle_mutex; 68 Mutex _qid_mutex; 69 70 AtomicInt _server_terminating; 71 Semaphore _msg_avail; 72 AsyncDQueue<Message> _response; 73 Message *_request; 74 AtomicInt _op_timeout; 75 AtomicInt _pending_operation; 76 AtomicInt _no_unload; 77 struct timeval _idle_timeout; 78 79 public: 80 typedef MessageQueue Base; 81 82 _cimom_handle_rep(void); 83 _cimom_handle_rep(Uint32 out_qid, Uint32 ret_qid); 84 ~_cimom_handle_rep(void) { } 85 private: 86 void get_idle_timer(struct timeval *); 87 void update_idle_timer(void); 88 Uint32 get_operation_timeout(void); 89 void set_operation_timeout(Uint32); 90 Boolean pending_operation(void); 91 Boolean unload_ok(void); 92 93 Uint32 get_output_qid(void); 94 void set_output_qid(Uint32); 95 Uint32 get_return_qid(void); 96 void set_return_qid(Uint32); 97 Uint32 get_qid(void); 98 99 void protect(void); 100 void unprotect(void); 101 102 virtual void handleEnqueue(Message *); 103 virtual void handleEnqueue(void); 104 105 Message *do_request(Message *, Uint32 response_type, Uint32 timeout) 106 throw(); 107 108 static PEGASUS_THREAD_RETURN PEGASUS_THREAD_CDECL _dispatch(void *); 109 MessageQueue * q_exists(Uint32 qid) const 110 { 111 return MessageQueue::lookup(qid); 112 } 113 114 _cimom_handle_rep & operator = (const _cimom_handle_rep & ); 115 friend class CIMOMHandle; 116 friend class cimom_handle_op_semaphore; 117 }; 118 119 class cimom_handle_op_semaphore 120 { 121 private: 122 cimom_handle_op_semaphore(void) 123 { 124 } 125 126 public: 127 cimom_handle_op_semaphore(CIMOMHandle::_cimom_handle_rep *rep) 128 :_rep(rep) 129 { 130 _rep->update_idle_timer(); 131 (_rep->_pending_operation)++; 132 } 133 ~cimom_handle_op_semaphore(void) 134 { 135 if(_rep) 136 { 137 (_rep->_pending_operation)--; 138 } 139 } 140 private: 141 CIMOMHandle::_cimom_handle_rep *_rep; 142 }; 143 144 145 class cimom_handle_dispatch 146 { 147 private: 148 cimom_handle_dispatch(void); 149 public: 150 cimom_handle_dispatch(Message *msg, 151 Uint32 my_qid, 152 Uint32 output_qid) 153 : _msg(msg), 154 _my_qid(my_qid), 155 _out_qid(output_qid) 156 { 157 } 158 ~cimom_handle_dispatch(void) 159 { 160 } 161 162 163 Message *_msg; 164 Uint32 _my_qid; 165 Uint32 _out_qid; 166 }; 167 168 169 170 CIMOMHandle::_cimom_handle_rep::_cimom_handle_rep(void) 171 : Base(PEGASUS_QUEUENAME_INTERNALCLIENT), 172 _server_terminating(0), 173 _msg_avail(0), 174 _response(true,0), 175 _op_timeout(0), 176 _pending_operation(0), 177 _no_unload(0) 178 { 179 // initialize the qids 180 // output queue defaults to CIMOPRequestDispatcher 181 MessageQueue *out = MessageQueue::lookup(PEGASUS_QUEUENAME_BINARY_HANDLER); 182 if(out) 183 _output_qid = out->getQueueId(); 184 else 185 _output_qid = _queueId; 186 187 // return queue defaults to myself 188 _return_qid = _queueId; 189 gettimeofday(&_idle_timeout, NULL); 190 191 } 192 193 CIMOMHandle::_cimom_handle_rep::_cimom_handle_rep(Uint32 out_qid, Uint32 ret_qid) 194 : Base(PEGASUS_QUEUENAME_INTERNALCLIENT), 195 _output_qid(out_qid), 196 _return_qid(ret_qid), 197 _server_terminating(0), 198 _msg_avail(0), 199 _response(true,0), 200 _op_timeout(0), 201 _pending_operation(0), 202 _no_unload(0) 203 { 204 if(0 == q_exists(_output_qid) ) 205 _output_qid = _queueId; 206 if(0 == q_exists(_return_qid) ) 207 _return_qid = _queueId; 208 gettimeofday(&_idle_timeout, NULL); 209 } 210 211 void CIMOMHandle::_cimom_handle_rep::get_idle_timer(struct timeval *tv) 212 { 213 if(tv == 0) 214 return; 215 216 try 217 { 218 _idle_mutex.lock(pegasus_thread_self()); 219 memcpy(tv, &_idle_timeout, sizeof(struct timeval)); 220 _idle_mutex.unlock(); 221 } 222 catch(...) 223 { 224 gettimeofday(tv, NULL); 225 } 226 } 227 228 void CIMOMHandle::_cimom_handle_rep::update_idle_timer(void) 229 { 230 try 231 { 232 _idle_mutex.lock(pegasus_thread_self()); 233 gettimeofday(&_idle_timeout, NULL); 234 _idle_mutex.unlock(); 235 } 236 catch(...) 237 { 238 } 239 } 240 241 Uint32 CIMOMHandle::_cimom_handle_rep::get_operation_timeout(void) 242 { 243 return _op_timeout.value(); 244 } 245 246 void CIMOMHandle::_cimom_handle_rep::set_operation_timeout(Uint32 t) 247 { 248 _op_timeout = t; 249 } 250 251 Boolean CIMOMHandle::_cimom_handle_rep::pending_operation(void) 252 { 253 if(_pending_operation.value()) 254 return true; 255 return false; 256 } 257 258 Boolean CIMOMHandle::_cimom_handle_rep::unload_ok(void) 259 { 260 if( _no_unload.value() || _pending_operation.value() ) 261 return false; 262 return true; 263 } 264 265 Uint32 CIMOMHandle::_cimom_handle_rep::get_output_qid(void) 266 { 267 try 268 { 269 _qid_mutex.lock(pegasus_thread_self()); 270 Uint32 qid = _output_qid; 271 _qid_mutex.unlock(); 272 return qid; 273 } 274 catch(...) 275 { 276 return _queueId; 277 } 278 } 279 280 void CIMOMHandle::_cimom_handle_rep::set_output_qid(Uint32 qid) 281 { 282 try 283 { 284 _qid_mutex.lock(pegasus_thread_self()); 285 _output_qid = qid; 286 _qid_mutex.unlock(); 287 } 288 catch(...) 289 { 290 } 291 } 292 293 Uint32 CIMOMHandle::_cimom_handle_rep::get_return_qid(void) 294 { 295 try 296 { 297 _qid_mutex.lock(pegasus_thread_self()); 298 Uint32 qid = _return_qid; 299 _qid_mutex.unlock(); 300 return qid; 301 } 302 catch(...) 303 { 304 return _queueId; 305 } 306 } 307 308 void CIMOMHandle::_cimom_handle_rep::set_return_qid(Uint32 qid) 309 { 310 try 311 { 312 _qid_mutex.lock(pegasus_thread_self()); 313 _return_qid = qid; 314 _qid_mutex.unlock(); 315 } 316 catch(...) 317 { 318 } 319 } 320 321 Uint32 CIMOMHandle::_cimom_handle_rep::get_qid(void) 322 { 323 return _queueId; 324 } 325 326 void CIMOMHandle::_cimom_handle_rep::protect(void) 327 { 328 _no_unload++; 329 } 330 331 void CIMOMHandle::_cimom_handle_rep::unprotect(void) 332 { 333 _no_unload--; 334 } 335 336 void CIMOMHandle::_cimom_handle_rep::handleEnqueue(void) 337 { 338 PEG_METHOD_ENTER(TRC_CIMOM_HANDLE, 339 "CIMOMHandle::_cimom_handle_rep::handleEnqueue(Message *)"); 340 341 Message *message = dequeue(); 342 343 if (!message) 344 { 345 PEG_METHOD_EXIT(); 346 return; 347 } 348 349 handleEnqueue(message); 350 PEG_METHOD_EXIT(); 351 } 352 353 void CIMOMHandle::_cimom_handle_rep::handleEnqueue(Message *message) 354 { 355 PEG_METHOD_ENTER(TRC_CIMOM_HANDLE, 356 "CIMOMHandle::_cimom_handle_rep::handleEnqueue(Message *)"); 357 if (!message) 358 { 359 PEG_METHOD_EXIT(); 360 return; 361 } 362 363 switch(message->getType()) 364 { 365 case CIM_GET_CLASS_RESPONSE_MESSAGE: 366 case CIM_ENUMERATE_CLASSES_RESPONSE_MESSAGE: 367 case CIM_ENUMERATE_CLASS_NAMES_RESPONSE_MESSAGE: 368 case CIM_CREATE_CLASS_RESPONSE_MESSAGE: 369 case CIM_MODIFY_CLASS_RESPONSE_MESSAGE: 370 case CIM_DELETE_CLASS_RESPONSE_MESSAGE: 371 case CIM_GET_INSTANCE_RESPONSE_MESSAGE: 372 case CIM_ENUMERATE_INSTANCES_RESPONSE_MESSAGE: 373 case CIM_ENUMERATE_INSTANCE_NAMES_RESPONSE_MESSAGE: 374 case CIM_CREATE_INSTANCE_RESPONSE_MESSAGE: 375 case CIM_MODIFY_INSTANCE_RESPONSE_MESSAGE: 376 case CIM_DELETE_INSTANCE_RESPONSE_MESSAGE: 377 case CIM_EXEC_QUERY_RESPONSE_MESSAGE: 378 case CIM_ASSOCIATORS_RESPONSE_MESSAGE: 379 case CIM_ASSOCIATOR_NAMES_RESPONSE_MESSAGE: 380 case CIM_REFERENCES_RESPONSE_MESSAGE: 381 case CIM_REFERENCE_NAMES_RESPONSE_MESSAGE: 382 case CIM_GET_PROPERTY_RESPONSE_MESSAGE: 383 case CIM_SET_PROPERTY_RESPONSE_MESSAGE: 384 try 385 { 386 _response.insert_last_wait(message); 387 _msg_avail.signal(); 388 } 389 catch(...) 390 { 391 PEG_METHOD_ENTER(TRC_CIMOM_HANDLE, 392 "CIMOMHandle::_cimom_handle_rep::handleEnqueue(Message *) - IPC Exception"); 393 delete message; 394 } 395 break; 396 397 default: 398 { 399 PEG_METHOD_ENTER(TRC_CIMOM_HANDLE, 400 "CIMOMHandle::_cimom_handle_rep::handleEnqueue(Message *) - unexpected message"); 401 delete message; 402 } 403 } 404 PEG_METHOD_EXIT(); 405 } 406 407 // run as a detached thread 408 PEGASUS_THREAD_RETURN PEGASUS_THREAD_CDECL 409 CIMOMHandle::_cimom_handle_rep::_dispatch(void *parm) 410 { 411 // Thread *th_dp = reinterpret_cast<Thread *>(parm); 412 413 PEG_METHOD_ENTER(TRC_CIMOM_HANDLE, 414 "CIMOMHandle::_cimom_handle_rep::_dispatch(void *)"); 415 416 cimom_handle_dispatch *dp = 417 reinterpret_cast<cimom_handle_dispatch *>(parm); 418 if(dp ) 419 { 420 try 421 { 422 MessageQueue * target = MessageQueue::lookup(dp->_out_qid); 423 MessageQueue *me = MessageQueue::lookup(dp->_my_qid); 424 if(me && target && dp->_msg) 425 { 426 CIMOMHandle::_cimom_handle_rep *myself = 427 static_cast<CIMOMHandle::_cimom_handle_rep *>(me); 428 target->enqueue(dp->_msg); 429 } 430 } 431 catch(...) 432 { 433 } 434 delete dp; 435 } 436 437 PEG_METHOD_EXIT(); 438 // exit_thread((PEGASUS_THREAD_RETURN)1); 439 return 0; 440 } 441 442 Message *CIMOMHandle::_cimom_handle_rep::do_request(Message *request, 443 Uint32 response_type, 444 Uint32 timeout) 445 throw() 446 { 447 PEG_METHOD_ENTER(TRC_CIMOM_HANDLE, 448 "CIMOMHandle::_cimom_handle_rep::do_request(Message *, Uint32, Uint32)"); 449 450 try 451 { 452 _recursion.try_lock(pegasus_thread_self()); 453 } 454 catch(AlreadyLocked & ) 455 { 456 PEG_TRACE_STRING(TRC_CIMOM_HANDLE, Tracer::LEVEL4, 457 "AlreadyLocked Exception, throwing Deadlock"); 458 throw Deadlock(pegasus_thread_self()); 459 } 460 catch(Deadlock & ) 461 { 462 PEG_TRACE_STRING(TRC_CIMOM_HANDLE, Tracer::LEVEL4, 463 "Deadlock Exception"); 464 throw; 465 } 466 catch(...) 467 { 468 PEG_TRACE_STRING(TRC_CIMOM_HANDLE, Tracer::LEVEL4, 469 "Unexpected Exception"); 470 throw; 471 } 472 cimom_handle_dispatch *dp = 473 new cimom_handle_dispatch(request, get_qid(), get_output_qid()); 474 475 MessageQueueService::get_thread_pool()->allocate_and_awaken(dp, _dispatch); 476 477 _request = request; 478 479 Message *response = 0; 480 481 try 482 { 483 if(timeout) 484 _msg_avail.time_wait(timeout); 485 else 486 _msg_avail.wait(); 487 } 488 catch(TimeOut) 489 { 490 PEG_TRACE_STRING(TRC_CIMOM_HANDLE, Tracer::LEVEL4, 491 "timeout waiting for response"); 492 _request = 0; 493 PEG_METHOD_EXIT(); 494 _recursion.unlock(); 495 return 0; 496 } 497 catch(...) 498 { 499 PEG_TRACE_STRING(TRC_CIMOM_HANDLE, Tracer::LEVEL4, 500 "Unexpected Exception"); 501 _request = 0; 502 PEG_METHOD_EXIT(); 503 _recursion.unlock(); 504 return 0; 505 } 506 507 response = _response.remove_first(); 508 if(response && response->getRouting() != request->getRouting() || (response->getType() != response_type)) 509 { 510 PEG_TRACE_STRING(TRC_CIMOM_HANDLE, Tracer::LEVEL4, 511 "Unexpected Message Instance"); 512 response = 0; 513 try 514 { 515 _response.empty_list(); 516 } 517 catch(...) 518 { 519 } 520 } 521 _request = 0; 522 523 PEG_METHOD_EXIT(); 524 _recursion.unlock(); 525 return response; 526 } 527 528 CIMOMHandle::CIMOMHandle(void) 529 { 530 _rep = new _cimom_handle_rep(); 531 532 } 533 534 CIMOMHandle::CIMOMHandle(const CIMOMHandle & h) 535 { 536 if(this != &h) 537 { 538 Inc(this->_rep = h._rep); 539 } 540 541 } 542 543 CIMOMHandle::~CIMOMHandle(void) 544 { 545 Dec(_rep); 546 } 547 548 CIMOMHandle & CIMOMHandle::operator=(const CIMOMHandle & handle) 549 { 550 if(this != &handle) 551 { 552 Inc(_rep = handle._rep); 553 } 554 return *this; 555 } 556 557 558 CIMClass CIMOMHandle::getClass( 559 const OperationContext & context, 560 const CIMNamespaceName& nameSpace, 561 const CIMName& className, 562 Boolean localOnly, 563 Boolean includeQualifiers, 564 Boolean includeClassOrigin, 565 const CIMPropertyList& propertyList) 566 { 567 568 PEG_METHOD_ENTER(TRC_CIMOM_HANDLE, "CIMOMHandle::getClass()"); 569 cimom_handle_op_semaphore opsem(_rep); 570 571 // encode request 572 CIMGetClassRequestMessage * request = 573 new CIMGetClassRequestMessage( 574 XmlWriter::getNextMessageId(), 575 nameSpace, 576 className, 577 localOnly, 578 includeQualifiers, 579 includeClassOrigin, 580 propertyList, 581 QueueIdStack(_rep->get_qid(), _rep->get_output_qid())); 582 583 request->dest = _rep->get_output_qid(); 584 585 CIMGetClassResponseMessage * response; 586 try 587 { 588 response = 589 static_cast<CIMGetClassResponseMessage *>( 590 _rep->do_request(request, 591 CIM_GET_CLASS_RESPONSE_MESSAGE, 592 _rep->get_operation_timeout())); 593 } 594 catch(Exception & ) 595 { 596 PEG_TRACE_STRING(TRC_CIMOM_HANDLE, Tracer::LEVEL4, 597 "Exception caught in CIMOMHandle"); 598 response = 0; 599 } 600 catch(...) 601 { 602 PEG_TRACE_STRING(TRC_CIMOM_HANDLE, Tracer::LEVEL4, 603 "Unexpected Exception caught in CIMOMHandle"); 604 response = 0; 605 } 606 607 CIMClass cimClass; 608 609 if(response != 0) 610 { 611 cimClass = response->cimClass; 612 } 613 614 delete response; 615 616 PEG_METHOD_EXIT(); 617 return cimClass; 618 } 619 620 void CIMOMHandle::getClassAsync( 621 const OperationContext & context, 622 const CIMNamespaceName& nameSpace, 623 const CIMName& className, 624 Boolean localOnly, 625 Boolean includeQualifiers, 626 Boolean includeClassOrigin, 627 const CIMPropertyList& propertyList, 628 ClassResponseHandler & handler) 629 { 630 throw CIMException(CIM_ERR_NOT_SUPPORTED); 631 } 632 633 634 Array<CIMClass> CIMOMHandle::enumerateClasses( 635 const OperationContext & context, 636 const CIMNamespaceName& nameSpace, 637 const CIMName& className, 638 Boolean deepInheritance, 639 Boolean localOnly, 640 Boolean includeQualifiers, 641 Boolean includeClassOrigin) 642 { 643 PEG_METHOD_ENTER(TRC_CIMOM_HANDLE, "CIMOMHandle::enumerateClasses()"); 644 cimom_handle_op_semaphore opsem(_rep); 645 646 CIMEnumerateClassesRequestMessage * request = 647 new CIMEnumerateClassesRequestMessage( 648 XmlWriter::getNextMessageId(), 649 nameSpace, 650 className, 651 deepInheritance, 652 localOnly, 653 includeQualifiers, 654 includeClassOrigin, 655 QueueIdStack(_rep->get_qid(), _rep->get_output_qid())); 656 657 request->dest = _rep->get_output_qid(); 658 659 CIMEnumerateClassesResponseMessage *response; 660 661 try 662 { 663 response = 664 static_cast<CIMEnumerateClassesResponseMessage *>( 665 _rep->do_request(request, 666 CIM_ENUMERATE_CLASSES_RESPONSE_MESSAGE, 667 _rep->get_operation_timeout())); 668 } 669 catch(Exception & ) 670 { 671 PEG_TRACE_STRING(TRC_CIMOM_HANDLE, Tracer::LEVEL4, 672 "Exception caught in CIMOMHandle"); 673 response = 0; 674 } 675 catch(...) 676 { 677 PEG_TRACE_STRING(TRC_CIMOM_HANDLE, Tracer::LEVEL4, 678 "Unexpected Exception caught in CIMOMHandle"); 679 response = 0; 680 } 681 682 Array<CIMClass> cimClasses; 683 if(response != 0) 684 { 685 cimClasses = response->cimClasses; 686 } 687 delete response; 688 PEG_METHOD_EXIT(); 689 return cimClasses; 690 } 691 692 void CIMOMHandle::enumerateClassesAsync( 693 const OperationContext & context, 694 const CIMNamespaceName &nameSpace, 695 const CIMName& className, 696 Boolean deepInheritance, 697 Boolean localOnly, 698 Boolean includeQualifiers, 699 Boolean includeClassOrigin, 700 ClassResponseHandler & handler) 701 { 702 throw CIMException(CIM_ERR_NOT_SUPPORTED); 703 } 704 705 Array<CIMName> CIMOMHandle::enumerateClassNames( 706 const OperationContext & context, 707 const CIMNamespaceName &nameSpace, 708 const CIMName& className, 709 Boolean deepInheritance) 710 { 711 PEG_METHOD_ENTER(TRC_CIMOM_HANDLE, "CIMOMHandle::enumerateClassNames()"); 712 cimom_handle_op_semaphore opsem(_rep); 713 714 CIMEnumerateClassNamesRequestMessage * request = 715 new CIMEnumerateClassNamesRequestMessage( 716 XmlWriter::getNextMessageId(), 717 nameSpace, 718 className, 719 deepInheritance, 720 QueueIdStack(_rep->get_qid(), _rep->get_output_qid())); 721 722 request->dest = _rep->get_output_qid(); 723 724 CIMEnumerateClassNamesResponseMessage * response; 725 try 726 { 727 response = 728 static_cast<CIMEnumerateClassNamesResponseMessage * >( 729 _rep->do_request(request, 730 CIM_ENUMERATE_CLASS_NAMES_RESPONSE_MESSAGE, 731 _rep->get_operation_timeout())); 732 } 733 catch(Exception & ) 734 { 735 PEG_TRACE_STRING(TRC_CIMOM_HANDLE, Tracer::LEVEL4, 736 "Exception caught in CIMOMHandle"); 737 response = 0; 738 } 739 catch(...) 740 { 741 PEG_TRACE_STRING(TRC_CIMOM_HANDLE, Tracer::LEVEL4, 742 "Unexpected Exception caught in CIMOMHandle"); 743 response = 0; 744 } 745 746 Array<CIMName> classNames; 747 if(response != 0 ) 748 { 749 classNames = response->classNames; 750 } 751 752 delete response; 753 PEG_METHOD_EXIT(); 754 return(classNames); 755 } 756 757 void CIMOMHandle::enumerateClassNamesAsync( 758 const OperationContext & context, 759 const CIMNamespaceName &nameSpace, 760 const CIMName& className, 761 Boolean deepInheritance, 762 ObjectPathResponseHandler & handler) 763 { 764 throw CIMException(CIM_ERR_NOT_SUPPORTED); 765 } 766 767 void CIMOMHandle::createClass( 768 const OperationContext & context, 769 const CIMNamespaceName& nameSpace, 770 const CIMClass& newClass) 771 { 772 PEG_METHOD_ENTER(TRC_CIMOM_HANDLE, "CIMOMHandle::createClass()"); 773 cimom_handle_op_semaphore opsem(_rep); 774 775 776 CIMCreateClassRequestMessage * request = 777 new CIMCreateClassRequestMessage( 778 XmlWriter::getNextMessageId(), 779 nameSpace, 780 newClass, 781 QueueIdStack(_rep->get_qid(), _rep->get_output_qid())); 782 783 request->dest = _rep->get_output_qid(); 784 785 CIMCreateClassResponseMessage *response; 786 787 try 788 { 789 response = 790 static_cast<CIMCreateClassResponseMessage *>( 791 _rep->do_request(request, 792 CIM_CREATE_CLASS_RESPONSE_MESSAGE, 793 _rep->get_operation_timeout())); 794 } 795 catch(Exception & ) 796 { 797 PEG_TRACE_STRING(TRC_CIMOM_HANDLE, Tracer::LEVEL4, 798 "Exception caught in CIMOMHandle"); 799 response = 0; 800 } 801 catch(...) 802 { 803 PEG_TRACE_STRING(TRC_CIMOM_HANDLE, Tracer::LEVEL4, 804 "Unexpected Exception caught in CIMOMHandle"); 805 response = 0; 806 } 807 808 if(response == 0) 809 { 810 throw PEGASUS_CIM_EXCEPTION(CIM_ERR_FAILED, String::EMPTY); 811 } 812 813 delete response; 814 PEG_METHOD_EXIT(); 815 return; 816 } 817 818 void CIMOMHandle::createClassAsync( 819 const OperationContext & context, 820 const CIMNamespaceName &nameSpace, 821 const CIMClass& newClass, 822 ResponseHandler & handler) 823 { 824 throw CIMException(CIM_ERR_NOT_SUPPORTED); 825 } 826 827 void CIMOMHandle::modifyClass( 828 const OperationContext & context, 829 const CIMNamespaceName &nameSpace, 830 const CIMClass& modifiedClass) 831 { 832 PEG_METHOD_ENTER(TRC_CIMOM_HANDLE, "CIMOMHandle::modifyClass()"); 833 cimom_handle_op_semaphore opsem(_rep); 834 835 CIMModifyClassRequestMessage * request = 836 new CIMModifyClassRequestMessage( 837 XmlWriter::getNextMessageId(), 838 nameSpace, 839 modifiedClass, 840 QueueIdStack(_rep->get_qid(), _rep->get_output_qid())); 841 842 request->dest = _rep->get_output_qid(); 843 CIMModifyClassResponseMessage *response; 844 try 845 { 846 response = 847 static_cast<CIMModifyClassResponseMessage *>( 848 _rep->do_request(request, 849 CIM_MODIFY_CLASS_RESPONSE_MESSAGE, 850 _rep->get_operation_timeout())); 851 } 852 catch(Exception & ) 853 { 854 PEG_TRACE_STRING(TRC_CIMOM_HANDLE, Tracer::LEVEL4, 855 "Exception caught in CIMOMHandle"); 856 response = 0; 857 } 858 catch(...) 859 { 860 PEG_TRACE_STRING(TRC_CIMOM_HANDLE, Tracer::LEVEL4, 861 "Unexpected Exception caught in CIMOMHandle"); 862 response = 0; 863 } 864 865 if(response == 0) 866 { 867 throw PEGASUS_CIM_EXCEPTION(CIM_ERR_FAILED, String::EMPTY); 868 } 869 870 delete response; 871 PEG_METHOD_EXIT(); 872 return; 873 } 874 875 void CIMOMHandle::modifyClassAsync( 876 const OperationContext & context, 877 const CIMNamespaceName &nameSpace, 878 const CIMClass& modifiedClass, 879 ResponseHandler & handler) 880 { 881 throw CIMException(CIM_ERR_NOT_SUPPORTED); 882 } 883 884 void CIMOMHandle::deleteClass( 885 const OperationContext & context, 886 const CIMNamespaceName &nameSpace, 887 const CIMName& className) 888 { 889 890 PEG_METHOD_ENTER(TRC_CIMOM_HANDLE, "CIMOMHandle::deleteClass()"); 891 cimom_handle_op_semaphore opsem(_rep); 892 893 // encode request 894 CIMDeleteClassRequestMessage * request = 895 new CIMDeleteClassRequestMessage( 896 XmlWriter::getNextMessageId(), 897 nameSpace, 898 className, 899 QueueIdStack(_rep->get_qid(), _rep->get_output_qid())); 900 request->dest = _rep->get_output_qid(); 901 902 CIMDeleteClassResponseMessage * response; 903 904 try 905 { 906 response = 907 static_cast<CIMDeleteClassResponseMessage *>( 908 _rep->do_request(request, 909 CIM_DELETE_CLASS_RESPONSE_MESSAGE, 910 _rep->get_operation_timeout())); 911 } 912 catch(Exception & ) 913 { 914 PEG_TRACE_STRING(TRC_CIMOM_HANDLE, Tracer::LEVEL4, 915 "Exception caught in CIMOMHandle"); 916 response = 0; 917 } 918 catch(...) 919 { 920 PEG_TRACE_STRING(TRC_CIMOM_HANDLE, Tracer::LEVEL4, 921 "Unexpected Exception caught in CIMOMHandle"); 922 response = 0; 923 } 924 925 if(response == 0) 926 { 927 throw PEGASUS_CIM_EXCEPTION(CIM_ERR_FAILED, String::EMPTY); 928 } 929 delete response; 930 PEG_METHOD_EXIT(); 931 return; 932 } 933 934 void CIMOMHandle::deleteClassAsync( 935 const OperationContext & context, 936 const CIMNamespaceName &nameSpace, 937 const CIMName& className, 938 ResponseHandler & handler) 939 { 940 throw CIMException(CIM_ERR_NOT_SUPPORTED); 941 } 942 943 CIMInstance CIMOMHandle::getInstance( 944 const OperationContext & context, 945 const CIMNamespaceName &nameSpace, 946 const CIMObjectPath& instanceName, 947 Boolean localOnly, 948 Boolean includeQualifiers, 949 Boolean includeClassOrigin, 950 const CIMPropertyList& propertyList) 951 { 952 PEG_METHOD_ENTER(TRC_CIMOM_HANDLE, "CIMOMHandle::getInstance()"); 953 cimom_handle_op_semaphore opsem(_rep); 954 955 956 // encode request 957 CIMGetInstanceRequestMessage * request = 958 new CIMGetInstanceRequestMessage( 959 XmlWriter::getNextMessageId(), 960 nameSpace, 961 instanceName, 962 localOnly, 963 includeQualifiers, 964 includeClassOrigin, 965 propertyList, 966 QueueIdStack(_rep->get_qid(), _rep->get_output_qid())); 967 968 request->dest = _rep->get_output_qid(); 969 CIMGetInstanceResponseMessage * response; 970 try 971 { 972 response = 973 static_cast<CIMGetInstanceResponseMessage *>( 974 _rep->do_request(request, 975 CIM_GET_INSTANCE_RESPONSE_MESSAGE, 976 _rep->get_operation_timeout())); 977 } 978 catch(Exception & ) 979 { 980 PEG_TRACE_STRING(TRC_CIMOM_HANDLE, Tracer::LEVEL4, 981 "Exception caught in CIMOMHandle"); 982 response = 0; 983 } 984 catch(...) 985 { 986 PEG_TRACE_STRING(TRC_CIMOM_HANDLE, Tracer::LEVEL4, 987 "Unexpected Exception caught in CIMOMHandle"); 988 response = 0; 989 } 990 991 CIMInstance cimInstance ; 992 993 if(response != 0) 994 { 995 cimInstance = response->cimInstance; 996 } 997 998 delete response; 999 PEG_METHOD_EXIT(); 1000 return(cimInstance); 1001 } 1002 1003 void CIMOMHandle::getInstanceAsync( 1004 const OperationContext & context, 1005 const CIMNamespaceName &nameSpace, 1006 const CIMObjectPath& instanceName, 1007 Boolean localOnly, 1008 Boolean includeQualifiers, 1009 Boolean includeClassOrigin, 1010 const CIMPropertyList& propertyList, 1011 InstanceResponseHandler & handler) 1012 { 1013 throw CIMException(CIM_ERR_NOT_SUPPORTED); 1014 } 1015 1016 Array<CIMInstance> CIMOMHandle::enumerateInstances( 1017 const OperationContext & context, 1018 const CIMNamespaceName &nameSpace, 1019 const CIMName& className, 1020 Boolean deepInheritance, 1021 Boolean localOnly, 1022 Boolean includeQualifiers, 1023 Boolean includeClassOrigin, 1024 const CIMPropertyList& propertyList) 1025 { 1026 PEG_METHOD_ENTER(TRC_CIMOM_HANDLE, "CIMOMHandle::enumerateInstances()"); 1027 cimom_handle_op_semaphore opsem(_rep); 1028 1029 // encode request 1030 CIMEnumerateInstancesRequestMessage * request = 1031 new CIMEnumerateInstancesRequestMessage( 1032 XmlWriter::getNextMessageId(), 1033 nameSpace, 1034 className, 1035 deepInheritance, 1036 localOnly, 1037 includeQualifiers, 1038 includeClassOrigin, 1039 propertyList, 1040 QueueIdStack(_rep->get_qid(), _rep->get_output_qid())); 1041 1042 request->dest = _rep->get_output_qid(); 1043 1044 CIMEnumerateInstancesResponseMessage * response; 1045 try 1046 { 1047 response = 1048 static_cast<CIMEnumerateInstancesResponseMessage *>( 1049 _rep->do_request(request, 1050 CIM_ENUMERATE_INSTANCES_RESPONSE_MESSAGE, 1051 _rep->get_operation_timeout())); 1052 } 1053 catch(Exception & ) 1054 { 1055 PEG_TRACE_STRING(TRC_CIMOM_HANDLE, Tracer::LEVEL4, 1056 "Exception caught in CIMOMHandle"); 1057 response = 0; 1058 } 1059 catch(...) 1060 { 1061 PEG_TRACE_STRING(TRC_CIMOM_HANDLE, Tracer::LEVEL4, 1062 "Unexpected Exception caught in CIMOMHandle"); 1063 response = 0; 1064 } 1065 1066 Array<CIMInstance> cimInstances; 1067 if(response != 0) 1068 { 1069 cimInstances = response->cimNamedInstances; 1070 } 1071 delete response; 1072 PEG_METHOD_EXIT(); 1073 return(cimInstances); 1074 } 1075 1076 1077 1078 void CIMOMHandle::enumerateInstancesAsync( 1079 const OperationContext & context, 1080 const CIMNamespaceName &nameSpace, 1081 const CIMName& className, 1082 Boolean deepInheritance, 1083 Boolean localOnly, 1084 Boolean includeQualifiers, 1085 Boolean includeClassOrigin, 1086 const CIMPropertyList& propertyList, 1087 InstanceResponseHandler & handler) 1088 { 1089 throw CIMException(CIM_ERR_NOT_SUPPORTED); 1090 } 1091 1092 Array<CIMObjectPath> CIMOMHandle::enumerateInstanceNames( 1093 const OperationContext & context, 1094 const CIMNamespaceName &nameSpace, 1095 const CIMName& className) 1096 { 1097 PEG_METHOD_ENTER(TRC_CIMOM_HANDLE, "CIMOMHandle::enumerateInstanceNamess()"); 1098 cimom_handle_op_semaphore opsem(_rep); 1099 1100 // encode request 1101 CIMEnumerateInstanceNamesRequestMessage * request = 1102 new CIMEnumerateInstanceNamesRequestMessage( 1103 XmlWriter::getNextMessageId(), 1104 nameSpace, 1105 className, 1106 QueueIdStack(_rep->get_qid(), _rep->get_output_qid())); 1107 1108 request->dest = _rep->get_output_qid(); 1109 1110 CIMEnumerateInstanceNamesResponseMessage * response; 1111 try 1112 { 1113 response = 1114 static_cast<CIMEnumerateInstanceNamesResponseMessage *>( 1115 _rep->do_request(request, 1116 CIM_ENUMERATE_INSTANCE_NAMES_RESPONSE_MESSAGE, 1117 _rep->get_operation_timeout())); 1118 } 1119 catch(Exception & ) 1120 { 1121 PEG_TRACE_STRING(TRC_CIMOM_HANDLE, Tracer::LEVEL4, 1122 "Exception caught in CIMOMHandle"); 1123 response = 0; 1124 } 1125 catch(...) 1126 { 1127 PEG_TRACE_STRING(TRC_CIMOM_HANDLE, Tracer::LEVEL4, 1128 "Unexpected Exception caught in CIMOMHandle"); 1129 response = 0; 1130 } 1131 1132 Array<CIMObjectPath> cimReferences; 1133 1134 if(response != 0) 1135 { 1136 cimReferences = response->instanceNames; 1137 } 1138 delete response; 1139 PEG_METHOD_EXIT(); 1140 return(cimReferences); 1141 } 1142 1143 void CIMOMHandle::enumerateInstanceNamesAsync( 1144 const OperationContext & context, 1145 const CIMNamespaceName &nameSpace, 1146 const CIMName& className, 1147 ObjectPathResponseHandler & handler) 1148 { 1149 throw CIMException(CIM_ERR_NOT_SUPPORTED); 1150 } 1151 1152 CIMObjectPath CIMOMHandle::createInstance( 1153 const OperationContext & context, 1154 const CIMNamespaceName &nameSpace, 1155 const CIMInstance& newInstance) 1156 { 1157 PEG_METHOD_ENTER(TRC_CIMOM_HANDLE, "CIMOMHandle::createInstance()"); 1158 cimom_handle_op_semaphore opsem(_rep); 1159 1160 CIMCreateInstanceRequestMessage * request = 1161 new CIMCreateInstanceRequestMessage( 1162 XmlWriter::getNextMessageId(), 1163 nameSpace, 1164 newInstance, 1165 QueueIdStack(_rep->get_qid(), _rep->get_output_qid())); 1166 1167 request->dest = _rep->get_output_qid(); 1168 1169 CIMCreateInstanceResponseMessage *response; 1170 try 1171 { 1172 response = 1173 static_cast<CIMCreateInstanceResponseMessage *>( 1174 _rep->do_request(request, 1175 CIM_CREATE_INSTANCE_RESPONSE_MESSAGE, 1176 _rep->get_operation_timeout())); 1177 } 1178 1179 catch(Exception & ) 1180 { 1181 PEG_TRACE_STRING(TRC_CIMOM_HANDLE, Tracer::LEVEL4, 1182 "Exception caught in CIMOMHandle"); 1183 response = 0; 1184 } 1185 catch(...) 1186 { 1187 PEG_TRACE_STRING(TRC_CIMOM_HANDLE, Tracer::LEVEL4, 1188 "Unexpected Exception caught in CIMOMHandle"); 1189 response = 0; 1190 } 1191 1192 CIMObjectPath cimReference; 1193 1194 if(response != 0) 1195 { 1196 cimReference = response->instanceName; 1197 } 1198 delete response; 1199 PEG_METHOD_EXIT(); 1200 return(cimReference); 1201 } 1202 1203 void CIMOMHandle::createInstanceAsync( 1204 const OperationContext & context, 1205 const CIMNamespaceName &nameSpace, 1206 const CIMInstance& newInstance, 1207 ResponseHandler & handler) 1208 { 1209 throw CIMException(CIM_ERR_NOT_SUPPORTED); 1210 } 1211 1212 void CIMOMHandle::modifyInstance( 1213 const OperationContext & context, 1214 const CIMNamespaceName &nameSpace, 1215 const CIMInstance& modifiedInstance, 1216 Boolean includeQualifiers, 1217 const CIMPropertyList& propertyList) 1218 { 1219 PEG_METHOD_ENTER(TRC_CIMOM_HANDLE, "CIMOMHandle::modifyInstance()"); 1220 cimom_handle_op_semaphore opsem(_rep); 1221 1222 CIMModifyInstanceRequestMessage * request = 1223 new CIMModifyInstanceRequestMessage( 1224 XmlWriter::getNextMessageId(), 1225 nameSpace, 1226 CIMInstance(), 1227 includeQualifiers, 1228 propertyList, 1229 QueueIdStack(_rep->get_qid(), _rep->get_output_qid())); 1230 1231 request->dest = _rep->get_output_qid(); 1232 1233 CIMModifyInstanceResponseMessage *response; 1234 1235 try 1236 { 1237 response = 1238 static_cast<CIMModifyInstanceResponseMessage *>( 1239 _rep->do_request(request, 1240 CIM_MODIFY_INSTANCE_RESPONSE_MESSAGE, 1241 _rep->get_operation_timeout())); 1242 } 1243 catch(Exception & ) 1244 { 1245 PEG_TRACE_STRING(TRC_CIMOM_HANDLE, Tracer::LEVEL4, 1246 "Exception caught in CIMOMHandle"); 1247 response = 0; 1248 } 1249 catch(...) 1250 { 1251 PEG_TRACE_STRING(TRC_CIMOM_HANDLE, Tracer::LEVEL4, 1252 "Unexpected Exception caught in CIMOMHandle"); 1253 response = 0; 1254 } 1255 1256 if(response == 0) 1257 { 1258 throw PEGASUS_CIM_EXCEPTION(CIM_ERR_FAILED, String::EMPTY); 1259 } 1260 delete response; 1261 PEG_METHOD_EXIT(); 1262 return; 1263 } 1264 1265 void CIMOMHandle::modifyInstanceAsync( 1266 const OperationContext & context, 1267 const CIMNamespaceName &nameSpace, 1268 const CIMInstance& modifiedInstance, 1269 Boolean includeQualifiers, 1270 const CIMPropertyList& propertyList, 1271 ResponseHandler & handler) 1272 { 1273 throw CIMException(CIM_ERR_NOT_SUPPORTED); 1274 } 1275 1276 void CIMOMHandle::deleteInstance( 1277 const OperationContext & context, 1278 const CIMNamespaceName &nameSpace, 1279 const CIMObjectPath& instanceName) 1280 { 1281 PEG_METHOD_ENTER(TRC_CIMOM_HANDLE, "CIMOMHandle::deleteInstance()"); 1282 cimom_handle_op_semaphore opsem(_rep); 1283 1284 CIMDeleteInstanceRequestMessage * request = 1285 new CIMDeleteInstanceRequestMessage( 1286 XmlWriter::getNextMessageId(), 1287 nameSpace, 1288 instanceName, 1289 QueueIdStack(_rep->get_qid(), _rep->get_output_qid())); 1290 1291 request->dest = _rep->get_output_qid(); 1292 CIMDeleteInstanceResponseMessage *response; 1293 1294 try 1295 { 1296 response = 1297 static_cast<CIMDeleteInstanceResponseMessage *>( 1298 _rep->do_request(request, 1299 CIM_DELETE_INSTANCE_RESPONSE_MESSAGE, 1300 _rep->get_operation_timeout())); 1301 } 1302 catch(Exception & ) 1303 { 1304 PEG_TRACE_STRING(TRC_CIMOM_HANDLE, Tracer::LEVEL4, 1305 "Exception caught in CIMOMHandle"); 1306 response = 0; 1307 } 1308 catch(...) 1309 { 1310 PEG_TRACE_STRING(TRC_CIMOM_HANDLE, Tracer::LEVEL4, 1311 "Unexpected Exception caught in CIMOMHandle"); 1312 response = 0; 1313 } 1314 1315 if(response == 0) 1316 { 1317 throw PEGASUS_CIM_EXCEPTION(CIM_ERR_FAILED, String::EMPTY); 1318 } 1319 delete response; 1320 PEG_METHOD_EXIT(); 1321 return; 1322 } 1323 1324 void CIMOMHandle::deleteInstanceAsync( 1325 const OperationContext & context, 1326 const CIMNamespaceName &nameSpace, 1327 const CIMObjectPath& instanceName, 1328 ResponseHandler & handler) 1329 { 1330 throw CIMException(CIM_ERR_NOT_SUPPORTED); 1331 } 1332 1333 Array<CIMObject> CIMOMHandle::execQuery( 1334 const OperationContext & context, 1335 const CIMNamespaceName &nameSpace, 1336 const String& queryLanguage, 1337 const String& query) 1338 { 1339 PEG_METHOD_ENTER(TRC_CIMOM_HANDLE, "CIMOMHandle::exeQuery()"); 1340 cimom_handle_op_semaphore opsem(_rep); 1341 1342 CIMExecQueryRequestMessage * request = 1343 new CIMExecQueryRequestMessage( 1344 XmlWriter::getNextMessageId(), 1345 nameSpace, 1346 queryLanguage, 1347 query, 1348 QueueIdStack(_rep->get_qid(), _rep->get_output_qid())); 1349 1350 request->dest = _rep->get_output_qid(); 1351 1352 CIMExecQueryResponseMessage * response; 1353 1354 try 1355 { 1356 response = 1357 static_cast<CIMExecQueryResponseMessage *>( 1358 _rep->do_request(request, 1359 CIM_EXEC_QUERY_RESPONSE_MESSAGE, 1360 _rep->get_operation_timeout())); 1361 } 1362 catch(Exception & ) 1363 { 1364 PEG_TRACE_STRING(TRC_CIMOM_HANDLE, Tracer::LEVEL4, 1365 "Exception caught in CIMOMHandle"); 1366 response = 0; 1367 } 1368 catch(...) 1369 { 1370 PEG_TRACE_STRING(TRC_CIMOM_HANDLE, Tracer::LEVEL4, 1371 "Unexpected Exception caught in CIMOMHandle"); 1372 response = 0; 1373 } 1374 1375 Array<CIMObject> cimObjects; 1376 if(response != 0) 1377 { 1378 cimObjects = response->cimObjects; 1379 } 1380 1381 delete response; 1382 PEG_METHOD_EXIT(); 1383 return(cimObjects); 1384 } 1385 1386 void CIMOMHandle::execQueryAsync( 1387 const OperationContext & context, 1388 const CIMNamespaceName &nameSpace, 1389 const String& queryLanguage, 1390 const String& query, 1391 ObjectResponseHandler & handler) 1392 { 1393 throw CIMException(CIM_ERR_NOT_SUPPORTED); 1394 } 1395 1396 Array<CIMObject> CIMOMHandle::associators( 1397 const OperationContext & context, 1398 const CIMNamespaceName &nameSpace, 1399 const CIMObjectPath& objectName, 1400 const String& assocClass, 1401 const String& resultClass, 1402 const String& role, 1403 const String& resultRole, 1404 Boolean includeQualifiers, 1405 Boolean includeClassOrigin, 1406 const CIMPropertyList& propertyList) 1407 { 1408 PEG_METHOD_ENTER(TRC_CIMOM_HANDLE, "CIMOMHandle::associators()"); 1409 cimom_handle_op_semaphore opsem(_rep); 1410 1411 CIMAssociatorsRequestMessage * request = 1412 new CIMAssociatorsRequestMessage( 1413 XmlWriter::getNextMessageId(), 1414 nameSpace, 1415 objectName, 1416 assocClass, 1417 resultClass, 1418 role, 1419 resultRole, 1420 includeQualifiers, 1421 includeClassOrigin, 1422 propertyList, 1423 QueueIdStack(_rep->get_qid(), _rep->get_output_qid())); 1424 1425 request->dest = _rep->get_output_qid(); 1426 CIMAssociatorsResponseMessage *response; 1427 1428 try 1429 { 1430 response = 1431 static_cast<CIMAssociatorsResponseMessage *>( 1432 _rep->do_request(request, 1433 CIM_ASSOCIATORS_RESPONSE_MESSAGE, 1434 _rep->get_operation_timeout())); 1435 } 1436 catch(Exception & ) 1437 { 1438 PEG_TRACE_STRING(TRC_CIMOM_HANDLE, Tracer::LEVEL4, 1439 "Exception caught in CIMOMHandle"); 1440 response = 0; 1441 } 1442 catch(...) 1443 { 1444 PEG_TRACE_STRING(TRC_CIMOM_HANDLE, Tracer::LEVEL4, 1445 "Unexpected Exception caught in CIMOMHandle"); 1446 response = 0; 1447 } 1448 1449 Array<CIMObject> cimObjects; 1450 1451 if(response != 0) 1452 { 1453 cimObjects = response->cimObjects; 1454 } 1455 1456 delete response; 1457 PEG_METHOD_EXIT(); 1458 return(cimObjects); 1459 } 1460 1461 void CIMOMHandle::associatorsAsync( 1462 const OperationContext & context, 1463 const CIMNamespaceName &nameSpace, 1464 const CIMObjectPath& objectName, 1465 const String& assocClass, 1466 const String& resultClass, 1467 const String& role, 1468 const String& resultRole, 1469 Boolean includeQualifiers, 1470 Boolean includeClassOrigin, 1471 const CIMPropertyList& propertyList, 1472 ObjectResponseHandler & handler) 1473 { 1474 throw CIMException(CIM_ERR_NOT_SUPPORTED); 1475 } 1476 1477 Array<CIMObjectPath> CIMOMHandle::associatorNames( 1478 const OperationContext & context, 1479 const CIMNamespaceName &nameSpace, 1480 const CIMObjectPath& objectName, 1481 const String& assocClass, 1482 const String& resultClass, 1483 const String& role, 1484 const String& resultRole) 1485 { 1486 PEG_METHOD_ENTER(TRC_CIMOM_HANDLE, "CIMOMHandle::associatorNames()"); 1487 cimom_handle_op_semaphore opsem(_rep); 1488 1489 CIMAssociatorNamesRequestMessage * request = 1490 new CIMAssociatorNamesRequestMessage( 1491 XmlWriter::getNextMessageId(), 1492 nameSpace, 1493 objectName, 1494 assocClass, 1495 resultClass, 1496 role, 1497 resultRole, 1498 QueueIdStack(_rep->get_qid(), _rep->get_output_qid())); 1499 1500 request->dest = _rep->get_output_qid(); 1501 1502 CIMAssociatorNamesResponseMessage *response; 1503 1504 try 1505 { 1506 response = 1507 static_cast<CIMAssociatorNamesResponseMessage *>( 1508 _rep->do_request(request, 1509 CIM_ASSOCIATOR_NAMES_RESPONSE_MESSAGE, 1510 _rep->get_operation_timeout())); 1511 } 1512 catch(Exception & ) 1513 { 1514 PEG_TRACE_STRING(TRC_CIMOM_HANDLE, Tracer::LEVEL4, 1515 "Exception caught in CIMOMHandle"); 1516 response = 0; 1517 } 1518 catch(...) 1519 { 1520 PEG_TRACE_STRING(TRC_CIMOM_HANDLE, Tracer::LEVEL4, 1521 "Unexpected Exception caught in CIMOMHandle"); 1522 response = 0; 1523 } 1524 1525 Array<CIMObjectPath> cimObjectPaths; 1526 1527 if(response != 0) 1528 { 1529 cimObjectPaths = response->objectNames; 1530 } 1531 1532 delete response; 1533 PEG_METHOD_EXIT(); 1534 return(cimObjectPaths); 1535 } 1536 1537 void CIMOMHandle::associatorNamesAsync( 1538 const OperationContext & context, 1539 const CIMNamespaceName &nameSpace, 1540 const CIMObjectPath& objectName, 1541 const String& assocClass, 1542 const String& resultClass, 1543 const String& role, 1544 const String& resultRole, 1545 ObjectPathResponseHandler & handler) 1546 { 1547 throw CIMException(CIM_ERR_NOT_SUPPORTED); 1548 } 1549 1550 1551 Array<CIMObject> CIMOMHandle::references( 1552 const OperationContext & context, 1553 const CIMNamespaceName &nameSpace, 1554 const CIMObjectPath& objectName, 1555 const String& resultClass, 1556 const String& role, 1557 Boolean includeQualifiers, 1558 Boolean includeClassOrigin, 1559 const CIMPropertyList& propertyList) 1560 { 1561 PEG_METHOD_ENTER(TRC_CIMOM_HANDLE, "CIMOMHandle::references()"); 1562 cimom_handle_op_semaphore opsem(_rep); 1563 1564 CIMReferencesRequestMessage * request = 1565 new CIMReferencesRequestMessage( 1566 XmlWriter::getNextMessageId(), 1567 nameSpace, 1568 objectName, 1569 resultClass, 1570 role, 1571 includeQualifiers, 1572 includeClassOrigin, 1573 propertyList, 1574 QueueIdStack(_rep->get_qid(), _rep->get_output_qid())); 1575 1576 request->dest = _rep->get_output_qid(); 1577 1578 CIMReferencesResponseMessage *response; 1579 1580 try 1581 { 1582 response = 1583 static_cast<CIMReferencesResponseMessage *>( 1584 _rep->do_request(request, 1585 CIM_REFERENCES_RESPONSE_MESSAGE, 1586 _rep->get_operation_timeout())); 1587 } 1588 catch(Exception & ) 1589 { 1590 PEG_TRACE_STRING(TRC_CIMOM_HANDLE, Tracer::LEVEL4, 1591 "Exception caught in CIMOMHandle"); 1592 response = 0; 1593 } 1594 catch(...) 1595 { 1596 PEG_TRACE_STRING(TRC_CIMOM_HANDLE, Tracer::LEVEL4, 1597 "Unexpected Exception caught in CIMOMHandle"); 1598 response = 0; 1599 } 1600 1601 Array<CIMObject> cimObjects; 1602 1603 if(response != 0) 1604 { 1605 cimObjects = response->cimObjects; 1606 } 1607 1608 delete response; 1609 PEG_METHOD_EXIT(); 1610 return(cimObjects); 1611 } 1612 1613 void CIMOMHandle::referencesAsync( 1614 const OperationContext & context, 1615 const CIMNamespaceName &nameSpace, 1616 const CIMObjectPath& objectName, 1617 const String& resultClass, 1618 const String& role, 1619 Boolean includeQualifiers, 1620 Boolean includeClassOrigin, 1621 const CIMPropertyList& propertyList, 1622 ObjectResponseHandler & handler) 1623 { 1624 throw CIMException(CIM_ERR_NOT_SUPPORTED); 1625 } 1626 1627 Array<CIMObjectPath> CIMOMHandle::referenceNames( 1628 const OperationContext & context, 1629 const CIMNamespaceName &nameSpace, 1630 const CIMObjectPath& objectName, 1631 const String& resultClass, 1632 const String& role) 1633 { 1634 PEG_METHOD_ENTER(TRC_CIMOM_HANDLE, "CIMOMHandle::()referenceNames"); 1635 cimom_handle_op_semaphore opsem(_rep); 1636 1637 CIMReferenceNamesRequestMessage * request = 1638 new CIMReferenceNamesRequestMessage( 1639 XmlWriter::getNextMessageId(), 1640 nameSpace, 1641 objectName, 1642 resultClass, 1643 role, 1644 QueueIdStack(_rep->get_qid(), _rep->get_output_qid())); 1645 1646 request->dest = _rep->get_output_qid(); 1647 1648 1649 CIMReferenceNamesResponseMessage * response; 1650 1651 try 1652 { 1653 response = 1654 static_cast<CIMReferenceNamesResponseMessage *>( 1655 _rep->do_request(request, 1656 CIM_REFERENCE_NAMES_RESPONSE_MESSAGE, 1657 _rep->get_operation_timeout())); 1658 } 1659 catch(Exception & ) 1660 { 1661 PEG_TRACE_STRING(TRC_CIMOM_HANDLE, Tracer::LEVEL4, 1662 "Exception caught in CIMOMHandle"); 1663 response = 0; 1664 } 1665 catch(...) 1666 { 1667 PEG_TRACE_STRING(TRC_CIMOM_HANDLE, Tracer::LEVEL4, 1668 "Unexpected Exception caught in CIMOMHandle"); 1669 response = 0; 1670 } 1671 1672 1673 Array<CIMObjectPath> cimObjectPaths; 1674 if(response != 0) 1675 { 1676 cimObjectPaths = response->objectNames; 1677 } 1678 1679 delete response; 1680 PEG_METHOD_EXIT(); 1681 return(cimObjectPaths); 1682 } 1683 1684 void CIMOMHandle::referenceNamesAsync( 1685 const OperationContext & context, 1686 const CIMNamespaceName &nameSpace, 1687 const CIMObjectPath& objectName, 1688 const String& resultClass, 1689 const String& role, 1690 ObjectPathResponseHandler & handler) 1691 { 1692 throw CIMException(CIM_ERR_NOT_SUPPORTED); 1693 } 1694 1695 CIMValue CIMOMHandle::getProperty( 1696 const OperationContext & context, 1697 const CIMNamespaceName &nameSpace, 1698 const CIMObjectPath& instanceName, 1699 const String& propertyName) 1700 { 1701 PEG_METHOD_ENTER(TRC_CIMOM_HANDLE, "CIMOMHandle::getProperty()"); 1702 cimom_handle_op_semaphore opsem(_rep); 1703 1704 CIMGetPropertyRequestMessage * request = 1705 new CIMGetPropertyRequestMessage( 1706 XmlWriter::getNextMessageId(), 1707 nameSpace, 1708 instanceName, 1709 propertyName, 1710 QueueIdStack(_rep->get_qid(), _rep->get_output_qid())); 1711 1712 request->dest = _rep->get_output_qid(); 1713 1714 CIMGetPropertyResponseMessage *response; 1715 1716 try 1717 { 1718 response = 1719 static_cast<CIMGetPropertyResponseMessage *>( 1720 _rep->do_request(request, 1721 CIM_GET_PROPERTY_RESPONSE_MESSAGE, 1722 _rep->get_operation_timeout())); 1723 } 1724 catch(Exception & ) 1725 { 1726 PEG_TRACE_STRING(TRC_CIMOM_HANDLE, Tracer::LEVEL4, 1727 "Exception caught in CIMOMHandle"); 1728 response = 0; 1729 } 1730 catch(...) 1731 { 1732 PEG_TRACE_STRING(TRC_CIMOM_HANDLE, Tracer::LEVEL4, 1733 "Unexpected Exception caught in CIMOMHandle"); 1734 response = 0; 1735 } 1736 1737 CIMValue cimValue; 1738 if(response != 0) 1739 { 1740 cimValue = response->value; 1741 } 1742 1743 delete response; 1744 PEG_METHOD_EXIT(); 1745 return(cimValue); 1746 } 1747 1748 void CIMOMHandle::getPropertyAsync( 1749 const OperationContext & context, 1750 const CIMNamespaceName &nameSpace, 1751 const CIMObjectPath& instanceName, 1752 const String& propertyName, 1753 ValueResponseHandler & handler) 1754 { 1755 throw CIMException(CIM_ERR_NOT_SUPPORTED); 1756 } 1757 1758 void CIMOMHandle::setProperty( 1759 const OperationContext & context, 1760 const CIMNamespaceName &nameSpace, 1761 const CIMObjectPath& instanceName, 1762 const String& propertyName, 1763 const CIMValue& newValue) 1764 { 1765 PEG_METHOD_ENTER(TRC_CIMOM_HANDLE, "CIMOMHandle::setProperty()"); 1766 cimom_handle_op_semaphore opsem(_rep); 1767 1768 CIMSetPropertyRequestMessage * request = 1769 new CIMSetPropertyRequestMessage( 1770 XmlWriter::getNextMessageId(), 1771 nameSpace, 1772 instanceName, 1773 propertyName, 1774 newValue, 1775 QueueIdStack(_rep->get_qid(), _rep->get_output_qid())); 1776 1777 1778 request->dest = _rep->get_output_qid(); 1779 1780 CIMSetPropertyResponseMessage *response; 1781 1782 try 1783 { 1784 response = 1785 static_cast<CIMSetPropertyResponseMessage *>( 1786 _rep->do_request(request, 1787 CIM_SET_PROPERTY_RESPONSE_MESSAGE, 1788 _rep->get_operation_timeout())); 1789 } 1790 catch(Exception & ) 1791 { 1792 PEG_TRACE_STRING(TRC_CIMOM_HANDLE, Tracer::LEVEL4, 1793 "Exception caught in CIMOMHandle"); 1794 response = 0; 1795 } 1796 catch(...) 1797 { 1798 PEG_TRACE_STRING(TRC_CIMOM_HANDLE, Tracer::LEVEL4, 1799 "Unexpected Exception caught in CIMOMHandle"); 1800 response = 0; 1801 } 1802 1803 if(response == 0) 1804 { 1805 throw PEGASUS_CIM_EXCEPTION(CIM_ERR_FAILED, String::EMPTY); 1806 } 1807 delete response; 1808 PEG_METHOD_EXIT(); 1809 return; 1810 } 1811 1812 void CIMOMHandle::setPropertyAsync( 1813 const OperationContext & context, 1814 const CIMNamespaceName &nameSpace, 1815 const CIMObjectPath& instanceName, 1816 const String& propertyName, 1817 const CIMValue& newValue, 1818 ValueResponseHandler & handler) 1819 { 1820 throw CIMException(CIM_ERR_NOT_SUPPORTED); 1821 } 1822 1823 1824 // CIMValue CIMOMHandle::invokeMethod( 1825 // const OperationContext & context, 1826 // const CIMNamespaceName &nameSpace, 1827 // const CIMObjectPath& instanceName, 1828 // const String& methodName, 1829 // const Array<CIMParamValue>& inParameters, 1830 // Array<CIMParamValue>& outParameters) 1831 // { 1832 // cimom_handle_op_semaphore opsem(_rep); 1833 1834 // { 1835 // throw UninitializedObjectException(); 1836 // } 1837 1838 // Message* request = new CIMInvokeMethodRequestMessage( 1839 // XmlWriter::getNextMessageId(), 1840 // nameSpace, 1841 // instanceName, 1842 // methodName, 1843 // inParameters, 1844 // QueueIdStack(_rep->_dispatcher_qid, _rep->_provider_manager_qid)); 1845 1846 // CIMInvokeMethodResponseMessage *reply = 1847 // static_cast<CIMInvokeMethodResponseMessage *>(_rep->_controller_async(request)); 1848 // CIMValue value; 1849 1850 // if(reply != 0 ) 1851 // { 1852 // outParameters = reply->outParameters; 1853 // value = reply->retValue; 1854 // } 1855 // delete request; 1856 // delete reply; 1857 // return value; 1858 // } 1859 1860 // void CIMOMHandle::invokeMethodAsync( 1861 // const OperationContext & context, 1862 // const CIMNamespaceName &nameSpace, 1863 // const CIMObjectPath& instanceName, 1864 // const String& methodName, 1865 // const Array<CIMParamValue>& inParameters, 1866 // Array<CIMParamValue>& outParameters, 1867 // ValueResponseHandler & handler) 1868 // { 1869 // throw CIMException(CIM_ERR_NOT_SUPPORTED); 1870 // } 1871 1872 void CIMOMHandle::get_idle_timer(struct timeval *tv) 1873 { 1874 _rep->get_idle_timer(tv); 1875 } 1876 1877 void CIMOMHandle::update_idle_timer(void) 1878 { 1879 _rep->update_idle_timer(); 1880 } 1881 1882 Uint32 CIMOMHandle::get_operation_timeout(void) 1883 { 1884 return _rep->get_operation_timeout(); 1885 } 1886 1887 void CIMOMHandle::set_operation_timeout(Uint32 t) 1888 { 1889 _rep->set_operation_timeout(t); 1890 } 1891 1892 Boolean CIMOMHandle::pending_operation(void) 1893 { 1894 if(_rep->_pending_operation.value()) 1895 return true; 1896 return false; 1897 } 1898 1899 Boolean CIMOMHandle::unload_ok(void) 1900 { 1901 return _rep->unload_ok(); 1902 } 1903 1904 Uint32 CIMOMHandle::get_output_qid(void) 1905 { 1906 return _rep->get_output_qid(); 1907 } 1908 1909 void CIMOMHandle::set_output_qid(Uint32 q) 1910 { 1911 _rep->set_output_qid(q); 1912 } 1913 1914 Uint32 CIMOMHandle::get_return_qid(void) 1915 { 1916 return _rep->get_return_qid(); 1917 } 1918 1919 void CIMOMHandle::set_return_qid(Uint32 q) 1920 { 1921 _rep->set_return_qid(q); 1922 } 1923 1924 void CIMOMHandle::protect(void) 1925 { 1926 _rep->protect(); 1927 } 1928 1929 void CIMOMHandle::unprotect(void) 1930 { 1931 _rep->unprotect(); 1932 } 1933 1934 1935 PEGASUS_NAMESPACE_END
1 //%/////////////-*-c++-*-/////////////////////////////////////////////////////// 2 // 3 // Copyright (c) 2000 - 2003 BMC Software, Hewlett-Packard Company, IBM, 4 // The Open Group, Tivoli Systems 5 // 6 // Permission is hereby granted, free of charge, to any person obtaining a copy 7 // of this software and associated documentation files (the "Software"), to 8 // deal in the Software without restriction, including without limitation the 9 // rights to use, copy, modify, merge, publish, distribute, sublicense, and/or 10 // sell copies of the Software, and to permit persons to whom the Software is 11 // furnished to do so, subject to the following conditions: 12 // 13 // THE ABOVE COPYRIGHT NOTICE AND THIS PERMISSION NOTICE SHALL BE INCLUDED IN 14 // ALL COPIES OR SUBSTANTIAL PORTIONS OF THE SOFTWARE. THE SOFTWARE IS PROVIDED 15 // "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT 16 // LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR 17 // PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT 18 // HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN 19 // ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION 20 // WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. 21 // 22 //============================================================================== 23 // 24 // Author: Mike Day (mdday@us.ibm.com) 25 // 26 //%///////////////////////////////////////////////////////////////////////////// 27 #ifndef Pegasus_BinaryMessageHandler_h 28 #define Pegasus_BinaryMessageHandler_h 29 #include <Pegasus/Common/Config.h> 30 #include <Pegasus/Common/AsyncOpNode.h> 31 #include <Pegasus/Common/DQueue.h> 32 #include <Pegasus/Common/MessageQueueService.h> 33 #include <Pegasus/Common/Message.h> 34 #include <Pegasus/Common/CIMMessage.h> 35 #include <Pegasus/Common/Tracer.h> 36 #include <Pegasus/Common/TraceComponents.h> 37 #include <Pegasus/Common/IPC.h> 38 #include <Pegasus/Common/Thread.h> 39 #include <Pegasus/Common/Constants.h> 40 #include <Pegasus/Server/Linkage.h> 41 42 PEGASUS_NAMESPACE_BEGIN 43 44 /** This class provides an in-process binary client interface, 45 both for requests and responses. 46 */ 47 48 class PEGASUS_SERVER_LINKAGE BinaryMessageHandler : public MessageQueueService 49 { 50 public: 51 typedef MessageQueueService Base; 52 53 BinaryMessageHandler(MessageQueueService *outputQueue); 54 ~BinaryMessageHandler(); 55 56 virtual Boolean messageOK(const Message * message); 57 virtual void handleEnqueue(void); 58 virtual void handleEnqueue(Message * message); 59 virtual void _handle_async_request(AsyncRequest * request); 60 protected: 61 static PEGASUS_THREAD_RETURN PEGASUS_THREAD_CDECL handle_binary_message(void *); 62 63 // **** Request Messages **** // 64 65 void handleCreateClassRequest( 66 AsyncOpNode *, 67 CIMCreateClassRequestMessage *) throw(); 68 69 void handleGetClassRequest( 70 AsyncOpNode *, 71 CIMGetClassRequestMessage *) throw(); 72 73 void handleModifyClassRequest( 74 AsyncOpNode *, 75 CIMModifyClassRequestMessage *) throw(); 76 77 void handleEnumerateClassNamesRequest( 78 AsyncOpNode *, 79 CIMEnumerateClassNamesRequestMessage *) throw(); 80 81 void handleEnumerateClassesRequest( 82 AsyncOpNode *, 83 CIMEnumerateClassesRequestMessage *) throw(); 84 85 void handleDeleteClassRequest( 86 AsyncOpNode *, 87 CIMDeleteClassRequestMessage *) throw(); 88 89 void handleCreateInstanceRequest( 90 AsyncOpNode *, 91 CIMCreateInstanceRequestMessage *) throw(); 92 93 void handleGetInstanceRequest( 94 AsyncOpNode *, 95 CIMGetInstanceRequestMessage *) throw(); 96 97 void handleModifyInstanceRequest( 98 AsyncOpNode *, 99 CIMModifyInstanceRequestMessage *) throw(); 100 101 void handleEnumerateInstanceNamesRequest( 102 AsyncOpNode *, 103 CIMEnumerateInstanceNamesRequestMessage *) throw(); 104 105 void handleEnumerateInstancesRequest( 106 AsyncOpNode *, 107 CIMEnumerateInstancesRequestMessage *) throw(); 108 109 void handleDeleteInstanceRequest( 110 AsyncOpNode *, 111 CIMDeleteInstanceRequestMessage *) throw(); 112 113 void handleSetQualifierRequest( 114 AsyncOpNode *, 115 CIMSetQualifierRequestMessage *) throw(); 116 117 void handleGetQualifierRequest( 118 AsyncOpNode *, 119 CIMGetQualifierRequestMessage *) throw(); 120 121 void handleEnumerateQualifiersRequest( 122 AsyncOpNode *, 123 CIMEnumerateQualifiersRequestMessage *) throw(); 124 125 void handleDeleteQualifiersRequest( 126 AsyncOpNode *, 127 CIMDeleteQualifierRequestMessage *) throw(); 128 129 void handleReferenceNamesRequest( 130 AsyncOpNode *, 131 CIMReferenceNamesRequestMessage *) throw(); 132 133 void handleReferencesRequest( 134 AsyncOpNode *, 135 CIMReferencesRequestMessage *) throw(); 136 137 void handleAssociatorNamesRequest( 138 AsyncOpNode *, 139 CIMAssociatorNamesRequestMessage *) throw(); 140 141 void handleAssociatorsRequest( 142 AsyncOpNode *, 143 CIMAssociatorsRequestMessage *) throw(); 144 145 void handleGetPropertyRequest( 146 AsyncOpNode *, 147 CIMGetPropertyRequestMessage *) throw(); 148 149 void handleSetPropertyRequest( 150 AsyncOpNode *, 151 CIMSetPropertyRequestMessage *) throw(); 152 153 void handleExecQueryRequest( 154 AsyncOpNode *, 155 CIMExecQueryRequestMessage *) throw(); 156 157 void handleInvokeMethodRequest( 158 AsyncOpNode *, 159 CIMInvokeMethodRequestMessage *) throw(); 160 161 // **** Response Messages **** // 162 163 void handleCreateClassResponse( 164 AsyncOpNode *, 165 CIMCreateClassResponseMessage *) throw(); 166 167 void handleGetClassResponse( 168 AsyncOpNode *, 169 CIMGetClassResponseMessage *) throw(); 170 171 void handleModifyClassResponse( 172 AsyncOpNode *, 173 CIMModifyClassResponseMessage *) throw(); 174 175 void handleEnumerateClassNamesResponse( 176 AsyncOpNode *, 177 CIMEnumerateClassNamesResponseMessage *) throw(); 178 179 void handleEnumerateClassesResponse( 180 AsyncOpNode *, 181 CIMEnumerateClassesResponseMessage *) throw(); 182 183 void handleDeleteClassResponse( 184 AsyncOpNode *, 185 CIMDeleteClassResponseMessage *) throw(); 186 187 void handleCreateInstanceResponse( 188 AsyncOpNode *, 189 CIMCreateInstanceResponseMessage *) throw(); 190 191 void handleGetInstanceResponse( 192 AsyncOpNode *, 193 CIMGetInstanceResponseMessage *) throw(); 194 195 void handleModifyInstanceResponse( 196 AsyncOpNode *, 197 CIMModifyInstanceResponseMessage *) throw(); 198 199 void handleEnumerateInstanceNamesResponse( 200 AsyncOpNode *, 201 CIMEnumerateInstanceNamesResponseMessage *) throw(); 202 203 void handleEnumerateInstancesResponse( 204 AsyncOpNode *, 205 CIMEnumerateInstancesResponseMessage *) throw(); 206 207 void handleDeleteInstanceResponse( 208 AsyncOpNode *, 209 CIMDeleteInstanceResponseMessage *) throw(); 210 211 void handleGetPropertyResponse( 212 AsyncOpNode *, 213 CIMGetPropertyResponseMessage *) throw(); 214 215 void handleSetPropertyResponse( 216 AsyncOpNode *, 217 CIMSetPropertyResponseMessage *) throw(); 218 219 void handleSetQualifierResponse( 220 AsyncOpNode *, 221 CIMSetQualifierResponseMessage *) throw(); 222 223 void handleGetQualifierResponse( 224 AsyncOpNode *, 225 CIMGetQualifierResponseMessage *) throw(); 226 227 void handleEnumerateQualifiersResponse( 228 AsyncOpNode *, 229 CIMEnumerateQualifiersResponseMessage *) throw(); 230 231 void handleDeleteQualifierResponse( 232 AsyncOpNode *, 233 CIMDeleteQualifierResponseMessage *) throw(); 234 235 void handleReferenceNamesResponse( 236 AsyncOpNode *, 237 CIMReferenceNamesResponseMessage *) throw(); 238 239 void handleReferencesResponse( 240 AsyncOpNode *, 241 CIMReferencesResponseMessage *) throw(); 242 243 void handleAssociatorNamesResponse( 244 AsyncOpNode *, 245 CIMAssociatorNamesResponseMessage *) throw(); 246 247 void handleAssociatorsResponse( 248 AsyncOpNode *, 249 CIMAssociatorsResponseMessage *) throw(); 250 251 void handleExecQueryResponse( 252 AsyncOpNode *, 253 CIMExecQueryResponseMessage *) throw(); 254 255 void handleInvokeMethodResponse( 256 AsyncOpNode *, 257 CIMInvokeMethodResponseMessage *) throw(); 258 259 private: 260 BinaryMessageHandler(void); 261 BinaryMessageHandler & operator = (const BinaryMessageHandler & ) const; 262 void _handleRequest(AsyncOpNode *, Message *) throw(); 263 void _handleResponse(AsyncOpNode *, Message *) throw(); 264 265 266 MessageQueueService* _outputQueue; 267 268 // Flag to indicate whether or not the CIMServer is shutting down. 269 Boolean _serverTerminating; 270 AsyncDQueue<AsyncOpNode> _msg_q; 271 272 }; 273 274 275 PEGASUS_NAMESPACE_END 276 277 #endif // Pegasus_BinaryMessageHandler_h
1 //%/////////////-*-c++-*-/////////////////////////////////////////////////////// 2 // 3 // Copyright (c) 2000 - 2003 BMC Software, Hewlett-Packard Company, IBM, 4 // The Open Group, Tivoli Systems 5 // 6 // Permission is hereby granted, free of charge, to any person obtaining a copy 7 // of this software and associated documentation files (the "Software"), to 8 // deal in the Software without restriction, including without limitation the 9 // rights to use, copy, modify, merge, publish, distribute, sublicense, and/or 10 // sell copies of the Software, and to permit persons to whom the Software is 11 // furnished to do so, subject to the following conditions: 12 // 13 // THE ABOVE COPYRIGHT NOTICE AND THIS PERMISSION NOTICE SHALL BE INCLUDED IN 14 // ALL COPIES OR SUBSTANTIAL PORTIONS OF THE SOFTWARE. THE SOFTWARE IS PROVIDED 15 // "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT 16 // LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR 17 // PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT 18 // HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN 19 // ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION 20 // WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. 21 // 22 //============================================================================== 23 // 24 // Author: Mike Day (mdday@us.ibm.com) 25 // 26 //%///////////////////////////////////////////////////////////////////////////// 27 28 #include "BinaryMessageHandler.h" 29 #include <Pegasus/Common/IPC.h> 30 #include <Pegasus/Common/Thread.h> 31 32 PEGASUS_NAMESPACE_BEGIN 33 34 BinaryMessageHandler::BinaryMessageHandler(MessageQueueService *output_q) 35 : Base(PEGASUS_QUEUENAME_BINARY_HANDLER), 36 _outputQueue(output_q), 37 _serverTerminating(false), 38 _msg_q(true, 0) 39 { 40 41 } 42 43 BinaryMessageHandler::~BinaryMessageHandler(void) 44 { 45 46 } 47 48 49 Boolean BinaryMessageHandler::messageOK(const Message * msg) 50 { 51 return Base::messageOK(msg); 52 } 53 54 void BinaryMessageHandler::handleEnqueue(void) 55 { 56 Message *msg = dequeue(); 57 handleEnqueue(msg); 58 } 59 60 void BinaryMessageHandler::handleEnqueue(Message * message) 61 { 62 PEG_METHOD_ENTER(TRC_BINARY_MSG_HANDLER, 63 "BinaryMessageHandler::_handleEnqueue(Message *)"); 64 PEGASUS_ASSERT(message != 0); 65 66 AsyncRequest * asyncRequest; 67 AsyncOpNode * op; 68 69 message->_async = 0; 70 71 PEG_TRACE_STRING(TRC_BINARY_MSG_HANDLER, Tracer::LEVEL4, 72 "Converting legacy message to AsyncLegacyOperationStart"); 73 op = this->get_op(); 74 asyncRequest = new AsyncLegacyOperationStart( 75 get_next_xid(), 76 op, 77 this->getQueueId(), 78 message, 79 this->getQueueId()); 80 op->_flags |= ASYNC_OPFLAGS_FIRE_AND_FORGET; 81 82 83 _handle_async_request(asyncRequest); 84 PEG_METHOD_EXIT(); 85 } 86 87 void BinaryMessageHandler::_handle_async_request(AsyncRequest * request) 88 { 89 PEG_METHOD_ENTER(TRC_BINARY_MSG_HANDLER, 90 "BinaryMessageHandler::_handle_async_request"); 91 92 PEGASUS_ASSERT(request != 0 && request->op != 0 ); 93 94 if(request->getType() == async_messages::ASYNC_LEGACY_OP_START || 95 request->getType() == async_messages::ASYNC_LEGACY_OP_RESULT) 96 { 97 PEG_TRACE_STRING(TRC_BINARY_MSG_HANDLER, Tracer::LEVEL4, 98 "Processing ASYNC_LEGACY_OP_* Message."); 99 request->op->processing(); 100 try 101 { 102 _msg_q.insert_last(request->op); 103 } 104 catch(ListFull & ) 105 { 106 PEG_TRACE_STRING(TRC_BINARY_MSG_HANDLER, Tracer::LEVEL4, 107 "Internal DQueue Full."); 108 Base::_handle_async_request(request); 109 PEG_METHOD_EXIT(); 110 return; 111 } 112 113 catch(...) 114 { 115 PEG_TRACE_STRING(TRC_BINARY_MSG_HANDLER, Tracer::LEVEL4, 116 "Internal DQueue Error."); 117 Base::_handle_async_request(request); 118 PEG_METHOD_EXIT(); 119 return; 120 } 121 122 PEG_TRACE_STRING(TRC_BINARY_MSG_HANDLER, Tracer::LEVEL4, 123 "Allocating pooled thread to handle binary message."); 124 _thread_pool->allocate_and_awaken( 125 (void *)this, BinaryMessageHandler::handle_binary_message); 126 } 127 else if(request->getType() == async_messages::CIMSERVICE_STOP) 128 { 129 PEG_TRACE_STRING(TRC_BINARY_MSG_HANDLER, Tracer::LEVEL4, 130 "Handling CIMServer Stop Message"); 131 _serverTerminating = true; 132 Base::_handle_async_request(request); 133 } 134 else 135 { 136 // pass all other operations to the default handler 137 PEG_TRACE_STRING(TRC_BINARY_MSG_HANDLER, Tracer::LEVEL4, 138 "Passing message to parent."); 139 140 PEGASUS_STD(cout) << "Unexpected Message: type " << request->getType() << PEGASUS_STD(endl); 141 142 Base::_handle_async_request(request); 143 } 144 145 PEG_METHOD_EXIT(); 146 147 return; 148 } 149 150 PEGASUS_THREAD_RETURN PEGASUS_THREAD_CDECL 151 BinaryMessageHandler::handle_binary_message(void *parm) 152 { 153 PEG_METHOD_ENTER(TRC_BINARY_MSG_HANDLER, 154 "BinaryMessageHandler::_handle_async_request"); 155 156 BinaryMessageHandler *myself = 157 reinterpret_cast<BinaryMessageHandler *>(parm); 158 159 PEGASUS_ASSERT(myself != 0); 160 161 AsyncOpNode *op; 162 try 163 { 164 op = myself->_msg_q.remove_first(); 165 } 166 catch(...) 167 { 168 PEG_TRACE_STRING(TRC_BINARY_MSG_HANDLER, Tracer::LEVEL4, 169 "Internal DQueue Error."); 170 PEG_METHOD_EXIT(); 171 return(0); 172 } 173 Uint32 msg_type; 174 175 PEGASUS_ASSERT(op != 0); 176 177 // we only receive ASYNC_LEGACY_OP_START and 178 // ASYNC_LEGACY_OP_RESULT messages 179 180 Message *legacy = 0; 181 AsyncMessage *msg = 0; 182 183 // if there is a response, dispatch the response 184 if(op->_response.count()) 185 { 186 msg = static_cast<AsyncMessage *>(op->_response.next(0)); 187 legacy = 188 static_cast<AsyncLegacyOperationResult *>(msg)->get_result(); 189 } 190 else 191 { 192 // there is no response so there has to be a request 193 if(op->_request.count() == 0) 194 { 195 PEG_TRACE_STRING(TRC_BINARY_MSG_HANDLER, Tracer::LEVEL4, 196 "Received OpNode with no messages."); 197 PEG_METHOD_EXIT(); 198 return(0); 199 } 200 // dispatch the request 201 msg = static_cast<AsyncMessage *>(op->_request.next(0)); 202 legacy = 203 static_cast<AsyncLegacyOperationStart *>(msg)->get_action(); 204 } 205 if(msg && legacy) 206 { 207 legacy->_async = 0; 208 209 switch(legacy->getType()) 210 { 211 212 case CIM_CREATE_CLASS_REQUEST_MESSAGE: 213 myself->handleCreateClassRequest( 214 op, (CIMCreateClassRequestMessage *)legacy); 215 break; 216 case CIM_CREATE_INSTANCE_REQUEST_MESSAGE: 217 myself->handleCreateInstanceRequest( 218 op, (CIMCreateInstanceRequestMessage *)legacy); 219 break; 220 case CIM_MODIFY_CLASS_REQUEST_MESSAGE: 221 myself->handleModifyClassRequest( 222 op, (CIMModifyClassRequestMessage *)legacy); 223 break; 224 case CIM_MODIFY_INSTANCE_REQUEST_MESSAGE: 225 myself->handleModifyInstanceRequest( 226 op, (CIMModifyInstanceRequestMessage *)legacy); 227 break; 228 case CIM_ENUMERATE_CLASSES_REQUEST_MESSAGE: //10 229 myself->handleEnumerateClassesRequest( 230 op, (CIMEnumerateClassesRequestMessage *)legacy); 231 break; 232 case CIM_ENUMERATE_CLASS_NAMES_REQUEST_MESSAGE: 233 myself->handleEnumerateClassNamesRequest( 234 op, (CIMEnumerateClassNamesRequestMessage *)legacy); 235 break; 236 case CIM_ENUMERATE_INSTANCES_REQUEST_MESSAGE: 237 myself->handleEnumerateInstancesRequest( 238 op, (CIMEnumerateInstancesRequestMessage *)legacy); 239 break; 240 case CIM_ENUMERATE_INSTANCE_NAMES_REQUEST_MESSAGE: 241 myself->handleEnumerateInstanceNamesRequest( 242 op, (CIMEnumerateInstanceNamesRequestMessage *)legacy); 243 break; 244 case CIM_EXEC_QUERY_REQUEST_MESSAGE: 245 myself->handleExecQueryRequest( 246 op, (CIMExecQueryRequestMessage *)legacy); 247 break; 248 case CIM_ASSOCIATORS_REQUEST_MESSAGE: 249 myself->handleAssociatorsRequest( 250 op, (CIMAssociatorsRequestMessage *)legacy); 251 break; 252 case CIM_ASSOCIATOR_NAMES_REQUEST_MESSAGE: 253 myself->handleAssociatorNamesRequest( 254 op, (CIMAssociatorNamesRequestMessage *)legacy); 255 break; 256 case CIM_REFERENCES_REQUEST_MESSAGE: 257 myself->handleReferencesRequest( 258 op, (CIMReferencesRequestMessage *)legacy); 259 break; 260 case CIM_REFERENCE_NAMES_REQUEST_MESSAGE: 261 myself->handleReferenceNamesRequest( 262 op, (CIMReferenceNamesRequestMessage *)legacy); 263 break; 264 case CIM_GET_PROPERTY_REQUEST_MESSAGE: 265 myself->handleGetPropertyRequest( 266 op, (CIMGetPropertyRequestMessage *)legacy); 267 break; 268 case CIM_SET_PROPERTY_REQUEST_MESSAGE: //20 269 myself->handleSetPropertyRequest( 270 op, (CIMSetPropertyRequestMessage *)legacy); 271 break; 272 case CIM_GET_QUALIFIER_REQUEST_MESSAGE: 273 myself->handleGetQualifierRequest( 274 op, (CIMGetQualifierRequestMessage *)legacy); 275 break; 276 case CIM_SET_QUALIFIER_REQUEST_MESSAGE: 277 myself->handleSetQualifierRequest( 278 op, (CIMSetQualifierRequestMessage *)legacy); 279 break; 280 case CIM_DELETE_QUALIFIER_REQUEST_MESSAGE: 281 myself->handleDeleteQualifiersRequest( 282 op, (CIMDeleteQualifierRequestMessage *)legacy); 283 break; 284 case CIM_ENUMERATE_QUALIFIERS_REQUEST_MESSAGE: 285 myself->handleEnumerateQualifiersRequest( 286 op, (CIMEnumerateQualifiersRequestMessage *)legacy); 287 break; 288 case CIM_INVOKE_METHOD_REQUEST_MESSAGE: 289 myself->handleInvokeMethodRequest( 290 op, (CIMInvokeMethodRequestMessage *)legacy); 291 break; 292 //**** response messages ****// 293 case CIM_GET_CLASS_RESPONSE_MESSAGE: 294 myself->handleGetClassResponse( 295 op, (CIMGetClassResponseMessage *)legacy); 296 break; 297 case CIM_GET_INSTANCE_RESPONSE_MESSAGE: 298 myself->handleGetInstanceResponse( 299 op, (CIMGetInstanceResponseMessage *)legacy); 300 break; 301 case CIM_DELETE_CLASS_RESPONSE_MESSAGE: 302 myself->handleDeleteClassResponse( 303 op, (CIMDeleteClassResponseMessage *)legacy); 304 break; 305 case CIM_DELETE_INSTANCE_RESPONSE_MESSAGE: 306 myself->handleDeleteInstanceResponse( 307 op, (CIMDeleteInstanceResponseMessage *)legacy); 308 break; 309 case CIM_CREATE_CLASS_RESPONSE_MESSAGE: 310 myself->handleCreateClassResponse( 311 op, (CIMCreateClassResponseMessage *)legacy); 312 break; 313 case CIM_CREATE_INSTANCE_RESPONSE_MESSAGE: 314 myself->handleCreateInstanceResponse( 315 op, (CIMCreateInstanceResponseMessage *)legacy); 316 break; 317 case CIM_MODIFY_CLASS_RESPONSE_MESSAGE: 318 myself->handleModifyClassResponse( 319 op, (CIMModifyClassResponseMessage *)legacy); 320 break; 321 case CIM_MODIFY_INSTANCE_RESPONSE_MESSAGE: 322 myself->handleModifyInstanceResponse( 323 op, (CIMModifyInstanceResponseMessage *)legacy); 324 break; 325 case CIM_ENUMERATE_CLASSES_RESPONSE_MESSAGE: 326 myself->handleEnumerateClassesResponse( 327 op, (CIMEnumerateClassesResponseMessage *)legacy); 328 break; 329 case CIM_ENUMERATE_CLASS_NAMES_RESPONSE_MESSAGE: 330 myself->handleEnumerateClassNamesResponse( 331 op, (CIMEnumerateClassNamesResponseMessage *)legacy); 332 break; 333 case CIM_ENUMERATE_INSTANCES_RESPONSE_MESSAGE: 334 myself->handleEnumerateInstancesResponse( 335 op, (CIMEnumerateInstancesResponseMessage *)legacy); 336 break; 337 case CIM_ENUMERATE_INSTANCE_NAMES_RESPONSE_MESSAGE: 338 myself->handleEnumerateInstanceNamesResponse( 339 op, (CIMEnumerateInstanceNamesResponseMessage *)legacy); 340 break; 341 case CIM_EXEC_QUERY_RESPONSE_MESSAGE: 342 myself->handleExecQueryResponse( 343 op, (CIMExecQueryResponseMessage *)legacy); 344 break; 345 case CIM_ASSOCIATORS_RESPONSE_MESSAGE: 346 myself->handleAssociatorsResponse( 347 op, (CIMAssociatorsResponseMessage *)legacy); 348 break; 349 case CIM_ASSOCIATOR_NAMES_RESPONSE_MESSAGE: 350 myself->handleAssociatorNamesResponse( 351 op, (CIMAssociatorNamesResponseMessage *)legacy); 352 break; 353 case CIM_REFERENCES_RESPONSE_MESSAGE: 354 myself->handleReferencesResponse( 355 op, (CIMReferencesResponseMessage *)legacy); 356 break; 357 case CIM_REFERENCE_NAMES_RESPONSE_MESSAGE: 358 myself->handleReferenceNamesResponse( 359 op, (CIMReferenceNamesResponseMessage *)legacy); 360 break; 361 case CIM_GET_PROPERTY_RESPONSE_MESSAGE: 362 myself->handleGetPropertyResponse( 363 op, (CIMGetPropertyResponseMessage *)legacy); 364 break; 365 case CIM_SET_PROPERTY_RESPONSE_MESSAGE: 366 myself->handleSetPropertyResponse( 367 op, (CIMSetPropertyResponseMessage *)legacy); 368 break; 369 case CIM_GET_QUALIFIER_RESPONSE_MESSAGE: 370 myself->handleGetQualifierResponse( 371 op, (CIMGetQualifierResponseMessage *)legacy); 372 break; 373 case CIM_SET_QUALIFIER_RESPONSE_MESSAGE: 374 myself->handleSetQualifierResponse( 375 op, (CIMSetQualifierResponseMessage *)legacy); 376 break; 377 case CIM_DELETE_QUALIFIER_RESPONSE_MESSAGE: 378 myself->handleDeleteQualifierResponse( 379 op, (CIMDeleteQualifierResponseMessage *)legacy); 380 break; 381 case CIM_ENUMERATE_QUALIFIERS_RESPONSE_MESSAGE: 382 myself->handleEnumerateQualifiersResponse( 383 op, (CIMEnumerateQualifiersResponseMessage *)legacy); 384 break; 385 case CIM_INVOKE_METHOD_RESPONSE_MESSAGE: 386 myself->handleInvokeMethodResponse( 387 op, (CIMInvokeMethodResponseMessage *)legacy); 388 break; 389 390 // unexpected requests 391 case CIM_ENABLE_INDICATION_SUBSCRIPTION_REQUEST_MESSAGE: 392 case CIM_MODIFY_INDICATION_SUBSCRIPTION_REQUEST_MESSAGE: 393 case CIM_DISABLE_INDICATION_SUBSCRIPTION_REQUEST_MESSAGE: 394 case CIM_PROCESS_INDICATION_REQUEST_MESSAGE: 395 case CIM_HANDLE_INDICATION_REQUEST_MESSAGE: // 30 396 case CIM_NOTIFY_PROVIDER_REGISTRATION_REQUEST_MESSAGE: 397 case CIM_NOTIFY_PROVIDER_TERMINATION_REQUEST_MESSAGE: 398 399 // new 400 case CIM_ENABLE_INDICATIONS_REQUEST_MESSAGE: 401 case CIM_DISABLE_INDICATIONS_REQUEST_MESSAGE: 402 case CIM_CREATE_SUBSCRIPTION_REQUEST_MESSAGE: 403 case CIM_MODIFY_SUBSCRIPTION_REQUEST_MESSAGE: 404 case CIM_DELETE_SUBSCRIPTION_REQUEST_MESSAGE: 405 406 // new 407 case CIM_DISABLE_MODULE_REQUEST_MESSAGE: 408 case CIM_ENABLE_MODULE_REQUEST_MESSAGE: 409 410 case CIM_STOP_ALL_PROVIDERS_REQUEST_MESSAGE: 411 case CIM_GET_CLASS_REQUEST_MESSAGE: 412 case CIM_GET_INSTANCE_REQUEST_MESSAGE: 413 case CIM_EXPORT_INDICATION_REQUEST_MESSAGE: 414 case CIM_DELETE_CLASS_REQUEST_MESSAGE: 415 case CIM_DELETE_INSTANCE_REQUEST_MESSAGE: 416 PEG_TRACE_STRING(TRC_BINARY_MSG_HANDLER, Tracer::LEVEL4, 417 "Received Unexpected legacy request message."); 418 myself->_handleRequest(op, legacy); 419 break; 420 421 // unexpected replies 422 case CIM_ENABLE_INDICATION_SUBSCRIPTION_RESPONSE_MESSAGE: 423 case CIM_MODIFY_INDICATION_SUBSCRIPTION_RESPONSE_MESSAGE: 424 case CIM_DISABLE_INDICATION_SUBSCRIPTION_RESPONSE_MESSAGE: 425 case CIM_PROCESS_INDICATION_RESPONSE_MESSAGE: 426 case CIM_NOTIFY_PROVIDER_REGISTRATION_RESPONSE_MESSAGE: 427 case CIM_NOTIFY_PROVIDER_TERMINATION_RESPONSE_MESSAGE: 428 case CIM_HANDLE_INDICATION_RESPONSE_MESSAGE: 429 // new 430 case CIM_ENABLE_INDICATIONS_RESPONSE_MESSAGE: 431 case CIM_DISABLE_INDICATIONS_RESPONSE_MESSAGE: 432 case CIM_CREATE_SUBSCRIPTION_RESPONSE_MESSAGE: 433 case CIM_MODIFY_SUBSCRIPTION_RESPONSE_MESSAGE: 434 case CIM_DELETE_SUBSCRIPTION_RESPONSE_MESSAGE: 435 // new 436 case CIM_DISABLE_MODULE_RESPONSE_MESSAGE: 437 case CIM_ENABLE_MODULE_RESPONSE_MESSAGE: 438 case CIM_STOP_ALL_PROVIDERS_RESPONSE_MESSAGE: 439 break; 440 default: 441 case CIM_EXPORT_INDICATION_RESPONSE_MESSAGE: // 42 442 443 PEG_TRACE_STRING(TRC_BINARY_MSG_HANDLER, Tracer::LEVEL4, 444 "Received Unexpected legacy response message."); 445 myself->_handleResponse(op, legacy); 446 break; 447 } 448 } 449 else 450 { 451 PEG_TRACE_STRING(TRC_BINARY_MSG_HANDLER, Tracer::LEVEL4, 452 "Damaged or uninitialized AsyncOpNode recieved."); 453 } 454 455 PEG_METHOD_EXIT(); 456 return(0); 457 } 458 459 // requests always go to the output queue 460 void 461 BinaryMessageHandler::_handleRequest(AsyncOpNode *op, Message *msg) 462 throw() 463 { 464 PEG_METHOD_ENTER(TRC_BINARY_MSG_HANDLER, 465 "BinaryMessageHandler::_handleRequest(AsyncOpNode *, Message *)"); 466 467 AsyncRequest *async_request = static_cast<AsyncRequest *>(op->get_request()); 468 469 msg->_async = 0; 470 try 471 { 472 _outputQueue->enqueue(msg) ; 473 } 474 catch(...) 475 { 476 477 } 478 479 delete async_request; 480 481 _complete_op_node(op, ASYNC_OPSTATE_COMPLETE, 0, 0); 482 PEG_METHOD_EXIT(); 483 } 484 485 // responses have their destination queue id in the message 486 void 487 BinaryMessageHandler::_handleResponse(AsyncOpNode *op, Message *msg) 488 throw() 489 { 490 PEG_METHOD_ENTER(TRC_BINARY_MSG_HANDLER, 491 "BinaryMessageHandler::_handleResponse(AsyncOpNode *, Message *)"); 492 AsyncReply *async_reply = static_cast<AsyncReply *>(op->get_response()); 493 msg->_async = 0; 494 delete async_reply; 495 496 MessageQueue *dest = MessageQueue::lookup(((CIMRequestMessage *)msg)->queueIds.top()); 497 if(dest == 0) 498 { 499 PEG_TRACE_STRING(TRC_BINARY_MSG_HANDLER, Tracer::LEVEL4, 500 "Bad or non-existent Queue ID for desination in legacy message."); 501 delete msg; 502 } 503 else 504 { 505 try 506 { 507 508 dest->enqueue(msg); 509 } 510 catch(...) 511 { 512 } 513 514 } 515 _complete_op_node(op, ASYNC_OPSTATE_COMPLETE, 0, 0); 516 PEG_METHOD_EXIT(); 517 } 518 519 void BinaryMessageHandler::handleCreateClassRequest( 520 AsyncOpNode *op, 521 CIMCreateClassRequestMessage *msg) throw() 522 { 523 PEG_METHOD_ENTER(TRC_BINARY_MSG_HANDLER, 524 "BinaryMessageHandler::handleCreateClassRequest()"); 525 _handleRequest(op, msg); 526 PEG_METHOD_EXIT(); 527 } 528 529 530 void BinaryMessageHandler::handleGetClassRequest( 531 AsyncOpNode *op, 532 CIMGetClassRequestMessage *msg) throw() 533 { 534 PEG_METHOD_ENTER(TRC_BINARY_MSG_HANDLER, 535 "BinaryMessageHandler::handleGetClassRequest()"); 536 _handleRequest(op, msg); 537 PEG_METHOD_EXIT(); 538 } 539 540 541 void BinaryMessageHandler::handleModifyClassRequest( 542 AsyncOpNode *op, 543 CIMModifyClassRequestMessage *msg) throw() 544 { 545 PEG_METHOD_ENTER(TRC_BINARY_MSG_HANDLER, 546 "BinaryMessageHandler::handleModifyClassRequest()"); 547 _handleRequest(op, msg); 548 PEG_METHOD_EXIT(); 549 } 550 551 void BinaryMessageHandler::handleEnumerateClassNamesRequest( 552 AsyncOpNode *op, 553 CIMEnumerateClassNamesRequestMessage *msg) throw() 554 { 555 PEG_METHOD_ENTER(TRC_BINARY_MSG_HANDLER, 556 "BinaryMessageHandler::handleEnumerateClassNamesRequest()"); 557 _handleRequest(op, msg); 558 PEG_METHOD_EXIT(); 559 } 560 561 void BinaryMessageHandler::handleEnumerateClassesRequest( 562 AsyncOpNode *op, 563 CIMEnumerateClassesRequestMessage *msg) throw() 564 { 565 PEG_METHOD_ENTER(TRC_BINARY_MSG_HANDLER, 566 "BinaryMessageHandler::handleEnumerateClassRequest()"); 567 _handleRequest(op, msg); 568 PEG_METHOD_EXIT(); 569 } 570 571 572 void BinaryMessageHandler::handleDeleteClassRequest( 573 AsyncOpNode *op, 574 CIMDeleteClassRequestMessage *msg) throw() 575 { 576 PEG_METHOD_ENTER(TRC_BINARY_MSG_HANDLER, 577 "BinaryMessageHandler::handleDeleteClassRequest()"); 578 _handleRequest(op, msg); 579 PEG_METHOD_EXIT(); 580 } 581 582 void BinaryMessageHandler::handleCreateInstanceRequest( 583 AsyncOpNode *op, 584 CIMCreateInstanceRequestMessage *msg) throw() 585 { 586 PEG_METHOD_ENTER(TRC_BINARY_MSG_HANDLER, 587 "BinaryMessageHandler::handleCreateInstanceRequest()"); 588 _handleRequest(op, msg); 589 PEG_METHOD_EXIT(); 590 } 591 592 void BinaryMessageHandler::handleGetInstanceRequest( 593 AsyncOpNode *op, 594 CIMGetInstanceRequestMessage *msg) throw() 595 { 596 PEG_METHOD_ENTER(TRC_BINARY_MSG_HANDLER, 597 "BinaryMessageHandler::handleGetInstanceRequest()"); 598 _handleRequest(op, msg); 599 PEG_METHOD_EXIT(); 600 } 601 602 void BinaryMessageHandler::handleModifyInstanceRequest( 603 AsyncOpNode *op, 604 CIMModifyInstanceRequestMessage *msg) throw() 605 { 606 PEG_METHOD_ENTER(TRC_BINARY_MSG_HANDLER, 607 "BinaryMessageHandler::handleModifyInstanceRequest()"); 608 _handleRequest(op, msg); 609 PEG_METHOD_EXIT(); 610 } 611 612 void BinaryMessageHandler::handleEnumerateInstanceNamesRequest( 613 AsyncOpNode *op, 614 CIMEnumerateInstanceNamesRequestMessage *msg) throw() 615 { 616 PEG_METHOD_ENTER(TRC_BINARY_MSG_HANDLER, 617 "BinaryMessageHandler::handleEnumerateInstanceNamesRequest()"); 618 _handleRequest(op, msg); 619 PEG_METHOD_EXIT(); 620 } 621 622 void BinaryMessageHandler::handleEnumerateInstancesRequest( 623 AsyncOpNode *op, 624 CIMEnumerateInstancesRequestMessage *msg) throw() 625 { 626 PEG_METHOD_ENTER(TRC_BINARY_MSG_HANDLER, 627 "BinaryMessageHandler::handleEnumerateInstancesRequest()"); 628 _handleRequest(op, msg); 629 PEG_METHOD_EXIT(); 630 } 631 632 void BinaryMessageHandler::handleDeleteInstanceRequest( 633 AsyncOpNode *op, 634 CIMDeleteInstanceRequestMessage *msg) throw() 635 { 636 PEG_METHOD_ENTER(TRC_BINARY_MSG_HANDLER, 637 "BinaryMessageHandler::handleDeleteInstanceRequest()"); 638 _handleRequest(op, msg); 639 PEG_METHOD_EXIT(); 640 } 641 642 void BinaryMessageHandler::handleSetQualifierRequest( 643 AsyncOpNode *op, 644 CIMSetQualifierRequestMessage *msg) throw() 645 { 646 PEG_METHOD_ENTER(TRC_BINARY_MSG_HANDLER, 647 "BinaryMessageHandler::handleSetQualifierRequest()"); 648 _handleRequest(op, msg); 649 PEG_METHOD_EXIT(); 650 } 651 652 void BinaryMessageHandler::handleGetQualifierRequest( 653 AsyncOpNode *op, 654 CIMGetQualifierRequestMessage *msg) throw() 655 { 656 PEG_METHOD_ENTER(TRC_BINARY_MSG_HANDLER, 657 "BinaryMessageHandler::handleGetQualifierRequest()"); 658 _handleRequest(op, msg); 659 PEG_METHOD_EXIT(); 660 } 661 662 void BinaryMessageHandler::handleEnumerateQualifiersRequest( 663 AsyncOpNode *op, 664 CIMEnumerateQualifiersRequestMessage *msg) throw() 665 { 666 PEG_METHOD_ENTER(TRC_BINARY_MSG_HANDLER, 667 "BinaryMessageHandler::handleEnumerateQualifiersRequest()"); 668 _handleRequest(op, msg); 669 PEG_METHOD_EXIT(); 670 } 671 672 void BinaryMessageHandler::handleDeleteQualifiersRequest( 673 AsyncOpNode *op, 674 CIMDeleteQualifierRequestMessage *msg) throw() 675 { 676 PEG_METHOD_ENTER(TRC_BINARY_MSG_HANDLER, 677 "BinaryMessageHandler::handleDeleteQualifiersRequest()"); 678 _handleRequest(op, msg); 679 PEG_METHOD_EXIT(); 680 } 681 682 void BinaryMessageHandler::handleReferenceNamesRequest( 683 AsyncOpNode *op, 684 CIMReferenceNamesRequestMessage *msg) throw() 685 { 686 PEG_METHOD_ENTER(TRC_BINARY_MSG_HANDLER, 687 "BinaryMessageHandler::handleReferenceNamesRequest()"); 688 _handleRequest(op, msg); 689 PEG_METHOD_EXIT(); 690 } 691 692 void BinaryMessageHandler::handleReferencesRequest( 693 AsyncOpNode *op, 694 CIMReferencesRequestMessage *msg) throw() 695 { 696 PEG_METHOD_ENTER(TRC_BINARY_MSG_HANDLER, 697 "BinaryMessageHandler::handleReferencesRequest()"); 698 _handleRequest(op, msg); 699 PEG_METHOD_EXIT(); 700 } 701 702 void BinaryMessageHandler::handleAssociatorNamesRequest( 703 AsyncOpNode *op, 704 CIMAssociatorNamesRequestMessage *msg) throw() 705 { 706 PEG_METHOD_ENTER(TRC_BINARY_MSG_HANDLER, 707 "BinaryMessageHandler::handleAssociatorNamesRequest()"); 708 _handleRequest(op, msg); 709 PEG_METHOD_EXIT(); 710 } 711 712 void BinaryMessageHandler::handleAssociatorsRequest( 713 AsyncOpNode *op, 714 CIMAssociatorsRequestMessage *msg) throw() 715 { 716 PEG_METHOD_ENTER(TRC_BINARY_MSG_HANDLER, 717 "BinaryMessageHandler::handleAssociatorsRequest()"); 718 _handleRequest(op, msg); 719 PEG_METHOD_EXIT(); 720 } 721 722 void BinaryMessageHandler::handleGetPropertyRequest( 723 AsyncOpNode *op, 724 CIMGetPropertyRequestMessage *msg) throw() 725 { 726 PEG_METHOD_ENTER(TRC_BINARY_MSG_HANDLER, 727 "BinaryMessageHandler::handleGetPropertyRequest()"); 728 _handleRequest(op, msg); 729 PEG_METHOD_EXIT(); 730 } 731 732 void BinaryMessageHandler::handleSetPropertyRequest( 733 AsyncOpNode *op, 734 CIMSetPropertyRequestMessage *msg) throw() 735 { 736 PEG_METHOD_ENTER(TRC_BINARY_MSG_HANDLER, 737 "BinaryMessageHandler::handleSetPropertyRequest()"); 738 _handleRequest(op, msg); 739 PEG_METHOD_EXIT(); 740 } 741 742 void BinaryMessageHandler::handleExecQueryRequest( 743 AsyncOpNode *op, 744 CIMExecQueryRequestMessage *msg) throw() 745 { 746 PEG_METHOD_ENTER(TRC_BINARY_MSG_HANDLER, 747 "BinaryMessageHandler::handleExecQueryRequest()"); 748 _handleRequest(op, msg); 749 PEG_METHOD_EXIT(); 750 } 751 752 void BinaryMessageHandler::handleInvokeMethodRequest( 753 AsyncOpNode *op, 754 CIMInvokeMethodRequestMessage *msg) throw() 755 { 756 PEG_METHOD_ENTER(TRC_BINARY_MSG_HANDLER, 757 "BinaryMessageHandler::handleInvokeMethodRequest()"); 758 _handleRequest(op, msg); 759 PEG_METHOD_EXIT(); 760 } 761 762 // **** Response Messages **** // 763 764 void BinaryMessageHandler::handleCreateClassResponse( 765 AsyncOpNode *op, 766 CIMCreateClassResponseMessage *msg) throw() 767 { 768 PEG_METHOD_ENTER(TRC_BINARY_MSG_HANDLER, 769 "BinaryMessageHandler::handleCreateClassResponse()"); 770 _handleResponse(op, msg); 771 PEG_METHOD_EXIT(); 772 } 773 774 void BinaryMessageHandler::handleGetClassResponse( 775 AsyncOpNode *op, 776 CIMGetClassResponseMessage *msg) throw() 777 { 778 PEG_METHOD_ENTER(TRC_BINARY_MSG_HANDLER, 779 "BinaryMessageHandler::handleGetClassResponse()"); 780 _handleResponse(op, msg); 781 PEG_METHOD_EXIT(); 782 } 783 784 void BinaryMessageHandler::handleModifyClassResponse( 785 AsyncOpNode *op, 786 CIMModifyClassResponseMessage *msg) throw() 787 { 788 PEG_METHOD_ENTER(TRC_BINARY_MSG_HANDLER, 789 "BinaryMessageHandler::handleModifyClassResponse()"); 790 _handleResponse(op, msg); 791 PEG_METHOD_EXIT(); 792 } 793 794 void BinaryMessageHandler::handleEnumerateClassNamesResponse( 795 AsyncOpNode *op, 796 CIMEnumerateClassNamesResponseMessage *msg) throw() 797 { 798 PEG_METHOD_ENTER(TRC_BINARY_MSG_HANDLER, 799 "BinaryMessageHandler::handleEnumerateClassNamesResponse()"); 800 _handleResponse(op, msg); 801 PEG_METHOD_EXIT(); 802 } 803 804 void BinaryMessageHandler::handleEnumerateClassesResponse( 805 AsyncOpNode *op, 806 CIMEnumerateClassesResponseMessage *msg) throw() 807 { 808 PEG_METHOD_ENTER(TRC_BINARY_MSG_HANDLER, 809 "BinaryMessageHandler::handleEnumerateClassesResponse()"); 810 _handleResponse(op, msg); 811 PEG_METHOD_EXIT(); 812 } 813 814 void BinaryMessageHandler::handleDeleteClassResponse( 815 AsyncOpNode *op, 816 CIMDeleteClassResponseMessage *msg) throw() 817 { 818 PEG_METHOD_ENTER(TRC_BINARY_MSG_HANDLER, 819 "BinaryMessageHandler::handleDeleteClassResponse()"); 820 _handleResponse(op, msg); 821 PEG_METHOD_EXIT(); 822 } 823 824 void BinaryMessageHandler::handleCreateInstanceResponse( 825 AsyncOpNode *op, 826 CIMCreateInstanceResponseMessage *msg) throw() 827 { 828 PEG_METHOD_ENTER(TRC_BINARY_MSG_HANDLER, 829 "BinaryMessageHandler::handleCreateInstanceResponse()"); 830 _handleResponse(op, msg); 831 PEG_METHOD_EXIT(); 832 } 833 834 void BinaryMessageHandler::handleGetInstanceResponse( 835 AsyncOpNode *op, 836 CIMGetInstanceResponseMessage *msg) throw() 837 { 838 PEG_METHOD_ENTER(TRC_BINARY_MSG_HANDLER, 839 "BinaryMessageHandler::handleGetInstanceResponse()"); 840 _handleResponse(op, msg); 841 PEG_METHOD_EXIT(); 842 } 843 844 void BinaryMessageHandler::handleModifyInstanceResponse( 845 AsyncOpNode *op, 846 CIMModifyInstanceResponseMessage *msg) throw() 847 { 848 PEG_METHOD_ENTER(TRC_BINARY_MSG_HANDLER, 849 "BinaryMessageHandler::handleModifyInstanceResponse()"); 850 _handleResponse(op, msg); 851 PEG_METHOD_EXIT(); 852 } 853 854 void BinaryMessageHandler::handleEnumerateInstanceNamesResponse( 855 AsyncOpNode *op, 856 CIMEnumerateInstanceNamesResponseMessage *msg) throw() 857 { 858 PEG_METHOD_ENTER(TRC_BINARY_MSG_HANDLER, 859 "BinaryMessageHandler::handleEnumerateInstanceNamesResponse()"); 860 _handleResponse(op, msg); 861 PEG_METHOD_EXIT(); 862 } 863 864 void BinaryMessageHandler::handleEnumerateInstancesResponse( 865 AsyncOpNode *op, 866 CIMEnumerateInstancesResponseMessage *msg) throw() 867 { 868 PEG_METHOD_ENTER(TRC_BINARY_MSG_HANDLER, 869 "BinaryMessageHandler::handleEnumerateInstancesResponse()"); 870 _handleResponse(op, msg); 871 PEG_METHOD_EXIT(); 872 } 873 874 void BinaryMessageHandler::handleDeleteInstanceResponse( 875 AsyncOpNode *op, 876 CIMDeleteInstanceResponseMessage *msg) throw() 877 { 878 PEG_METHOD_ENTER(TRC_BINARY_MSG_HANDLER, 879 "BinaryMessageHandler::handleDeleteInstanceResponse()"); 880 _handleResponse(op, msg); 881 PEG_METHOD_EXIT(); 882 } 883 884 void BinaryMessageHandler::handleGetPropertyResponse( 885 AsyncOpNode *op, 886 CIMGetPropertyResponseMessage *msg) throw() 887 { 888 PEG_METHOD_ENTER(TRC_BINARY_MSG_HANDLER, 889 "BinaryMessageHandler::handleGetPropertyResponse()"); 890 _handleResponse(op, msg); 891 PEG_METHOD_EXIT(); 892 } 893 894 void BinaryMessageHandler::handleSetPropertyResponse( 895 AsyncOpNode *op, 896 CIMSetPropertyResponseMessage *msg) throw() 897 { 898 PEG_METHOD_ENTER(TRC_BINARY_MSG_HANDLER, 899 "BinaryMessageHandler::handleSetPropertyResponse()"); 900 _handleResponse(op, msg); 901 PEG_METHOD_EXIT(); 902 } 903 904 905 void BinaryMessageHandler::handleSetQualifierResponse( 906 AsyncOpNode *op, 907 CIMSetQualifierResponseMessage *msg) throw() 908 { 909 PEG_METHOD_ENTER(TRC_BINARY_MSG_HANDLER, 910 "BinaryMessageHandler::handleSetQualifierResponse()"); 911 _handleResponse(op, msg); 912 PEG_METHOD_EXIT(); 913 } 914 915 void BinaryMessageHandler::handleGetQualifierResponse( 916 AsyncOpNode *op, 917 CIMGetQualifierResponseMessage *msg) throw() 918 { 919 PEG_METHOD_ENTER(TRC_BINARY_MSG_HANDLER, 920 "BinaryMessageHandler::handleGetQualifierResponse()"); 921 _handleResponse(op, msg); 922 PEG_METHOD_EXIT(); 923 } 924 925 void BinaryMessageHandler::handleEnumerateQualifiersResponse( 926 AsyncOpNode *op, 927 CIMEnumerateQualifiersResponseMessage *msg) throw() 928 { 929 PEG_METHOD_ENTER(TRC_BINARY_MSG_HANDLER, 930 "BinaryMessageHandler::handleEnumerateQualifiersResponse()"); 931 _handleResponse(op, msg); 932 PEG_METHOD_EXIT(); 933 } 934 935 void BinaryMessageHandler::handleDeleteQualifierResponse( 936 AsyncOpNode *op, 937 CIMDeleteQualifierResponseMessage *msg) throw() 938 { 939 PEG_METHOD_ENTER(TRC_BINARY_MSG_HANDLER, 940 "BinaryMessageHandler::handleDeleteQualifierResponse()"); 941 _handleResponse(op, msg); 942 PEG_METHOD_EXIT(); 943 } 944 945 void BinaryMessageHandler::handleReferenceNamesResponse( 946 AsyncOpNode *op, 947 CIMReferenceNamesResponseMessage *msg) throw() 948 { 949 PEG_METHOD_ENTER(TRC_BINARY_MSG_HANDLER, 950 "BinaryMessageHandler::handleReferenceNamesResponse()"); 951 _handleResponse(op, msg); 952 PEG_METHOD_EXIT(); 953 } 954 955 void BinaryMessageHandler::handleReferencesResponse( 956 AsyncOpNode *op, 957 CIMReferencesResponseMessage *msg) throw() 958 { 959 PEG_METHOD_ENTER(TRC_BINARY_MSG_HANDLER, 960 "BinaryMessageHandler::handleReferencesResponse()"); 961 _handleResponse(op, msg); 962 PEG_METHOD_EXIT(); 963 } 964 965 void BinaryMessageHandler::handleAssociatorNamesResponse( 966 AsyncOpNode *op, 967 CIMAssociatorNamesResponseMessage *msg) throw() 968 { 969 PEG_METHOD_ENTER(TRC_BINARY_MSG_HANDLER, 970 "BinaryMessageHandler::handleAssociatorNamesResponse()"); 971 _handleResponse(op, msg); 972 PEG_METHOD_EXIT(); 973 } 974 975 void BinaryMessageHandler::handleAssociatorsResponse( 976 AsyncOpNode *op, 977 CIMAssociatorsResponseMessage *msg) throw() 978 { 979 PEG_METHOD_ENTER(TRC_BINARY_MSG_HANDLER, 980 "BinaryMessageHandler::handleAssociatorsResponse()"); 981 _handleResponse(op, msg); 982 PEG_METHOD_EXIT(); 983 } 984 985 void BinaryMessageHandler::handleExecQueryResponse( 986 AsyncOpNode *op, 987 CIMExecQueryResponseMessage *msg) throw() 988 { 989 PEG_METHOD_ENTER(TRC_BINARY_MSG_HANDLER, 990 "BinaryMessageHandler::handleExecQueryResponse()"); 991 _handleResponse(op, msg); 992 PEG_METHOD_EXIT(); 993 } 994 995 996 void BinaryMessageHandler::handleInvokeMethodResponse( 997 AsyncOpNode *op, 998 CIMInvokeMethodResponseMessage *msg) throw() 999 { 1000 PEG_METHOD_ENTER(TRC_BINARY_MSG_HANDLER, 1001 "BinaryMessageHandler::handleInvokeMethodResponse()"); 1002 _handleResponse(op, msg); 1003 PEG_METHOD_EXIT(); 1004 } 1005 1006 PEGASUS_NAMESPACE_END
Existing client operations arrive at Pegasus as CIM/XML documents and are decoded into CIMMessage objects. Then they are dispatched to Pegasus. Responses are encoded from CIMMessage objects back into CIM/XML documents.