(file) Return to CIMListenerIndicationDispatcher.cpp CVS log (file) (dir) Up to [Pegasus] / pegasus / src / Pegasus / Listener

Diff for /pegasus/src/Pegasus/Listener/CIMListenerIndicationDispatcher.cpp between version 1.10 and 1.21

version 1.10, 2005/06/24 19:34:25 version 1.21, 2008/12/01 17:50:44
Line 1 
Line 1 
 //%2005////////////////////////////////////////////////////////////////////////  //%LICENSE////////////////////////////////////////////////////////////////
 // //
 // Copyright (c) 2000, 2001, 2002 BMC Software; Hewlett-Packard Development  // Licensed to The Open Group (TOG) under one or more contributor license
 // Company, L.P.; IBM Corp.; The Open Group; Tivoli Systems.  // agreements.  Refer to the OpenPegasusNOTICE.txt file distributed with
 // Copyright (c) 2003 BMC Software; Hewlett-Packard Development Company, L.P.;  // this work for additional information regarding copyright ownership.
 // IBM Corp.; EMC Corporation, The Open Group.  // Each contributor licenses this file to you under the OpenPegasus Open
 // Copyright (c) 2004 BMC Software; Hewlett-Packard Development Company, L.P.;  // Source License; you may not use this file except in compliance with the
 // IBM Corp.; EMC Corporation; VERITAS Software Corporation; The Open Group.  // License.
 // Copyright (c) 2005 Hewlett-Packard Development Company, L.P.; IBM Corp.;  
 // EMC Corporation; VERITAS Software Corporation; The Open Group.  
 // //
 // Permission is hereby granted, free of charge, to any person obtaining a copy  // Permission is hereby granted, free of charge, to any person obtaining a
 // of this software and associated documentation files (the "Software"), to  // copy of this software and associated documentation files (the "Software"),
 // deal in the Software without restriction, including without limitation the  // to deal in the Software without restriction, including without limitation
 // rights to use, copy, modify, merge, publish, distribute, sublicense, and/or  // the rights to use, copy, modify, merge, publish, distribute, sublicense,
 // sell copies of the Software, and to permit persons to whom the Software is  // and/or sell copies of the Software, and to permit persons to whom the
 // furnished to do so, subject to the following conditions:  // Software is furnished to do so, subject to the following conditions:
 // //
 // THE ABOVE COPYRIGHT NOTICE AND THIS PERMISSION NOTICE SHALL BE INCLUDED IN  // The above copyright notice and this permission notice shall be included
 // ALL COPIES OR SUBSTANTIAL PORTIONS OF THE SOFTWARE. THE SOFTWARE IS PROVIDED  // in all copies or substantial portions of the Software.
 // "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT  
 // LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR  
 // PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT  
 // HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN  
 // ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION  
 // WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.  
 // //
 //==============================================================================  // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
   // OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
   // MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
   // IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
   // CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
   // TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
   // SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
 // //
 //  //////////////////////////////////////////////////////////////////////////
 // Author: Dong Xiang, EMC Corporation (xiang_dong@emc.com)  
 //  
 // Modified By: Seema Gupta (gseema@in.ibm.com) for PEP135  
 // //
 //%///////////////////////////////////////////////////////////////////////////// //%/////////////////////////////////////////////////////////////////////////////
  
Line 45 
Line 40 
  
 #include <Pegasus/Listener/List.h> #include <Pegasus/Listener/List.h>
 #include <Pegasus/Consumer/CIMIndicationConsumer.h> #include <Pegasus/Consumer/CIMIndicationConsumer.h>
 #include <Pegasus/Common/ContentLanguages.h>  #include <Pegasus/Common/ContentLanguageList.h>
  
 PEGASUS_NAMESPACE_BEGIN PEGASUS_NAMESPACE_BEGIN
  
Line 58 
Line 53 
         CIMListenerIndicationDispatchEvent(CIMIndicationConsumer* consumer,         CIMListenerIndicationDispatchEvent(CIMIndicationConsumer* consumer,
                                            String url,                                            String url,
                                            CIMInstance instance,                                            CIMInstance instance,
                                            ContentLanguages contentLangs);                                             ContentLanguageList contentLangs);
         ~CIMListenerIndicationDispatchEvent();         ~CIMListenerIndicationDispatchEvent();
  
         CIMIndicationConsumer* getConsumer() const;         CIMIndicationConsumer* getConsumer() const;
  
         String getURL() const;         String getURL() const;
         CIMInstance getIndicationInstance() const;         CIMInstance getIndicationInstance() const;
         ContentLanguages getContentLanguages() const;          ContentLanguageList getContentLanguages() const;
  
 private: private:
         CIMIndicationConsumer*  _consumer;         CIMIndicationConsumer*  _consumer;
         String                                                                  _url;         String                                                                  _url;
         CIMInstance                                                     _instance;         CIMInstance                                                     _instance;
         ContentLanguages                    _contentLangs;      ContentLanguageList     _contentLangs;
 }; };
  
 CIMListenerIndicationDispatchEvent::CIMListenerIndicationDispatchEvent(CIMIndicationConsumer* consumer,  CIMListenerIndicationDispatchEvent::CIMListenerIndicationDispatchEvent(
       CIMIndicationConsumer* consumer,
                                                                        String url,                                                                        String url,
                                                                        CIMInstance instance,                                                                        CIMInstance instance,
                                                                        ContentLanguages contentLangs)      ContentLanguageList contentLangs)
 :_consumer(consumer),_url(url),_instance(instance), _contentLangs(contentLangs) :_consumer(consumer),_url(url),_instance(instance), _contentLangs(contentLangs)
 { {
 } }
Line 96 
Line 92 
 { {
         return _instance;         return _instance;
 } }
 ContentLanguages CIMListenerIndicationDispatchEvent::getContentLanguages() const  ContentLanguageList
       CIMListenerIndicationDispatchEvent::getContentLanguages() const
 { {
         return _contentLangs;         return _contentLangs;
 } }
Line 113 
Line 110 
         Boolean addConsumer(CIMIndicationConsumer* consumer);         Boolean addConsumer(CIMIndicationConsumer* consumer);
         Boolean removeConsumer(CIMIndicationConsumer* consumer);         Boolean removeConsumer(CIMIndicationConsumer* consumer);
  
         CIMExportIndicationResponseMessage* handleIndicationRequest(CIMExportIndicationRequestMessage* request);      CIMExportIndicationResponseMessage* handleIndicationRequest(
           CIMExportIndicationRequestMessage* request);
  
  
         static PEGASUS_THREAD_RETURN PEGASUS_THREAD_CDECL deliver_routine(void *param);      static ThreadReturnType PEGASUS_THREAD_CDECL deliver_routine(void *param);
  
 private: private:
         void    deliverIndication(String url, CIMInstance instance, ContentLanguages contentLangs);      void    deliverIndication(String url,
                                 CIMInstance instance,
                                 ContentLanguageList contentLangs);
  
         ThreadPool* _thread_pool;         ThreadPool* _thread_pool;
         PtrList*                _consumers;         PtrList*                _consumers;
Line 130 
Line 130 
  
 CIMListenerIndicationDispatcherRep::CIMListenerIndicationDispatcherRep() CIMListenerIndicationDispatcherRep::CIMListenerIndicationDispatcherRep()
 :_thread_pool(new ThreadPool(0, "ListenerIndicationDispatcher", 0, 0, :_thread_pool(new ThreadPool(0, "ListenerIndicationDispatcher", 0, 0,
         deallocateWait))      deallocateWait)), _consumers(new PtrList())
 ,_consumers(new PtrList())  
 { {
  
 } }
Line 141 
Line 140 
         delete _consumers;         delete _consumers;
 } }
  
 Boolean CIMListenerIndicationDispatcherRep::addConsumer(CIMIndicationConsumer* consumer)  Boolean CIMListenerIndicationDispatcherRep::addConsumer(
       CIMIndicationConsumer* consumer)
 { {
         _consumers->add(consumer);         _consumers->add(consumer);
         return true;         return true;
 } }
 Boolean CIMListenerIndicationDispatcherRep::removeConsumer(CIMIndicationConsumer* consumer)  Boolean CIMListenerIndicationDispatcherRep::removeConsumer(
       CIMIndicationConsumer* consumer)
 { {
         _consumers->remove(consumer);         _consumers->remove(consumer);
         return true;         return true;
 } }
 CIMExportIndicationResponseMessage* CIMListenerIndicationDispatcherRep::handleIndicationRequest(CIMExportIndicationRequestMessage* request)  CIMExportIndicationResponseMessage*
   CIMListenerIndicationDispatcherRep::handleIndicationRequest(
       CIMExportIndicationRequestMessage* request)
 { {
         PEG_METHOD_ENTER(TRC_SERVER,         PEG_METHOD_ENTER(TRC_SERVER,
                 "CIMListenerIndicationDispatcherRep::handleIndicationRequest");                 "CIMListenerIndicationDispatcherRep::handleIndicationRequest");
  
         CIMInstance instance = request->indicationInstance;         CIMInstance instance = request->indicationInstance;
         String                  url = request->destinationPath;         String                  url = request->destinationPath;
     ContentLanguages contentLangs =((ContentLanguageListContainer)request->operationContext.      ContentLanguageList contentLangs =
           ((ContentLanguageListContainer)request->operationContext.
                                                             get(ContentLanguageListContainer::NAME)).getLanguages();                                                             get(ContentLanguageListContainer::NAME)).getLanguages();
  
         deliverIndication(url,instance,contentLangs);         deliverIndication(url,instance,contentLangs);
Line 166 
Line 170 
         // compose a response message         // compose a response message
         CIMException cimException;         CIMException cimException;
  
         CIMExportIndicationResponseMessage* response = new CIMExportIndicationResponseMessage(      CIMExportIndicationResponseMessage* response =
                 request->messageId,          dynamic_cast<CIMExportIndicationResponseMessage*>(
                 cimException,              request->buildResponse());
                 request->queueIds.copyAndPop());      response->cimException = cimException;
   
         response->dest = request->queueIds.top();         response->dest = request->queueIds.top();
  
         PEG_METHOD_EXIT();         PEG_METHOD_EXIT();
Line 180 
Line 183 
  
 void CIMListenerIndicationDispatcherRep::deliverIndication(String url, void CIMListenerIndicationDispatcherRep::deliverIndication(String url,
                                                            CIMInstance instance,                                                            CIMInstance instance,
                                                            ContentLanguages contentLangs)      ContentLanguageList contentLangs)
 { {
         // go thru all consumers and broadcast the result; should be run in seperate thread      // go thru all consumers and broadcast the result;
         Iterator* it = _consumers->iterator();      // should be run in seperate thread
           AutoPtr<Iterator> it( _consumers->iterator() );
   
         while(it->hasNext()==true)         while(it->hasNext()==true)
         {         {
                 CIMIndicationConsumer* consumer = static_cast<CIMIndicationConsumer*>(it->next());          CIMIndicationConsumer* consumer =
                 CIMListenerIndicationDispatchEvent* event = new CIMListenerIndicationDispatchEvent(              static_cast<CIMIndicationConsumer*>(it->next());
                                                                                      consumer,          CIMListenerIndicationDispatchEvent* event =
               new CIMListenerIndicationDispatchEvent(consumer,
                                                                                      url,                                                                                      url,
                                                                                      instance,                                                                                      instance,
                                                                                      contentLangs);                                                                                      contentLangs);
                 ThreadStatus rtn = _thread_pool->allocate_and_awaken(event,deliver_routine);          ThreadStatus rtn = _thread_pool->allocate_and_awaken(
                                   event,deliver_routine);
  
                 if (rtn != PEGASUS_THREAD_OK)                 if (rtn != PEGASUS_THREAD_OK)
                 {                 {
                     Logger::put(Logger::STANDARD_LOG, System::CIMSERVER, Logger::TRACE,                  PEG_TRACE_CSTRING(
                                 "Not enough threads to allocate a worker to deliver the event. ");                      TRC_SERVER,
                       Tracer::LEVEL1,
                     Tracer::trace(TRC_SERVER, Tracer::LEVEL2,                      "Could not allocate thread to deliver event."
                                 "Could not allocate thread to deliver event. Instead using current thread.");                          " Instead using current thread.");
                     delete event;                     delete event;
                     throw Exception(MessageLoaderParms("Listener.CIMListenerIndicationDispatcher.CANNOT_ALLOCATE_THREAD",              throw Exception(MessageLoaderParms(
                                         "Not enough threads to allocate a worker to deliver the event."));                  "Listener.CIMListenerIndicationDispatcher."
                       "CANNOT_ALLOCATE_THREAD",
                   "Not enough threads to allocate a worker to deliver the"
                       " event."));
                 }                 }
         }         }
 } }
 PEGASUS_THREAD_RETURN PEGASUS_THREAD_CDECL CIMListenerIndicationDispatcherRep::deliver_routine(void *param)  ThreadReturnType PEGASUS_THREAD_CDECL
   CIMListenerIndicationDispatcherRep::deliver_routine(void *param)
 { {
         CIMListenerIndicationDispatchEvent* event = static_cast<CIMListenerIndicationDispatchEvent*>(param);      CIMListenerIndicationDispatchEvent* event =
           static_cast<CIMListenerIndicationDispatchEvent*>(param);
  
         if(event!=NULL)         if(event!=NULL)
         {         {
                 CIMIndicationConsumer* consumer = event->getConsumer();                 CIMIndicationConsumer* consumer = event->getConsumer();
                 OperationContext context;                 OperationContext context;
                 context.insert(ContentLanguageListContainer(event->getContentLanguages()));              context.insert(ContentLanguageListContainer(
                           event->getContentLanguages()));
                 if(consumer)                 if(consumer)
                 {                 {
                         consumer->consumeIndication(context,event->getURL(),event->getIndicationInstance());              consumer->consumeIndication(context,
                   event->getURL(),event->getIndicationInstance());
                 }                 }
  
                 delete event;                 delete event;
Line 245 
Line 259 
  
 void CIMListenerIndicationDispatcher::handleEnqueue() void CIMListenerIndicationDispatcher::handleEnqueue()
 { {
         PEG_METHOD_ENTER(TRC_SERVER, "CIMListenerIndicationDispatcher::handleEnqueue");      PEG_METHOD_ENTER(TRC_SERVER,
           "CIMListenerIndicationDispatcher::handleEnqueue");
  
         Message *message = dequeue();         Message *message = dequeue();
         if(message)         if(message)
Line 256 
Line 271 
  
 void CIMListenerIndicationDispatcher::handleEnqueue(Message* message) void CIMListenerIndicationDispatcher::handleEnqueue(Message* message)
 { {
         PEG_METHOD_ENTER(TRC_SERVER, "CIMListenerIndicationDispatcher::handleEnqueue");      PEG_METHOD_ENTER(TRC_SERVER,
           "CIMListenerIndicationDispatcher::handleEnqueue");
  
         if(message!=NULL)         if(message!=NULL)
         {         {
Line 264 
Line 280 
     {     {
                         case CIM_EXPORT_INDICATION_REQUEST_MESSAGE:                         case CIM_EXPORT_INDICATION_REQUEST_MESSAGE:
                                 {                                 {
                                         CIMExportIndicationRequestMessage* request = (CIMExportIndicationRequestMessage*)message;                      CIMExportIndicationRequestMessage* request =
                           (CIMExportIndicationRequestMessage*)message;
  
                                         CIMExportIndicationResponseMessage* response =                                         CIMExportIndicationResponseMessage* response =
                                                 static_cast<CIMListenerIndicationDispatcherRep*>(_rep)->handleIndicationRequest(request);                          static_cast<CIMListenerIndicationDispatcherRep*>(_rep)->
                               handleIndicationRequest(request);
  
                                         _enqueueResponse(request, response);                                         _enqueueResponse(request, response);
                                 }                                 }
Line 280 
Line 298 
  
         PEG_METHOD_EXIT();         PEG_METHOD_EXIT();
 } }
 Boolean CIMListenerIndicationDispatcher::addConsumer(CIMIndicationConsumer* consumer)  Boolean CIMListenerIndicationDispatcher::addConsumer(
       CIMIndicationConsumer* consumer)
 { {
         return static_cast<CIMListenerIndicationDispatcherRep*>(_rep)->addConsumer(consumer);      return static_cast<CIMListenerIndicationDispatcherRep*>(_rep)->addConsumer(
               consumer);
 } }
 Boolean CIMListenerIndicationDispatcher::removeConsumer(CIMIndicationConsumer* consumer)  Boolean CIMListenerIndicationDispatcher::removeConsumer(
           CIMIndicationConsumer* consumer)
 { {
         return static_cast<CIMListenerIndicationDispatcherRep*>(_rep)->removeConsumer(consumer);      return static_cast<CIMListenerIndicationDispatcherRep*>
           (_rep)->removeConsumer(consumer);
 } }
  
 PEGASUS_NAMESPACE_END PEGASUS_NAMESPACE_END

Legend:
Removed from v.1.10  
changed lines
  Added in v.1.21
No CVS admin address has been configured
 Powered by
ViewCVS 0.9.2