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

Diff for /pegasus/src/Pegasus/WsmServer/WsmRequestDecoder.cpp between version 1.14 and 1.15

version 1.14, 2010/12/10 19:39:51 version 1.15, 2012/07/30 11:18:27
Line 38 
Line 38 
 #include <Pegasus/Common/MessageLoader.h> #include <Pegasus/Common/MessageLoader.h>
 #include <Pegasus/Common/AutoPtr.h> #include <Pegasus/Common/AutoPtr.h>
 #include <Pegasus/Common/SharedPtr.h> #include <Pegasus/Common/SharedPtr.h>
   #include <Pegasus/IndicationService/IndicationConstants.h>
  
 #include "WsmConstants.h" #include "WsmConstants.h"
 #include "WsmReader.h" #include "WsmReader.h"
Line 442 
Line 443 
     WsmReader wsmReader(content);     WsmReader wsmReader(content);
     XmlEntry entry;     XmlEntry entry;
     AutoPtr<WsmRequest> request;     AutoPtr<WsmRequest> request;
       AutoPtr<WsmRequest> createFilterRequest;
       AutoPtr<WsmRequest> createSubRequest;
       AutoPtr<WsmRequest> deleteFilterRequest;
       AutoPtr<WsmRequest> deleteHandlerRequest;
       // Whether to include the filter request while processing
       // Subscribe and Unsubscribe requests.
       Boolean includeFilter=true;
     String wsaMessageId;     String wsaMessageId;
       String wsaAction;
     // Process <?xml ... >     // Process <?xml ... >
     try     try
     {     {
Line 460 
Line 468 
         wsmReader.expectStartTag(         wsmReader.expectStartTag(
             entry, WsmNamespaces::SOAP_ENVELOPE, "Envelope");             entry, WsmNamespaces::SOAP_ENVELOPE, "Envelope");
  
         String wsaAction;  
         String wsaFrom;         String wsaFrom;
         String wsaReplyTo;         String wsaReplyTo;
         String wsaFaultTo;         String wsaFaultTo;
         WsmEndpointReference epr;  
         Uint32 wsmMaxEnvelopeSize = 0;         Uint32 wsmMaxEnvelopeSize = 0;
         AcceptLanguageList wsmLocale;         AcceptLanguageList wsmLocale;
         Boolean wsmRequestEpr = false;         Boolean wsmRequestEpr = false;
           String wseIdentifier;
           WsmEndpointReference epr;
         Boolean wsmRequestItemCount = false;         Boolean wsmRequestItemCount = false;
  
         try         try
Line 484 
Line 492 
                 wsmMaxEnvelopeSize,                 wsmMaxEnvelopeSize,
                 wsmLocale,                 wsmLocale,
                 wsmRequestEpr,                 wsmRequestEpr,
                 wsmRequestItemCount);                  wsmRequestItemCount,
                   wseIdentifier);
         }         }
         catch (XmlException&)         catch (XmlException&)
         {         {
Line 642 
Line 651 
                 className,                 className,
                 methodName));                 methodName));
         }         }
           else if(wsaAction == WSM_ACTION_WSMAN_SUBSCRIBE)
           {
               request.reset(_decodeWSSubscriptionRequest(
               wsmReader,
               wsaMessageId,
               epr,
               createFilterRequest,
               createSubRequest,
               includeFilter));
           }
           else if(wsaAction == WSM_ACTION_WSMAN_UNSUBSCRIBE)
           {
               request.reset(_decodeWSUnsubscribeRequest(
               wsmReader,
               wsaMessageId,
               epr,
               wseIdentifier,
               includeFilter,
               deleteFilterRequest,
               deleteHandlerRequest));
           }
           else if(wsaAction == WSM_ACTION_SUBSCRIBE_RENEW)
           {
               throw WsmFault(
                   WsmFault::wse_UnableToRenew,
                   MessageLoaderParms(
                       "WsmServer.WsmRequestDecoder.UNABLE_TO_RENEW",
                       "The subscription could not be renewed."));
           }
         else         else
         {         {
             throw WsmFault(             throw WsmFault(
Line 725 
Line 763 
         PEG_METHOD_EXIT();         PEG_METHOD_EXIT();
         return;         return;
     }     }
       if(wsaAction == WSM_ACTION_WSMAN_SUBSCRIBE)
       {
           // If a filter has to be created during subscription,
           // add the filter request.
           if(includeFilter)
           {
               createFilterRequest.get()->copyRequestProperties(request);
               _wsmProcessor->addReqToSubContext(createFilterRequest.release(),
                   true);
           }
           createSubRequest.get()->copyRequestProperties(request);
           _wsmProcessor->addReqToSubContext(request.get(), true);
           _wsmProcessor->addReqToSubContext(createSubRequest.release(), true);
       }
       else if(wsaAction == WSM_ACTION_WSMAN_UNSUBSCRIBE)
       {
           // If the filter has to be deleted during unsubscribe,
           // add the filter request.
           if(includeFilter)
           {
               deleteFilterRequest.get()->copyRequestProperties(request);
               _wsmProcessor->addReqToSubContext(deleteFilterRequest.release(),
                    false);
           }
           deleteHandlerRequest.get()->copyRequestProperties(request);
           _wsmProcessor->addReqToSubContext(deleteHandlerRequest.release(),
               false);
       }
     _wsmProcessor->handleRequest(request.release());     _wsmProcessor->handleRequest(request.release());
  
     PEG_METHOD_EXIT();     PEG_METHOD_EXIT();
Line 1022 
Line 1087 
     return new WsInvokeRequest(messageId, epr, className, methodName, instance);     return new WsInvokeRequest(messageId, epr, className, methodName, instance);
 } }
  
   WsmRequest* WsmRequestDecoder::_decodeWSUnsubscribeRequest(
       WsmReader& wsmReader,
       const String& messageId,
       WsmEndpointReference& epr,
       const String& identifier,
       Boolean & includeFilter,
       AutoPtr<WsmRequest> &deleteFilterRequest,
       AutoPtr<WsmRequest> &deleteHandlerRequest)
   {
       PEG_METHOD_ENTER(TRC_WSMSERVER,
           "WsmRequestDecoder::_decodeWSUnsubscribeRequest()");
       _checkRequiredHeader("wse:Identifier", identifier.size());
       XmlEntry entry;
       wsmReader.expectStartOrEmptyTag(
           entry, WsmNamespaces::SOAP_ENVELOPE, "Body");
       if (entry.type != XmlEntry::EMPTY_TAG)
       {
           wsmReader.expectStartOrEmptyTag(
               entry, WsmNamespaces::WS_EVENTING, "Unsubscribe");
           wsmReader.expectEndTag(WsmNamespaces::SOAP_ENVELOPE, "Body");
       }
   
       WsmEndpointReference filterEPR;
       String filterName;
       // If existing filter is used in Subscription, do not delete the filter
       if(_wsmProcessor->isSubCreatedWithExistingFilter(identifier, filterName))
       {
           getFilterOrHandlerEPR(filterEPR,
               epr.address,
               filterName,
               PEGASUS_CLASSNAME_INDFILTER.getString());
           includeFilter = false;
       }
       else
       {
           getFilterOrHandlerEPR(filterEPR,
               epr.address,
               identifier,
               PEGASUS_CLASSNAME_INDFILTER.getString());
       }
   
       WsmEndpointReference handlerEPR;
       getFilterOrHandlerEPR(handlerEPR,
           epr.address,
           identifier, PEGASUS_CLASSNAME_INDHANDLER_WSMAN.getString());
   
       WsmEndpointReference subscriptionEPR;
       subscriptionEPR.address = epr.address;
       subscriptionEPR.resourceUri = String(WSM_RESOURCEURI_CIMSCHEMAV2) +
           "/" + PEGASUS_CLASSNAME_INDSUBSCRIPTION.getString();
       subscriptionEPR.selectorSet->selectors.append(WsmSelector
           (PEGASUS_WS_CIMNAMESPACE,
           PEGASUS_NAMESPACENAME_INTEROP.getString()));
       subscriptionEPR.selectorSet->selectors.append(WsmSelector
           (PEGASUS_PROPERTYNAME_FILTER.getString(), filterEPR));
       subscriptionEPR.selectorSet->selectors.append(WsmSelector
           (PEGASUS_PROPERTYNAME_HANDLER.getString(), handlerEPR));
       // DSP0227:R10.6-4 :If a service created CIM indication-related instances
       // as described in 10.5, then the service shall delete those instances
       // when the subscription is canceled for any reason.
       if(includeFilter)
       {
           deleteFilterRequest.reset(new WxfSubDeleteRequest( messageId,
               filterEPR,
               PEGASUS_CLASSNAME_INDFILTER.getString()));
       }
       deleteHandlerRequest.reset(new WxfSubDeleteRequest( messageId,
           handlerEPR,
           PEGASUS_CLASSNAME_INDHANDLER_WSMAN.getString()));
       PEG_METHOD_EXIT();
       return new WxfSubDeleteRequest(messageId,
           subscriptionEPR,
           PEGASUS_CLASSNAME_INDSUBSCRIPTION.getString());
   }
   
   WsmRequest* WsmRequestDecoder::_decodeWSSubscriptionRequest(
       WsmReader& wsmReader,
       const String& messageId,
       WsmEndpointReference& epr,
       AutoPtr<WsmRequest> &createFilterRequest,
       AutoPtr<WsmRequest> &createSubRequest,
       Boolean &includeFilter)
   {
       PEG_METHOD_ENTER(TRC_WSMSERVER,
           "WsmRequestDecoder::_decodeWSSubscriptionRequest()");
       _checkRequiredHeader("wsman:ResourceURI", epr.resourceUri.size());
   
       String filterName;
       String deliveryMode;
       String notifyTo;
       String subExpiration;
       XmlEntry entry;
       WsmFilter wsmFilter;
       // Remove the "uuid:" from messageId
       String msgId = messageId.subString(PEGASUS_WS_UUID_LENGTH);
   
       wsmReader.expectStartOrEmptyTag(
           entry, WsmNamespaces::SOAP_ENVELOPE, "Body");
       if (entry.type != XmlEntry::EMPTY_TAG)
       {
           wsmReader.decodeSubscribeBody(
               deliveryMode,
               notifyTo,
               subExpiration,
               wsmFilter);
           wsmReader.expectEndTag(WsmNamespaces::SOAP_ENVELOPE, "Body");
       }
   
       // DSP0227: 10.2.1.1 - Subscribing to CIM server.
       // Resource URI is all classes
       if( epr.resourceUri == WSM_RESOURCEURI_ALLCLASSES )
       {
           if(!wsmFilter.WQLFilter.query.size())
           {
                   MessageLoaderParms parms(
                       "WsmServer.WsmRequestDecoder.INVALID_MESSAGE ",
                       "The request message has unknown or invalid content"
                       " and cannot be processed. ");
                   throw WsmFault( WsmFault::wse_InvalidMessage, parms);
           }
       }
       //DSP0227: 10.2.1.3 Subscribing to an existing filter
       //Resource URI specifies existing filter
       else if ( epr.resourceUri == WSM_RESOURCEURI_INDICATION_FILTER)
       {
           // DSP0227:R10.2.2-2 - If a service supports filtering using an
           // existing filter expression, the service message shall return the
           // wsman:InvalidParameter fault if the wse:Subscribe request includes
           // a filter expression
           if(wsmFilter.WQLFilter.query.size())
           {
               throw WsmFault(
                       WsmFault::wsman_InvalidParameter,
                       MessageLoaderParms(
                           "WsmServer.WsmRequestDecoder.INVALID_PARAMETER ",
                           "An operation parameter is not valid."));
           }
           else
           {
              for (Uint32 i = 0; i < epr.selectorSet->selectors.size(); i++)
              {
                  if(String::equalNoCase(epr.selectorSet->selectors[i].name,
                         "Name"))
                  {
                      filterName = epr.selectorSet->selectors[i].value;
                      includeFilter = false;
                      break;
                  }
              }
           }
       }
       //DSP0227: 10.2.1.2 Subscribing to an indication class
       else
       {
           CIMName className = WsmToCimRequestMapper::
               convertResourceUriToClassName(epr.resourceUri);
           if(wsmFilter.filterDialect == WsmFilter::NONE)
           {
               //If no filter query is specified, form a filter query.
               wsmFilter.filterDialect = WsmFilter::WQL;
               String query("SELECT * FROM ");
               query.append(className.getString());
               wsmFilter.WQLFilter.query = query;
               try
               {
                   wsmFilter.WQLFilter.selectStatement.reset(
                       new WQLSelectStatement);
                   WQLParser::parse(wsmFilter.WQLFilter.query,
                       *wsmFilter.WQLFilter.selectStatement.get());
               }
               catch (ParseError& e)
               {
                   MessageLoaderParms parms(
                       "WsmServer.WsmRequestDecoder."
                       "INVALID_FILTER_QUERY_EXPRESSION",
                       "Invalid filter query expression: \"$0\".",
                       entry.text);
                   throw WsmFault(WsmFault::wsen_CannotProcessFilter, parms);
               }
               wsmFilter.WQLFilter.queryLanguage = "WQL";
           }
           else if(wsmFilter.filterDialect == WsmFilter::WQL)
           {
               // DSP0227 - R8.1-9 : If class name in resource URI does not
               // match the class name in the filter query, then throw
               // wse:EventSourceUnableToProcess fault.
               WQLSelectStatement *st = wsmFilter.WQLFilter.selectStatement.get();
               if(className.getString() != st->getClassName().getString())
               {
                   throw WsmFault(
                       WsmFault::wse_EventSourceUnableToProcess,
                       MessageLoaderParms(
                           "WsmServer.WsmRequestDecoder.UNABLE_TO_PROCESS ",
                           "The event source cannot process the subscription."));
               }
           }
       }
       WsmEndpointReference filterEPR;
       const String creClassName(PEGASUS_PROPERTYNAME_CREATIONCLASSNAME.
           getString());
       const String propertyName(PEGASUS_PROPERTYNAME_NAME.getString());
       WsmValue sysNameValue(System::getFullyQualifiedHostName());
       WsmProperty sysNameProp("SystemName", sysNameValue);
       WsmValue sysCreClassNameValue(System::getSystemCreationClassName ());
       WsmProperty sysCreClassNameProp(
           "SystemCreationClassName",
           sysCreClassNameValue);
   
       //Creating filterInstance and forming createInstace request for filter.
       if ( includeFilter == true)
       {
           WsmInstance filterInstance;
           filterInstance.setClassName(PEGASUS_CLASSNAME_INDFILTER.getString());
   
           filterInstance.addProperty(sysCreClassNameProp);
           filterInstance.addProperty(sysNameProp);
   
           WsmValue filCreClassNameValue(PEGASUS_CLASSNAME_INDFILTER.getString());
           WsmProperty filCreClassNameProp(creClassName, filCreClassNameValue);
           filterInstance.addProperty(filCreClassNameProp);
   
           WsmValue filNameValue(msgId);
           WsmProperty filNameProp(propertyName, filNameValue);
           filterInstance.addProperty(filNameProp);
           filterName = msgId;
   
           WsmValue queryValue(wsmFilter.WQLFilter.query);
           WsmProperty queryProp(PEGASUS_PROPERTYNAME_QUERY.getString(),
               queryValue);
           filterInstance.addProperty(queryProp);
   
           WsmValue queryLangValue(wsmFilter.WQLFilter.queryLanguage);
           WsmProperty queryLangProp(PEGASUS_PROPERTYNAME_QUERYLANGUAGE.
               getString(),
               queryLangValue);
           filterInstance.addProperty(queryLangProp);
   
           WsmValue srcNamespaceValue(( const char *)epr.getNamespace().
               getCString() );
           WsmProperty srcNamespaceProp("SourceNamespaces", srcNamespaceValue);
           filterInstance.addProperty(srcNamespaceProp);
           getFilterOrHandlerEPR(filterEPR,
               epr.address,
               filterName,
               PEGASUS_CLASSNAME_INDFILTER.getString());
           createFilterRequest.reset(new WxfSubCreateRequest(messageId,
               filterEPR,
               filterInstance));
       }
       else
       {
           getFilterOrHandlerEPR(filterEPR,
               epr.address,
               filterName,
               PEGASUS_CLASSNAME_INDFILTER.getString());
       }
   
       //Creating Handler Instance.
       WsmInstance handlerInstance;
       handlerInstance.setClassName(PEGASUS_CLASSNAME_INDHANDLER_WSMAN.
           getString());
       handlerInstance.addProperty(sysCreClassNameProp);
       handlerInstance.addProperty(sysNameProp);
       WsmValue hanCreClassNameValue(PEGASUS_CLASSNAME_INDHANDLER_WSMAN.
           getString());
       WsmProperty hanCreClassNameProp(creClassName, hanCreClassNameValue);
       handlerInstance.addProperty(hanCreClassNameProp);
   
       WsmValue handlerNameValue(msgId);
       WsmProperty handlerNameProp(propertyName,handlerNameValue);
       handlerInstance.addProperty(handlerNameProp);
   
       WsmValue deliveryModeValue(deliveryMode);
       WsmProperty deliveryModeProp(
           PEGASUS_PROPERTYNAME_WSM_DELIVERY_MODE.getString(),
           deliveryModeValue);
       handlerInstance.addProperty(deliveryModeProp);
   
       WsmValue destValue(notifyTo);
       WsmProperty destProp(PEGASUS_PROPERTYNAME_LSTNRDST_DESTINATION.getString(),
           destValue);
       handlerInstance.addProperty(destProp);
   
       WsmEndpointReference handlerEPR;
       getFilterOrHandlerEPR(handlerEPR,
           epr.address,
           msgId,
           PEGASUS_CLASSNAME_INDHANDLER_WSMAN.getString());
   
       //Creating Subscription Instance.
       WsmInstance subscriptionInstance;
       subscriptionInstance.setClassName(
           PEGASUS_CLASSNAME_INDSUBSCRIPTION.getString());
   
       WsmValue subCreClassNameValue(
           PEGASUS_CLASSNAME_INDSUBSCRIPTION.getString());
       WsmProperty subCreClassNameProp(creClassName, subCreClassNameValue);
   
       WsmValue subInfoVal(msgId);
       WsmProperty subscriptionInfo(_PROPERTY_SUBSCRIPTION_INFO.getString(),
               subInfoVal);
       subscriptionInstance.addProperty(subscriptionInfo);
   
       WsmValue subFilterValue(filterEPR);
       WsmProperty subFilterProp(PEGASUS_PROPERTYNAME_FILTER.getString(),
           subFilterValue);
       subscriptionInstance.addProperty(subFilterProp);
   
       WsmValue subHandlerValue(handlerEPR);
       WsmProperty subHandlerProp(PEGASUS_PROPERTYNAME_HANDLER.getString(),
           subHandlerValue);
       subscriptionInstance.addProperty(subHandlerProp);
   
       if(subExpiration.size())
       {
           WsmValue subDurationval(subExpiration);
           WsmProperty subDurationProp(PEGASUS_WS_SUB_DURATION,
               subDurationval);
           subscriptionInstance.addProperty(subDurationProp);
       }
   
       WsmEndpointReference subscriptionEPR;
       subscriptionEPR.address = epr.address;
       subscriptionEPR.resourceUri = String(WSM_RESOURCEURI_CIMSCHEMAV2) +
           "/" + PEGASUS_CLASSNAME_INDSUBSCRIPTION.getString();
       subscriptionEPR.selectorSet->selectors.append(WsmSelector
           (PEGASUS_WS_CIMNAMESPACE,
           PEGASUS_NAMESPACENAME_INTEROP.getString()));
       createSubRequest.reset(new WxfSubCreateRequest(messageId,
           subscriptionEPR,
           subscriptionInstance));
       PEG_METHOD_EXIT();
       return(new WxfSubCreateRequest(messageId,
           handlerEPR,
           handlerInstance));
   }
   
   void WsmRequestDecoder::getFilterOrHandlerEPR(
       WsmEndpointReference& instanceEPR,
       const String address,
       const String name,
       const String className)
   {
       instanceEPR.address = address;
       instanceEPR.resourceUri = String(WSM_RESOURCEURI_CIMSCHEMAV2)
           + "/" + className;
       instanceEPR.selectorSet->selectors.append(WsmSelector
           (PEGASUS_WS_CIMNAMESPACE,
           PEGASUS_NAMESPACENAME_INTEROP.getString()));
       instanceEPR.selectorSet->selectors.append(WsmSelector(
           "SystemCreationClassName",
           System::getSystemCreationClassName()));
       instanceEPR.selectorSet->selectors.append(WsmSelector(
           "SystemName",
           System::getFullyQualifiedHostName()));
       instanceEPR.selectorSet->selectors.append(WsmSelector(
           PEGASUS_PROPERTYNAME_CREATIONCLASSNAME.getString(),
           className));
       instanceEPR.selectorSet->selectors.append(WsmSelector(
           PEGASUS_PROPERTYNAME_NAME.getString(),
           name));
   }
   
 bool WsmRequestDecoder::_isIdentifyRequest(WsmReader& wsmReader) bool WsmRequestDecoder::_isIdentifyRequest(WsmReader& wsmReader)
 { {
     // Parse the <s:Body> element. Here is an example:     // Parse the <s:Body> element. Here is an example:

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