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

Diff for /pegasus/src/Pegasus/ControlProviders/InteropProvider/InteropProvider.cpp between version 1.36 and 1.41

version 1.36, 2005/05/24 10:42:51 version 1.41, 2005/06/02 11:47:04
Line 50 
Line 50 
 //      CIM_ObjectManagerCommunicationMechanism //      CIM_ObjectManagerCommunicationMechanism
 //      CIM_CIMXMLCommunicationMechanism //      CIM_CIMXMLCommunicationMechanism
 //      CIM_ProtocolAdapter  (Note: Removed because deprecated class in cim 2.9) //      CIM_ProtocolAdapter  (Note: Removed because deprecated class in cim 2.9)
 //      CIM_Namespace (Effective Pegasus 2.4 we use PG_Namespace which  //      CIM_Namespace (Effective Pegasus 2.4 we use PG_Namespace.
 //      is a subclass of CIM_Namespace with additional properties for  //
 //      shared namespaces.  //      PG_Namespace - Pegasus particular subclass of CIM_Namespace that
   //      add the parameters for shared namespaces
   //
   //      PG_CIMXMLCommunicationMechanism - Pegasus subclass of
   //      CIM_CIMXMLCommunicationMechanism that adds support for passing
   //      additional communication parameters (ie. port, https vs. http, etc.)
 // //
 //      It also services the Interop associations tied to these classes //      It also services the Interop associations tied to these classes
 //      including: //      including:
Line 131 
Line 136 
 /** /**
     The constants representing the class names we process     The constants representing the class names we process
 */ */
 // ATTN DELETE: static const CIMName __NAMESPACE_CLASSNAME  = CIMName ("__Namespace");  
 static const CIMName CIM_NAMESPACE_CLASSNAME  = CIMName ("CIM_Namespace"); static const CIMName CIM_NAMESPACE_CLASSNAME  = CIMName ("CIM_Namespace");
 static const CIMName PG_NAMESPACE_CLASSNAME  = CIMName ("PG_Namespace"); static const CIMName PG_NAMESPACE_CLASSNAME  = CIMName ("PG_Namespace");
  
Line 145 
Line 149 
 static const CIMName CIM_NAMESPACEINMANAGER_CLASSNAME  = static const CIMName CIM_NAMESPACEINMANAGER_CLASSNAME  =
         CIMName ("CIM_NamespaceInManager");         CIMName ("CIM_NamespaceInManager");
  
 // Property Names for __Namespace Class  // Property Names for CIM_Namespace Class
 static const CIMName NAMESPACE_PROPERTYNAME  = CIMName ("Name"); static const CIMName NAMESPACE_PROPERTYNAME  = CIMName ("Name");
   
   // Root Namespace Name for test.
 static const CIMNamespaceName ROOTNS  = CIMNamespaceName ("root"); static const CIMNamespaceName ROOTNS  = CIMNamespaceName ("root");
  
  
 // Property names for CIM_ObjectManager Class // Property names for CIM_ObjectManager Class
 static const CIMName OM_GATHERSTATISTICALDATA  = static const CIMName OM_GATHERSTATISTICALDATA  =
  CIMName ("GatherStatisticalData");  CIMName ("GatherStatisticalData");
   
 // Property for the slp template. // Property for the slp template.
 static const CIMName OM_DESCRIPTIONPROPERTY = static const CIMName OM_DESCRIPTIONPROPERTY =
     CIMName("Description");     CIMName("Description");
Line 213 
Line 220 
 // operations. // operations.
  
 enum targetClass{ enum targetClass{
         //__NAMESPACE = 1,  
         PG_NAMESPACE = 1,         PG_NAMESPACE = 1,
         CIM_OBJECTMANAGER = 2,         CIM_OBJECTMANAGER = 2,
         PG_CIMXMLCOMMUNICATIONMECHANISM = 3,         PG_CIMXMLCOMMUNICATIONMECHANISM = 3,
Line 238 
Line 244 
  
     //***********************************************     //***********************************************
     // This is a tempory fix untill there is a method created for the InteropProvider to     // This is a tempory fix untill there is a method created for the InteropProvider to
     // do it's inaliaztion work. This fix sets StatisticalData::CopyGSD, enabling the      // do it's inalization work. This fix sets StatisticalData::CopyGSD, enabling the
     //statistical gathering function.     //statistical gathering function.
     Array<CIMInstance> instance = repository->enumerateInstances(CIMNamespaceName("root/cimv2"), CIMName ("CIM_ObjectManager"));  
  
     if(instance.size() > 0)  
        Boolean InstancesExists = true;
        Array<CIMInstance> instance;
   
        try
        {
            instance = repository->enumerateInstances(CIMNamespaceName("root/cimv2"),
                                                      CIMName ("CIM_ObjectManager"));
        }
        catch(Exception e)
        {
          InstancesExists = false;
        }
   
        /* When Bug 3696 is fixed the following try block will replace the try block above. But for
           now if no instances of the CIM_ObjectManager class are found in the root/cimv2 name space
           the root/PG_InterOp name space will be checked
        */
        if(!InstancesExists)
        {
            try
            {
                instance = repository->enumerateInstances(CIMNamespaceName("root/PG_InterOp"),
                                                          CIMName ("CIM_ObjectManager"));
            }
            catch(Exception e)
            {
                InstancesExists = false;
            }
        }
   
        if(instance.size() > 0 && InstancesExists)
     {     {
         Boolean output = false;         Boolean output = false;
         Uint32 pos;         Uint32 pos;
Line 268 
Line 304 
     PEG_METHOD_EXIT();     PEG_METHOD_EXIT();
  }  }
  
   
   
 //*************************************************************** //***************************************************************
 // Provider Utility Functions // Provider Utility Functions
 //*************************************************************** //***************************************************************
Line 291 
Line 325 
     return(tmp);     return(tmp);
 } }
  
   
   /* set the hostname and namespace fields into the cimobjectpath
      of the defined instance
   */
   
   void _setCompleteInstancePath(CIMInstance& instance,
                              const CIMObjectPath& inputPath)
   {
       CIMObjectPath p = instance.getPath();
       p.setHost(inputPath.getHost());
       p.setNameSpace(inputPath.getNameSpace());
   
       instance.setPath(p);
   }
   
   /* complete the instance by setting the complete path into the instance
      and executing the instance filter to set the qualifiers, classorigin and
      propertylist in accordance with the input.  Note that this can only remove
      characteristics, except for the path completion so that it expects instances
      with qualifiers included, class origin included and a complete property
      list.
   */
   
   
    void _finishInstance(CIMInstance& instance, const CIMObjectPath& path, Boolean includeQualifiers,
        Boolean includeClassOrigin, const CIMPropertyList& propertyList)
    {
        _setCompleteInstancePath( instance, path);
   
        instance.filter(includeQualifiers,
                        includeClassOrigin,
                        propertyList );
    }
 static String _showPropertyList(const CIMPropertyList& pl) static String _showPropertyList(const CIMPropertyList& pl)
 { {
     if (pl.isNull())     if (pl.isNull())
Line 355 
Line 422 
     used for localhost (127.0.0.1).     used for localhost (127.0.0.1).
  
     @param hostName String with the name of the host     @param hostName String with the name of the host
     @return String with the IP address to be used      @param namespaceType - Uint32 representing the
     NOTE: This code should not be in slpprovider. This      access protocol for this request.  This is exactly
     should be in the Interop classes but for the moment      the definition in the PG_CIMXMLCommunicationMechanism
     it is not.      mof for the property namespaceAccessProtocol.
       @return String with the IP address to be used. This must
       be the complete address sufficient to access the
       IP address. Therefore, it includes the port number.
 */ */
 String _getHostAddress(String hostName)  String _getHostAddress(String & hostName, Uint32  namespaceType)
 { {
   String ipAddress;   String ipAddress;
  
Line 372 
Line 442 
       // set default address if everything else failed       // set default address if everything else failed
       ipAddress = String("127.0.0.1");       ipAddress = String("127.0.0.1");
   }   }
     // Question: is there a case where we leave off the port number.
     // Code to get the property service_location_tcp ( which is equivalent to "IP address:5988")
     // Need to tie these two together.
     Uint32 portNumber;
   
     /********************** Drop this
     ConfigManager* configManager = ConfigManager::getInstance();
     Boolean enableHttpConnection = String::equal(
         configManager->getCurrentValue("enableHttpConnection"), "true");
     Boolean enableHttpsConnection = String::equal(
         configManager->getCurrentValue("enableHttpsConnection"), "true");
     ***********************/
   
     // ATTN: The following is incorrect and must be modified as part
     // of bug 1857 and possibly other bug reports. KS. This is 2.5 mustfix.
   
     // Match the protocol and port number from internal information.
     if (namespaceType == 3)
          portNumber = System::lookupPort(WBEM_HTTPS_SERVICE_NAME,
             WBEM_DEFAULT_HTTPS_PORT);
     else if (namespaceType == 2)
     {
         portNumber = System::lookupPort(WBEM_HTTP_SERVICE_NAME,
             WBEM_DEFAULT_HTTP_PORT);
     }
     else
         portNumber = 0;
     // convert portNumber to ascii
     char buffer[32];
     sprintf(buffer, ":%u", portNumber);
     if (portNumber != 0)
         ipAddress.append(buffer);
   
     // now fillout the serviceIDAttribute from the object manager instance name property.
     // This is a key field so must have a value.
     //String strUUID = _getPropertyValue( instance_ObjMgr, namePropertyName, "DefaultEmptyUUID");
   
   return ipAddress;   return ipAddress;
 } }
  
Line 557 
Line 664 
    @return the CIMClass object    @return the CIMClass object
    @Exceptions any repository exceptions if class not found.    @Exceptions any repository exceptions if class not found.
 */ */
 CIMClass InteropProvider::_getClass(const CIMNamespaceName& nameSpace,  CIMClass InteropProvider::_getClass(const CIMObjectPath& objectPath,
                                     const CIMName& className)                                     const CIMName& className)
 { {
     PEG_METHOD_ENTER(TRC_CONTROLPROVIDER,     PEG_METHOD_ENTER(TRC_CONTROLPROVIDER,
             "InteropProvider::_getClass");             "InteropProvider::_getClass");
  
     CIMClass myClass = _repository->getClass(nameSpace, className,      CIMClass myClass = _repository->getClass(objectPath.getNameSpace(), className,
                             false,true,true);                             false,true,true);
     PEG_METHOD_EXIT();     PEG_METHOD_EXIT();
     return myClass;     return myClass;
Line 698 
Line 805 
             "InteropProvider::_fixInstanceCommonKeys()");             "InteropProvider::_fixInstanceCommonKeys()");
     String SystemCreationClassName = System::getSystemCreationClassName ();     String SystemCreationClassName = System::getSystemCreationClassName ();
  
     _setPropertyValue(instance, CIM_NAMESPACE_PROPERTY_SYSTEMCREATIONCLASSNAME,SystemCreationClassName);      _setPropertyValue(instance, CIM_NAMESPACE_PROPERTY_SYSTEMCREATIONCLASSNAME,
               SystemCreationClassName);
  
     // Add property SystemName     // Add property SystemName
       _setPropertyValue(instance, CIM_NAMESPACE_PROPERTY_SYSTEMNAME,
     _setPropertyValue(instance, CIM_NAMESPACE_PROPERTY_SYSTEMNAME,System::getFullyQualifiedHostName());              System::getFullyQualifiedHostName());
     PEG_METHOD_EXIT();     PEG_METHOD_EXIT();
 } }
  
Line 718 
Line 826 
     @return CIMInstance of this class with properties complete.     @return CIMInstance of this class with properties complete.
     @exception passes on any exceptions received from the repository request.     @exception passes on any exceptions received from the repository request.
 */ */
 CIMInstance InteropProvider::_buildInstanceSkeleton(const CIMName& className)  CIMInstance InteropProvider::_buildInstanceSkeleton(const CIMObjectPath & objectPath,
                                                       const CIMName& className,
                                                       CIMClass& returnedClass)
 { {
     PEG_METHOD_ENTER(TRC_CONTROLPROVIDER,     PEG_METHOD_ENTER(TRC_CONTROLPROVIDER,
             "InteropProvider::_buildInstanceSkeleton()");             "InteropProvider::_buildInstanceSkeleton()");
     CIMClass myClass;      // get class with lo = false, qualifier = true classorig = true
       CIMClass myClass = _repository->getClass(objectPath.getNameSpace(),
     CIMInstance skeleton(className);                                          className, false, true, true);
         myClass = _repository->getClass(_operationNamespace, className, false, true, true);      returnedClass = myClass;
       CIMInstance skeleton = myClass.buildInstance(true,true,CIMPropertyList());
     // copy the qualifiers  
     for (Uint32 i = 0 ; i < myClass.getQualifierCount() ; i++)  
         skeleton.addQualifier(myClass.getQualifier(i));  
   
     // copy the properties  
     for (Uint32 i = 0 ; i < myClass.getPropertyCount() ; i++)  
         skeleton.addProperty(myClass.getProperty(i));  
  
     PEG_METHOD_EXIT();     PEG_METHOD_EXIT();
     return(skeleton.clone());      return(skeleton);
 } }
  
 /* build a single instance of the cimxmlcommunicationmechanism class /* build a single instance of the cimxmlcommunicationmechanism class
Line 745 
Line 848 
    @return CIMInstance of the class    @return CIMInstance of the class
 */ */
 CIMInstance InteropProvider::_buildInstancePGCIMXMLCommunicationMechanism( CIMInstance InteropProvider::_buildInstancePGCIMXMLCommunicationMechanism(
               const CIMObjectPath& objectPath,
                                             const String& namespaceType,                                             const String& namespaceType,
               const Uint16& accessProtocol,
                                             const String& IPAddress,                                             const String& IPAddress,
                                             const Boolean& includeQualifiers,                                             const Boolean& includeQualifiers,
                                             const Boolean& includeClassOrigin,                                             const Boolean& includeClassOrigin,
Line 753 
Line 858 
 { {
     PEG_METHOD_ENTER(TRC_CONTROLPROVIDER,     PEG_METHOD_ENTER(TRC_CONTROLPROVIDER,
             "InteropProvider::_buildInstancePGCIMXMLCommunicationMechanism()");             "InteropProvider::_buildInstancePGCIMXMLCommunicationMechanism()");
       CIMClass targetClass;
     CIMInstance instance = _buildInstanceSkeleton(PG_CIMXMLCOMMUNICATIONMECHANISM_CLASSNAME);      CIMInstance instance = _buildInstanceSkeleton(objectPath,
                               PG_CIMXMLCOMMUNICATIONMECHANISM_CLASSNAME,
                               targetClass);
  
     _fixInstanceCommonKeys(instance);     _fixInstanceCommonKeys(instance);
  
     //CreationClassName     //CreationClassName
     _setPropertyValue(instance, CIM_NAMESPACE_PROPERTY_CREATIONCLASSNAME,PG_CIMXMLCOMMUNICATIONMECHANISM_CLASSNAME.getString());      _setPropertyValue(instance, CIM_NAMESPACE_PROPERTY_CREATIONCLASSNAME,
               PG_CIMXMLCOMMUNICATIONMECHANISM_CLASSNAME.getString());
  
     //Name, this CommunicationMechanism.  We need to make it unique.  To do this     //Name, this CommunicationMechanism.  We need to make it unique.  To do this
     // we simply append the commtype to the classname since we have max of two right     // we simply append the commtype to the classname since we have max of two right
     // now.     // now.
     _setPropertyValue(instance, CIM_NAMESPACE_PROPERTY_NAME, (String("PEGASUSCOMM") + namespaceType));      _setPropertyValue(instance, CIM_NAMESPACE_PROPERTY_NAME,
               (String("PEGASUSCOMM") + namespaceType));
  
     // CommunicationMechanism Property - Force to 2.     // CommunicationMechanism Property - Force to 2.
     _setPropertyValue(instance, OM_COMMUNICATIONMECHANISM, Uint16(2));     _setPropertyValue(instance, OM_COMMUNICATIONMECHANISM, Uint16(2));
Line 797 
Line 906 
     // Obsolete function     // Obsolete function
     _setPropertyValue(instance, "namespaceType", namespaceType);     _setPropertyValue(instance, "namespaceType", namespaceType);
  
       _setPropertyValue(instance, "namespaceAccessProtocol", accessProtocol);
   
     _setPropertyValue(instance, "IPAddress", IPAddress);     _setPropertyValue(instance, "IPAddress", IPAddress);
  
     PEG_METHOD_EXIT();     PEG_METHOD_EXIT();
Line 804 
Line 915 
 } }
  
 Array<CIMInstance> InteropProvider::_buildInstancesPGCIMXMLCommunicationMechanism( Array<CIMInstance> InteropProvider::_buildInstancesPGCIMXMLCommunicationMechanism(
                                               const CIMObjectPath& objectPath,
                                             const Boolean includeQualifiers,                                             const Boolean includeQualifiers,
                                             const Boolean includeClassOrigin,                                             const Boolean includeClassOrigin,
                                             const CIMPropertyList& propertyList)                                             const CIMPropertyList& propertyList)
Line 812 
Line 924 
             "InteropProvider::_buildInstancesPGCIMXMLCommunicationMechanism");             "InteropProvider::_buildInstancesPGCIMXMLCommunicationMechanism");
  
     // This is a temporary hack to get the multiple connections.     // This is a temporary hack to get the multiple connections.
       // This is based on the configmanager being the source of what
       // protocols are available, http and https.
   
     ConfigManager* configManager = ConfigManager::getInstance();     ConfigManager* configManager = ConfigManager::getInstance();
     Boolean enableHttpConnection = String::equal(     Boolean enableHttpConnection = String::equal(
         configManager->getCurrentValue("enableHttpConnection"), "true");         configManager->getCurrentValue("enableHttpConnection"), "true");
     Boolean enableHttpsConnection = String::equal(     Boolean enableHttpsConnection = String::equal(
         configManager->getCurrentValue("enableHttpsConnection"), "true");         configManager->getCurrentValue("enableHttpsConnection"), "true");
  
     String IPAddress = _getHostAddress(System::getHostName());  
     Array<CIMInstance> instances;     Array<CIMInstance> instances;
       Uint32 namespaceAccessProtocol;
       String namespaceType;
  
       // for each type, create the instance if that type is defined.
     if (enableHttpConnection)     if (enableHttpConnection)
     {     {
         CDEBUG("building pgcimxmlinstances 1");          namespaceAccessProtocol = 2;
         CIMInstance instance = _buildInstancePGCIMXMLCommunicationMechanism(          namespaceType = "http";
                             "http", IPAddress,          CIMInstance instance =
               _buildInstancePGCIMXMLCommunicationMechanism(
                   objectPath,
                   namespaceType,
                   namespaceAccessProtocol,
                   _getHostAddress(System::getHostName(), namespaceAccessProtocol),
                             includeQualifiers,                             includeQualifiers,
                             includeClassOrigin,                             includeClassOrigin,
                             propertyList);                             propertyList);
Line 834 
Line 956 
  
     if (enableHttpsConnection)     if (enableHttpsConnection)
     {     {
         CDEBUG("building pgcimxmlinstances 2");          namespaceAccessProtocol = 3;
         CIMInstance instance = _buildInstancePGCIMXMLCommunicationMechanism(          namespaceType = "https";
                                                 "https", IPAddress,          CIMInstance instance =
               _buildInstancePGCIMXMLCommunicationMechanism(
                   objectPath,
                   namespaceType,
                   namespaceAccessProtocol,
                   _getHostAddress(System::getHostName(), namespaceAccessProtocol),
                                                 includeQualifiers,                                                 includeQualifiers,
                                                 includeClassOrigin,                                                 includeClassOrigin,
                                                 propertyList);                                                 propertyList);
         instances.append(instance);         instances.append(instance);
     }     }
   
   
     PEG_METHOD_EXIT();     PEG_METHOD_EXIT();
     return(instances);     return(instances);
 } }
Line 868 
Line 997 
     this is used so infrequently, waste of space.     this is used so infrequently, waste of space.
 */ */
 Boolean InteropProvider::_getInstanceFromRepositoryCIMObjectManager( Boolean InteropProvider::_getInstanceFromRepositoryCIMObjectManager(
                           const CIMObjectPath& objectPath,
                         CIMInstance& rtnInstance,                         CIMInstance& rtnInstance,
                         const Boolean includeQualifiers,                         const Boolean includeQualifiers,
                         const Boolean includeClassOrigin,                         const Boolean includeClassOrigin,
Line 875 
Line 1005 
 { {
     PEG_METHOD_ENTER(TRC_CONTROLPROVIDER,     PEG_METHOD_ENTER(TRC_CONTROLPROVIDER,
             "InteropProvider::_getInstanceCIMObjectManager");             "InteropProvider::_getInstanceCIMObjectManager");
   
     // Try to get persistent instance from repository     // Try to get persistent instance from repository
     Array<CIMInstance> instances;     Array<CIMInstance> instances;
     try     try
     {     {
         instances = _repository->enumerateInstances(_operationNamespace,          instances = _repository->enumerateInstances(
                   objectPath.getNameSpace(),
                       CIM_OBJECTMANAGER_CLASSNAME, true, false, includeQualifiers,                       CIM_OBJECTMANAGER_CLASSNAME, true, false, includeQualifiers,
                         includeClassOrigin, propertyList);                         includeClassOrigin, propertyList);
  
Line 895 
Line 1027 
             // but we will still continue to use the first entry.             // but we will still continue to use the first entry.
             if (instances.size() > 1)             if (instances.size() > 1)
             {             {
                 Logger::put(Logger::ERROR_LOG, System::CIMSERVER, Logger::INFORMATION,                  Logger::put(Logger::ERROR_LOG,
                     "Error. Multiple definitons of : $0", CIM_OBJECTMANAGER_CLASSNAME.getString());                      System::CIMSERVER, Logger::INFORMATION,
                       "Error. Multiple definitons of : $0",
                       CIM_OBJECTMANAGER_CLASSNAME.getString());
             }             }
             CDEBUG("getInstanceFromRepository returning true");  
             return(true);             return(true);
         }         }
         else         else
         {         {
             CDEBUG("getInstanceFromRepository returning false");  
             return(false);             return(false);
         }         }
     }     }
     catch(const CIMException&)     catch(const CIMException&)
     {     {
         Logger::put(Logger::ERROR_LOG, System::CIMSERVER, Logger::INFORMATION,         Logger::put(Logger::ERROR_LOG, System::CIMSERVER, Logger::INFORMATION,
             "Error. Cannot access $0 in repository", CIM_OBJECTMANAGER_CLASSNAME.getString());              "Error. Cannot access $0 in repository",
               CIM_OBJECTMANAGER_CLASSNAME.getString());
         PEG_METHOD_EXIT();         PEG_METHOD_EXIT();
         throw;         throw;
     }     }
     catch(const Exception&)     catch(const Exception&)
     {     {
         Logger::put(Logger::ERROR_LOG, System::CIMSERVER, Logger::INFORMATION,         Logger::put(Logger::ERROR_LOG, System::CIMSERVER, Logger::INFORMATION,
             "Error. Cannot access $0 in repository", CIM_OBJECTMANAGER_CLASSNAME.getString());              "Error. Cannot access $0 in repository",
               CIM_OBJECTMANAGER_CLASSNAME.getString());
         PEG_METHOD_EXIT();         PEG_METHOD_EXIT();
         throw;         throw;
     }     }
Line 935 
Line 1069 
         for this class.         for this class.
 */ */
 CIMInstance InteropProvider::_getInstanceCIMObjectManager( CIMInstance InteropProvider::_getInstanceCIMObjectManager(
                           const CIMObjectPath& objectPath,
                         const Boolean includeQualifiers,                         const Boolean includeQualifiers,
                         const Boolean includeClassOrigin,                         const Boolean includeClassOrigin,
                         const CIMPropertyList& propertyList)                         const CIMPropertyList& propertyList)
Line 944 
Line 1079 
  
     // Try to get the current object.  If true then it is already created.     // Try to get the current object.  If true then it is already created.
     CIMInstance instance;     CIMInstance instance;
     if (!_getInstanceFromRepositoryCIMObjectManager(instance, includeQualifiers,includeClassOrigin,propertyList))      if (!_getInstanceFromRepositoryCIMObjectManager(objectPath,
                   instance, includeQualifiers,includeClassOrigin,propertyList))
     {     {
         //         //
         // No instance in the repository. Build new instance and save it.         // No instance in the repository. Build new instance and save it.
         //         //
         CDEBUG("Creating New instance of CIMOBjectManager");          CIMClass targetClass;
         instance = _buildInstanceSkeleton(CIM_OBJECTMANAGER_CLASSNAME);          instance = _buildInstanceSkeleton(objectPath, CIM_OBJECTMANAGER_CLASSNAME,
                       targetClass);
  
         _fixInstanceCommonKeys(instance);         _fixInstanceCommonKeys(instance);
  
         _setPropertyValue(instance, CIM_NAMESPACE_PROPERTY_CREATIONCLASSNAME,CIM_OBJECTMANAGER_CLASSNAME.getString());          _setPropertyValue(instance, CIM_NAMESPACE_PROPERTY_CREATIONCLASSNAME,
                   CIM_OBJECTMANAGER_CLASSNAME.getString());
         _setPropertyValue(instance, CIM_NAMESPACE_PROPERTY_NAME,buildObjectManagerName());         _setPropertyValue(instance, CIM_NAMESPACE_PROPERTY_NAME,buildObjectManagerName());
         _setPropertyValue(instance, CIMName("ElementName"), String("Pegasus"));         _setPropertyValue(instance, CIMName("ElementName"), String("Pegasus"));
  
Line 997 
Line 1135 
         try         try
         {         {
             CDEBUG("Create Instance for CIM_ObjectManager");             CDEBUG("Create Instance for CIM_ObjectManager");
             instancePath = _repository->createInstance(_operationNamespace,              instancePath = _repository->createInstance(objectPath.getNameSpace(),
                            instance );                            instance );
         }         }
         catch(const CIMException&)         catch(const CIMException&)
Line 1014 
Line 1152 
         }         }
         instance.setPath(instancePath);         instance.setPath(instancePath);
     }     }
     instance.filter(includeQualifiers, includeClassOrigin, propertyList);      // KS_TEMP Drop Thisinstance.filter(includeQualifiers, includeClassOrigin, propertyList);
     PEG_METHOD_EXIT();     PEG_METHOD_EXIT();
     return(instance);     return(instance);
 } }
  
 /** Get the instances of CIM_Namespace. Gets all instances of the namespace from /** Get the instances of CIM_Namespace. Gets all instances of the namespace from
     the repository namespace management functions      the repository namespace management functions. Builds instances that
     Pegasus 2.4 - This now gets CIM_Namespace and its subclass PG_Namespace      match all of the request attributes.
 */ */
 Array<CIMInstance> InteropProvider::_getInstancesCIMNamespace(const Boolean& includeQualifiers,  Array<CIMInstance> InteropProvider::_getInstancesCIMNamespace(
                               const CIMObjectPath& objectPath,
                               const Boolean& includeQualifiers,
                             const Boolean& includeClassOrigin,                             const Boolean& includeClassOrigin,
                             const CIMPropertyList& propertyList)                             const CIMPropertyList& propertyList)
 { {
Line 1035 
Line 1175 
     CDEBUG("_getInstancesCIMNamespace. count = " << namespaceNames.size());     CDEBUG("_getInstancesCIMNamespace. count = " << namespaceNames.size());
     Array<CIMInstance> instanceArray;     Array<CIMInstance> instanceArray;
  
     // We build instances of PG namespace since that is the leaf class      // Build instances of PG namespace since that is the leaf class
     for (Uint32 i = 0; i < namespaceNames.size(); i++)     for (Uint32 i = 0; i < namespaceNames.size(); i++)
     {     {
        instanceArray.append( _buildInstancePGNamespace(namespaceNames[i]));         instanceArray.append( _buildInstancePGNamespace(objectPath, namespaceNames[i]));
     }     }
     CDEBUG("Build this many PG_Namespace Instances. count= " << instanceArray.size());     CDEBUG("Build this many PG_Namespace Instances. count= " << instanceArray.size());
     PEG_METHOD_EXIT();     PEG_METHOD_EXIT();
Line 1049 
Line 1189 
     for the instance required.     for the instance required.
     ATTN: Note that this is incorrect. We are supplying the namespace name and need to supply     ATTN: Note that this is incorrect. We are supplying the namespace name and need to supply
     the objectpath     the objectpath
     @param TBD      @param objectPath CIMObjectPath from request
       @param nameSpace CIMNamespaceName for instance to get
     @return CIMInstance with the found instance or CIMInstance() if nothing found.     @return CIMInstance with the found instance or CIMInstance() if nothing found.
 */ */
 CIMInstance InteropProvider::_getInstanceCIMNamespace(const CIMNamespaceName & nameSpace)  CIMInstance InteropProvider::_getInstanceCIMNamespace(const CIMObjectPath& objectPath)
 { {
     PEG_METHOD_ENTER(TRC_CONTROLPROVIDER,     PEG_METHOD_ENTER(TRC_CONTROLPROVIDER,
             "InteropProvider::_getInstancesCIMNamespace()");             "InteropProvider::_getInstancesCIMNamespace()");
  
     Array<CIMInstance> instances = _getInstancesCIMNamespace(true, true, CIMPropertyList());      Array<CIMInstance> instances = _getInstancesCIMNamespace(objectPath, true, true, CIMPropertyList());
  
       CIMNamespaceName nameSpace = objectPath.getNameSpace();
     // search the instances for one with the name property value = input parameter.     // search the instances for one with the name property value = input parameter.
     for (Uint32 i = 0 ; i < instances.size() ; i++)     for (Uint32 i = 0 ; i < instances.size() ; i++)
     {     {
Line 1073 
Line 1215 
     return(nullInstance);     return(nullInstance);
 } }
  
 CIMObjectPath InteropProvider::_buildReference(const CIMInstance& instance, const CIMName& className)  CIMObjectPath InteropProvider::_buildReference(const CIMObjectPath& objectPath,
           const CIMInstance& instance, const CIMName& className)
 { {
     return(_buildObjectPath(_operationNamespace,className, instance));      return(_buildObjectPath(objectPath,className, instance));
 } }
  
 Array<CIMInstance> InteropProvider::_buildInstancesNamespaceInManager()  Array<CIMInstance> InteropProvider::_buildInstancesNamespaceInManager(const CIMObjectPath& objectPath)
 { {
     PEG_METHOD_ENTER(TRC_CONTROLPROVIDER,     PEG_METHOD_ENTER(TRC_CONTROLPROVIDER,
             "InteropProvider::_buildInstancesNamespaceInManager");             "InteropProvider::_buildInstancesNamespaceInManager");
  
     Array<CIMInstance> namespaceInstances = _getInstancesCIMNamespace(false,      Array<CIMInstance> namespaceInstances = _getInstancesCIMNamespace(objectPath, false,
                             false, CIMPropertyList());                             false, CIMPropertyList());
  
     CIMInstance instanceObjMgr = _getInstanceCIMObjectManager( true, true, CIMPropertyList());      CIMInstance instanceObjMgr = _getInstanceCIMObjectManager(objectPath, true, true, CIMPropertyList());
  
     CIMObjectPath refObjMgr = _buildReference(instanceObjMgr, CIM_OBJECTMANAGER_CLASSNAME);      CIMObjectPath refObjMgr = _buildReference(objectPath,instanceObjMgr, CIM_OBJECTMANAGER_CLASSNAME);
  
     Array<CIMInstance> assocInstances;     Array<CIMInstance> assocInstances;
       CIMClass targetClass;
  
     for (Uint32 i = 0 ; i < namespaceInstances.size() ; i++)     for (Uint32 i = 0 ; i < namespaceInstances.size() ; i++)
     {     {
         CIMInstance instance = _buildInstanceSkeleton(CIM_NAMESPACEINMANAGER_CLASSNAME);          CIMInstance instance = _buildInstanceSkeleton(objectPath, CIM_NAMESPACEINMANAGER_CLASSNAME,
                                                       targetClass);
  
         _setPropertyValue(instance, CIMName("Antecedent"), refObjMgr);         _setPropertyValue(instance, CIMName("Antecedent"), refObjMgr);
         //ATTNATTN: this is weak qualifier.         //ATTNATTN: this is weak qualifier.
         _setPropertyValue(instance, CIMName("Dependent"), _buildReference(namespaceInstances[i],          _setPropertyValue(instance, CIMName("Dependent"),
                                                             CIM_NAMESPACEINMANAGER_CLASSNAME));              _buildReference(objectPath, namespaceInstances[i], CIM_NAMESPACEINMANAGER_CLASSNAME));
           instance.setPath(instance.buildPath(targetClass));
         assocInstances.append(instance);         assocInstances.append(instance);
     }     }
  
     PEG_METHOD_EXIT();     PEG_METHOD_EXIT();
   
     return(assocInstances);     return(assocInstances);
 } }
  
 Array<CIMInstance> InteropProvider::_buildInstancesCommMechanismForManager()  Array<CIMInstance> InteropProvider::_buildInstancesCommMechanismForManager(
       const CIMObjectPath& objectPath)
 { {
     PEG_METHOD_ENTER(TRC_CONTROLPROVIDER,     PEG_METHOD_ENTER(TRC_CONTROLPROVIDER,
             "InteropProvider::_buildInstancesCommMechanismForManager");             "InteropProvider::_buildInstancesCommMechanismForManager");
  
     Array<CIMInstance> commInstances = _buildInstancesPGCIMXMLCommunicationMechanism(true,      Array<CIMInstance> commInstances = _buildInstancesPGCIMXMLCommunicationMechanism(
            objectPath,true,
          true, CIMPropertyList());          true, CIMPropertyList());
  
     CIMInstance instanceObjMgr = _getInstanceCIMObjectManager( true, true, CIMPropertyList());      CIMInstance instanceObjMgr = _getInstanceCIMObjectManager(objectPath, true, true, CIMPropertyList());
  
     CIMObjectPath refObjMgr = _buildReference(instanceObjMgr, CIM_OBJECTMANAGER_CLASSNAME);      CIMObjectPath refObjMgr = _buildReference(objectPath, instanceObjMgr, CIM_OBJECTMANAGER_CLASSNAME);
     Array<CIMInstance> assocInstances;  
  
       Array<CIMInstance> assocInstances;
       CIMClass targetClass;
     for (Uint32 i = 0 ; i < commInstances.size() ; i++)     for (Uint32 i = 0 ; i < commInstances.size() ; i++)
     {     {
  
         CIMInstance instance = _buildInstanceSkeleton(CIM_COMMMECHANISMFORMANAGER_CLASSNAME);          CIMInstance instance = _buildInstanceSkeleton(objectPath,CIM_COMMMECHANISMFORMANAGER_CLASSNAME,
                                                         targetClass);
  
         _setPropertyValue(instance,CIMName("Antecedent"), refObjMgr);         _setPropertyValue(instance,CIMName("Antecedent"), refObjMgr);
         //ATTNATTN: this is weak qualifier.         //ATTNATTN: this is weak qualifier.
         _setPropertyValue(instance,CIMName("Dependent"), _buildReference(commInstances[i],CIM_COMMMECHANISMFORMANAGER_CLASSNAME));          _setPropertyValue(instance,CIMName("Dependent"),
               _buildReference(objectPath, commInstances[i],CIM_COMMMECHANISMFORMANAGER_CLASSNAME));
   
           instance.setPath(instance.buildPath(targetClass));
         assocInstances.append(instance);         assocInstances.append(instance);
     }     }
  
Line 1138 
Line 1292 
 /* generate one instance of the CIM_Namespace class with the /* generate one instance of the CIM_Namespace class with the
    properties    properties
    NOTE: CIM 2.4 - Changed to build PG namespace    NOTE: CIM 2.4 - Changed to build PG namespace
      @param objectPath
    @param namespace name to put into the class    @param namespace name to put into the class
    @exceptions - exceptions carried forward from create instance    @exceptions - exceptions carried forward from create instance
    and addProperty.    and addProperty.
 */ */
 CIMInstance InteropProvider::_buildInstancePGNamespace(const CIMNamespaceName & nameSpace)  CIMInstance InteropProvider::_buildInstancePGNamespace(const CIMObjectPath& objectPath,
           CIMNamespaceName& nameSpace)
 { {
     PEG_METHOD_ENTER(TRC_CONTROLPROVIDER,     PEG_METHOD_ENTER(TRC_CONTROLPROVIDER,
             "InteropProvider::_buildInstancePGNamespace");             "InteropProvider::_buildInstancePGNamespace");
Line 1153 
Line 1309 
     // interop or more generally somewhere within the system for common access.     // interop or more generally somewhere within the system for common access.
     String ObjectManagerName = "ObjectManagerNameValue";     String ObjectManagerName = "ObjectManagerNameValue";
  
     CIMInstance instance = _buildInstanceSkeleton(PG_NAMESPACE_CLASSNAME);      CIMClass targetClass;
       CIMInstance instance = _buildInstanceSkeleton(objectPath, PG_NAMESPACE_CLASSNAME,
                                                     targetClass);
  
     _fixInstanceCommonKeys(instance);     _fixInstanceCommonKeys(instance);
  
Line 1232 
Line 1390 
     _setPropertyValue(instance, PG_NAMESPACE_PROPERTY_PARENTNAMESPACE, parent);     _setPropertyValue(instance, PG_NAMESPACE_PROPERTY_PARENTNAMESPACE, parent);
         _setPropertyValue(instance, PG_NAMESPACE_PROPERTY_NAME, name);         _setPropertyValue(instance, PG_NAMESPACE_PROPERTY_NAME, name);
  
       instance.setPath(instance.buildPath(targetClass));
     PEG_METHOD_EXIT();     PEG_METHOD_EXIT();
     return(instance);     return(instance);
 } }
   
 void _validateCIMNamespaceKeys(const CIMObjectPath& objectPath) void _validateCIMNamespaceKeys(const CIMObjectPath& objectPath)
 { {
     PEG_METHOD_ENTER(TRC_CONTROLPROVIDER,     PEG_METHOD_ENTER(TRC_CONTROLPROVIDER,
Line 1327 
Line 1487 
         }         }
         else         else
         {         {
             //  
             _setPropertyValue(instance, propertyName, value);             _setPropertyValue(instance, propertyName, value);
         }         }
     }     }
Line 1475 
Line 1634 
 /** builds complete object path from instance and classinfo by building the full path /** builds complete object path from instance and classinfo by building the full path
     with host and namespace names included.     with host and namespace names included.
 */ */
 CIMObjectPath InteropProvider::_buildObjectPath(const CIMNamespaceName& name,  CIMObjectPath InteropProvider::_buildObjectPath(const CIMObjectPath& objectPath,
                                                 const CIMName& className,                                                 const CIMName& className,
                                                 const CIMInstance& instance)                                                 const CIMInstance& instance)
 { {
     PEG_METHOD_ENTER(TRC_CONTROLPROVIDER,     PEG_METHOD_ENTER(TRC_CONTROLPROVIDER,
             "InteropProvider::_buildObjectPath");             "InteropProvider::_buildObjectPath");
  
     CIMObjectPath objectPath;      CIMObjectPath rtnObjectPath;
     objectPath = _buildInstancePath(name,className,instance);      rtnObjectPath = _buildInstancePath(objectPath,className,instance);
  
     objectPath.setHost(System::getHostName());      rtnObjectPath.setHost(objectPath.getHost());
  
     objectPath.setNameSpace(name);      rtnObjectPath.setNameSpace(objectPath.getNameSpace());
  
     PEG_METHOD_EXIT();     PEG_METHOD_EXIT();
     return(objectPath);      return(rtnObjectPath);
 } }
  
 /* Given a class and instance build the instance path for a /* Given a class and instance build the instance path for a
Line 1501 
Line 1660 
    @exceptions - Passes repository exceptions.    @exceptions - Passes repository exceptions.
 */ */
  
 CIMObjectPath InteropProvider::_buildInstancePath(const CIMNamespaceName& name,  CIMObjectPath InteropProvider::_buildInstancePath(const CIMObjectPath& objectPath,
                                            const CIMName& className,                                            const CIMName& className,
                                            const CIMInstance& instance)                                            const CIMInstance& instance)
 { {
Line 1510 
Line 1669 
  
     // get the class CIM_Namespace class to use in building path     // get the class CIM_Namespace class to use in building path
     // Exception out if Class does not exist in this namespace     // Exception out if Class does not exist in this namespace
     CIMClass thisClass = _getClass(name, className);      CIMClass thisClass = _getClass(objectPath, className);
  
     CIMObjectPath ref = instance.buildPath(thisClass);     CIMObjectPath ref = instance.buildPath(thisClass);
  
Line 1560 
Line 1719 
     String name;     String name;
     propertyValue.get(name);     propertyValue.get(name);
     return(name);     return(name);
     //ATTN: KS Returns String whereas below returns CIMNamespaceName.  
 } }
  
 //*************************************************************************** //***************************************************************************
Line 1582 
Line 1740 
             (const char *) instanceReference.toString().getCString());             (const char *) instanceReference.toString().getCString());
  
         handler.processing();         handler.processing();
         CIMNamespaceName newNamespaceName;  
  
         CDEBUG("CreateInstance " << instanceReference.toString());         CDEBUG("CreateInstance " << instanceReference.toString());
         // operation namespace needed internally to get class.         // operation namespace needed internally to get class.
         _operationNamespace = instanceReference.getNameSpace();          // KS_TEMP _operationNamespace = instanceReference.getNameSpace();
  
         // Verify that ClassName is correct and get value         // Verify that ClassName is correct and get value
         targetClass classEnum  = _verifyValidClassInput(instanceReference.getClassName());         targetClass classEnum  = _verifyValidClassInput(instanceReference.getClassName());
Line 1594 
Line 1751 
         String userName = _validateUserID(context);         String userName = _validateUserID(context);
         CIMObjectPath newInstanceReference;         CIMObjectPath newInstanceReference;
  
         if ((classEnum == CIM_OBJECTMANAGER) ||          CIMNamespaceName newNamespaceName;
             (classEnum == PG_CIMXMLCOMMUNICATIONMECHANISM))  
             throw CIMNotSupportedException("InteropProvider, Create Not allowed");  
   
         if (classEnum == PG_NAMESPACE)         if (classEnum == PG_NAMESPACE)
         {         {
 #ifdef PEGASUS_OS_OS400 #ifdef PEGASUS_OS_OS400
             MessageLoaderParms mparms("ControlProviders.InteropProvider.CREATE_INSTANCE_NOT_ALLOWED",              MessageLoaderParms mparms(
                   "ControlProviders.InteropProvider.CREATE_INSTANCE_NOT_ALLOWED",
                                       "Create instance operation not allowed by Interop Provider for class $0.",                                       "Create instance operation not allowed by Interop Provider for class $0.",
                                       PG_NAMESPACE_CLASSNAME.getString());                                       PG_NAMESPACE_CLASSNAME.getString());
             throw CIMNotSupportedException(mparms);             throw CIMNotSupportedException(mparms);
Line 1613 
Line 1768 
             // Validate that keys are as required. Does its own exception.             // Validate that keys are as required. Does its own exception.
             newNamespaceName = _getKeyValue(myInstance, CIM_NAMESPACE_PROPERTY_NAME);             newNamespaceName = _getKeyValue(myInstance, CIM_NAMESPACE_PROPERTY_NAME);
  
             newInstanceReference = _buildInstancePath(_operationNamespace,              newInstanceReference = _buildInstancePath(instanceReference,
                                         PG_NAMESPACE_CLASSNAME, localInstance);                                         PG_NAMESPACE_CLASSNAME, localInstance);
 #endif #endif
         }         }
  
           else if ((classEnum == CIM_OBJECTMANAGER) ||
               (classEnum == PG_CIMXMLCOMMUNICATIONMECHANISM))
           {
               PEG_METHOD_EXIT();
               throw CIMNotSupportedException("InteropProvider, Create Not allowed");
           }
   
         else   // Invalid class for the create functions.         else   // Invalid class for the create functions.
         {         {
             PEGASUS_ASSERT(false);             PEGASUS_ASSERT(false);
Line 1677 
Line 1839 
                 "Namespace = " + newNamespaceName.getString() +                 "Namespace = " + newNamespaceName.getString() +
                     " successfully created.");                     " successfully created.");
             Logger::put(Logger::STANDARD_LOG, System::CIMSERVER, Logger::TRACE,             Logger::put(Logger::STANDARD_LOG, System::CIMSERVER, Logger::TRACE,
                 "Create Namespace: Shareable = $0, Updates allows: $1,  Parent: $2",                  "Create Namespace: Shareable = $0, Updates allowed: $1,  Parent: $2",
                 newNamespaceName.getString(), shareable? "true" : "false", shareable? "true" : "false", parent );                  newNamespaceName.getString(), shareable?
                           "true" : "false", shareable? "true" : "false", parent );
  
         }         }
         catch(const CIMException&)         catch(const CIMException&)
Line 1718 
Line 1881 
             thisProvider,             thisProvider,
             (const char *) instanceName.toString().getCString());             (const char *) instanceName.toString().getCString());
  
         _operationNamespace = instanceName.getNameSpace();          // KS_TEMP _operationNamespace = instanceName.getNameSpace();
         handler.processing();         handler.processing();
         // Verify that ClassName is correct and get value         // Verify that ClassName is correct and get value
         targetClass classEnum  = _verifyValidClassInput(instanceName.getClassName());         targetClass classEnum  = _verifyValidClassInput(instanceName.getClassName());
Line 1730 
Line 1893 
         {         {
             try             try
             {             {
                 _repository->deleteInstance(_operationNamespace,instanceName);                  _repository->deleteInstance(instanceName.getNameSpace(),instanceName);
             }             }
             catch(const CIMException&)             catch(const CIMException&)
             {             {
Line 1742 
Line 1905 
         {         {
             CIMNamespaceName deleteNamespaceName;             CIMNamespaceName deleteNamespaceName;
 #ifdef PEGASUS_OS_OS400 #ifdef PEGASUS_OS_OS400
             MessageLoaderParms mparms("ControlProviders.InteropProvider.DELETE_INSTANCE_NOT_ALLOWED",              MessageLoaderParms mparms(
                   "ControlProviders.InteropProvider.DELETE_INSTANCE_NOT_ALLOWED",
                                       "Delete instance operation not allowed by Interop Provider for class $0.",                                       "Delete instance operation not allowed by Interop Provider for class $0.",
                                       PG_NAMESPACE_CLASSNAME.getString());                                       PG_NAMESPACE_CLASSNAME.getString());
             throw CIMNotSupportedException(mparms);             throw CIMNotSupportedException(mparms);
Line 1776 
Line 1940 
             throw CIMNotSupportedException("Delete Not allowed for " + instanceName.getClassName().getString());             throw CIMNotSupportedException("Delete Not allowed for " + instanceName.getClassName().getString());
         }         }
  
         handler.processing();  
   
         handler.complete();         handler.complete();
  
         PEG_METHOD_EXIT();         PEG_METHOD_EXIT();
Line 1804 
Line 1966 
             (const char *)_showBool(includeQualifiers).getCString(),             (const char *)_showBool(includeQualifiers).getCString(),
             (const char*) _showBool(includeClassOrigin).getCString(),             (const char*) _showBool(includeClassOrigin).getCString(),
             (const char *)_showPropertyList(propertyList).getCString());             (const char *)_showPropertyList(propertyList).getCString());
   
         // Verify that ClassName is correct and get value         // Verify that ClassName is correct and get value
         targetClass classEnum  = _verifyValidClassInput(instanceName.getClassName());         targetClass classEnum  = _verifyValidClassInput(instanceName.getClassName());
  
         _operationNamespace = instanceName.getNameSpace();  
         String userName = _validateUserID(context);         String userName = _validateUserID(context);
   
         // begin processing the request         // begin processing the request
         handler.processing();         handler.processing();
           CIMInstance instance;
           Boolean found = false;
         if (classEnum == CIM_OBJECTMANAGER)         if (classEnum == CIM_OBJECTMANAGER)
         {         {
             CIMInstance instance = _getInstanceCIMObjectManager(includeQualifiers,              instance = _getInstanceCIMObjectManager(
                               instanceName,
                               includeQualifiers,
                                         includeClassOrigin, propertyList);                                         includeClassOrigin, propertyList);
             handler.deliver(instance);              if (instanceName == instance.getPath())
             handler.complete();              {
             PEG_METHOD_EXIT();                  found = true;
             return;              }
               //handler.deliver(instance);
         }         }
  
         if (classEnum == PG_CIMXMLCOMMUNICATIONMECHANISM)          else if (classEnum == PG_CIMXMLCOMMUNICATIONMECHANISM)
         {         {
             // ATTN: test for correct instance KS: Priority 1             // ATTN: test for correct instance KS: Priority 1
             Array <CIMInstance> instances = _buildInstancesPGCIMXMLCommunicationMechanism(              Array <CIMInstance> instances =
                   _buildInstancesPGCIMXMLCommunicationMechanism(
                               instanceName,
                                     includeQualifiers,                                     includeQualifiers,
                                     includeClassOrigin, propertyList);                                     includeClassOrigin, propertyList);
             handler.deliver(instances[0]);              for (Uint32 i = 0 ; i < instances.size() ; i++)
             handler.complete();              {
             PEG_METHOD_EXIT();                  if (instanceName == instances[i].getPath())
             return;                  {
                       instance = instances[i];
                       found = true;
                       break;
                   }
               }
               //instance = instances[0];
               //handler.deliver(instances[0]);
         }         }
  
         if (classEnum == CIM_NAMESPACEINMANAGER)          else if (classEnum == CIM_NAMESPACEINMANAGER)
         {         {
             handler.complete();  
             PEG_METHOD_EXIT();  
             return;  
         }         }
  
           else if (classEnum == PG_NAMESPACE)
           {
         // Get List of namespaces         // Get List of namespaces
         Array<CIMNamespaceName> namespaceNames;         Array<CIMNamespaceName> namespaceNames;
         namespaceNames = _enumerateNameSpaces();         namespaceNames = _enumerateNameSpaces();
         CIMInstance instance;  
  
         if (classEnum == PG_NAMESPACE)  
         {  
             // Not clear what we have to take into account here.             // Not clear what we have to take into account here.
             // get the namespace from the name value.             // get the namespace from the name value.
             // should check the other keys to see if valid.             // should check the other keys to see if valid.
             CIMNamespaceName namespaceName;              CIMNamespaceName namespaceName =
             namespaceName = _getKeyValue(instanceName, CIM_NAMESPACE_PROPERTY_NAME);                  _getKeyValue(instanceName, CIM_NAMESPACE_PROPERTY_NAME);
  
             // ATTN: Why this CIMNamespaceName parentNamespaceName = instanceName.getNameSpace();             // ATTN: Why this CIMNamespaceName parentNamespaceName = instanceName.getNameSpace();
             if (!Contains(namespaceNames, namespaceName))             if (!Contains(namespaceNames, namespaceName))
Line 1862 
Line 2035 
             PEG_TRACE_STRING(TRC_CONTROLPROVIDER, Tracer::LEVEL4,             PEG_TRACE_STRING(TRC_CONTROLPROVIDER, Tracer::LEVEL4,
                "Namespace = " + namespaceName.getString() + " successfully found.");                "Namespace = " + namespaceName.getString() + " successfully found.");
  
             instance = _getInstanceCIMNamespace(namespaceName);              instance = _getInstanceCIMNamespace(instanceName);
               found = true;
         }         }
         else  // processing for __Namespace         else  // processing for __Namespace
         {         {
             PEGASUS_ASSERT(false);              PEG_METHOD_EXIT();
               throw CIMNotSupportedException
                   (instanceName.getClassName().getString() + " not supported by Interop Provider");
         }         }
          if (found)
          {
              instance.filter( includeQualifiers,
                               includeClassOrigin,
                               propertyList);
        handler.deliver(instance);        handler.deliver(instance);
          }
  
        // complete processing the request  
        handler.complete();        handler.complete();
  
        PEG_METHOD_EXIT();        PEG_METHOD_EXIT();
        return ;        return ;
     }     }
  
   
   
 //*************************************************************************** //***************************************************************************
 //                enumerateInstances //                enumerateInstances
 //*************************************************************************** //***************************************************************************
Line 1902 
Line 2084 
         // Verify that ClassName is correct and get value         // Verify that ClassName is correct and get value
         targetClass classEnum  = _verifyValidClassInput(ref.getClassName());         targetClass classEnum  = _verifyValidClassInput(ref.getClassName());
  
         // operation namespace needed internally to get class.  
         _operationNamespace = ref.getNameSpace();  
         CDEBUG("Namespace = " << _operationNamespace.getString());  
         //String userName = _validateUserID(context);         //String userName = _validateUserID(context);
  
         // The following 3 classes deliver a single instance because         // The following 3 classes deliver a single instance because
         // that is all there is today.         // that is all there is today.
   
           Array<CIMInstance> instances;
         if (classEnum == CIM_OBJECTMANAGER)         if (classEnum == CIM_OBJECTMANAGER)
         {         {
             CIMInstance instance = _getInstanceCIMObjectManager(includeQualifiers,              CIMInstance instance = _getInstanceCIMObjectManager(
                                       ref,
                                       includeQualifiers,
                                     includeClassOrigin,                                     includeClassOrigin,
                                     propertyList);                                     propertyList);
  
             //Array<Sint8> tmp;              instances.append(instance);
             ///XmlWriter::appendInstanceElement(tmp, instance);  
             //tmp.append('\0');  
             //Logger::put(Logger::STANDARD_LOG, System::CIMSERVER, Logger::TRACE,  
             //        "Instance - XML content: $0", tmp.getData());  
             ///XmlWriter::printInstanceElement(instance);  
             handler.deliver(instance);  
             //handler.complete();  
             //PEG_METHOD_EXIT();  
             //return;  
         }         }
  
         else if (classEnum == PG_CIMXMLCOMMUNICATIONMECHANISM)         else if (classEnum == PG_CIMXMLCOMMUNICATIONMECHANISM)
         {         {
             Array<CIMInstance> instances = _buildInstancesPGCIMXMLCommunicationMechanism(includeQualifiers,              instances = _buildInstancesPGCIMXMLCommunicationMechanism(
                                     includeClassOrigin, propertyList);                                      ref,
             CDEBUG("Build instances of PGCIMXML. count= " << instances.size());                                      includeQualifiers,
             handler.deliver(instances);                                      includeClassOrigin,
             //handler.complete();                                      propertyList);
             //PEG_METHOD_EXIT();  
             //return;  
         }         }
  
         else if (classEnum == CIM_NAMESPACEINMANAGER)         else if (classEnum == CIM_NAMESPACEINMANAGER)
Line 1947 
Line 2119 
  
         else if (classEnum == PG_NAMESPACE)         else if (classEnum == PG_NAMESPACE)
         {         {
             Array<CIMInstance> instances = _getInstancesCIMNamespace(includeQualifiers,              instances = _getInstancesCIMNamespace(
                                     includeClassOrigin, propertyList);                                      ref,
                                       includeQualifiers,
             handler.deliver(instances);                                      includeClassOrigin,
             //handler.complete();                                      propertyList);
             //PEG_METHOD_EXIT();  
             //return;  
         }         }
         else         else
         {         {
               PEG_METHOD_EXIT();
             throw CIMNotSupportedException             throw CIMNotSupportedException
                 ("EnumerateInstance for " + ref.getClassName().getString() + " not supported");                  (ref.getClassName().getString() + " not supported by Interop Provider");
         }         }
  
           // Filter and deliver the resulting instances
           for (Uint32 i = 0 ; i < instances.size() ; i++)
           {
               _finishInstance(instances[i], ref, includeQualifiers,
                                   includeClassOrigin,
                                   propertyList );
               /*** Debug Trace of the Instances generated
               Tracer::trace(TRC_CONTROLPROVIDER, Tracer::LEVEL4,
                   "%s enumerateInstances return instance number %u\npath: %s\n %s",thisProvider, i,
                   (instances[i].getPath().toString().getCString()),
                   ( ( CIMObject) instances[i]).toString().getCString());
               ****/
   
               handler.deliver(instances[i]);
           }
         handler.complete();         handler.complete();
  
         PEG_METHOD_EXIT();         PEG_METHOD_EXIT();
Line 1975 
Line 2161 
 { {
     PEG_METHOD_ENTER(TRC_CONTROLPROVIDER,     PEG_METHOD_ENTER(TRC_CONTROLPROVIDER,
             "InteropProvider::modifyInstanceManagerInstance");             "InteropProvider::modifyInstanceManagerInstance");
   
     // the only allowed modification is this one property, statistical data     // the only allowed modification is this one property, statistical data
   
     if (modifiedIns.findProperty(OM_GATHERSTATISTICALDATA) != PEG_NOT_FOUND)     if (modifiedIns.findProperty(OM_GATHERSTATISTICALDATA) != PEG_NOT_FOUND)
     {     {
         // the following is a temporary hack to set the value of the statistics         // the following is a temporary hack to set the value of the statistics
Line 1983 
Line 2171 
         // and call the internal method to set it each time this object is         // and call the internal method to set it each time this object is
         // built.         // built.
 #ifndef PEGASUS_DISABLE_PERFINST #ifndef PEGASUS_DISABLE_PERFINST
         Boolean statisticsFlag = _getPropertyValue(modifiedIns, OM_GATHERSTATISTICALDATA, false);          Boolean statisticsFlag = _getPropertyValue(modifiedIns,
                   OM_GATHERSTATISTICALDATA, false);
         CIMInstance instance;         CIMInstance instance;
         instance = _getInstanceCIMObjectManager(true, true, CIMPropertyList());          instance = _getInstanceCIMObjectManager(instanceReference,
                   true, true, CIMPropertyList());
  
         if (statisticsFlag != _getPropertyValue(instance,  OM_GATHERSTATISTICALDATA, false))         if (statisticsFlag != _getPropertyValue(instance,  OM_GATHERSTATISTICALDATA, false))
         {         {
Line 1994 
Line 2184 
             // Modify the object on disk             // Modify the object on disk
             try             try
             {             {
                 _repository->modifyInstance(_operationNamespace,                  _repository->modifyInstance(instanceReference.getNameSpace(),
                                instance );                                instance );
             }             }
             catch(const CIMException&)             catch(const CIMException&)
Line 2023 
Line 2213 
     // ATTN Expand this defintion to be more precise since it allows only mod of     // ATTN Expand this defintion to be more precise since it allows only mod of
     // one property and that property MUST be in the instance to be modifiable.     // one property and that property MUST be in the instance to be modifiable.
     throw CIMNotSupportedException     throw CIMNotSupportedException
         (OM_GATHERSTATISTICALDATA.getString() + " modify operation not supported by Interop Provider");          (OM_GATHERSTATISTICALDATA.getString() +
                   " modify operation not supported by Interop Provider");
 } }
 //*************************************************************************** //***************************************************************************
 //                modifyInstance //                modifyInstance
Line 2035 
Line 2226 
     const CIMPropertyList& propertyList,     const CIMPropertyList& propertyList,
     ResponseHandler & handler)     ResponseHandler & handler)
 { {
   
     PEG_METHOD_ENTER(TRC_CONTROLPROVIDER,     PEG_METHOD_ENTER(TRC_CONTROLPROVIDER,
             "InteropProvider::modifyInstance");             "InteropProvider::modifyInstance");
  
Line 2047 
Line 2237 
         (const char *) _showPropertyList(propertyList).getCString());         (const char *) _showPropertyList(propertyList).getCString());
  
     // ATTN: KS 31 August 2004. This must test for privileged user.     // ATTN: KS 31 August 2004. This must test for privileged user.
     _operationNamespace = instanceReference.getNameSpace();  
     CIMName className =  instanceReference.getClassName();     CIMName className =  instanceReference.getClassName();
     targetClass classEnum  = _verifyValidClassInput(instanceReference.getClassName());      targetClass classEnum  = _verifyValidClassInput(className);
  
     String userName = _validateUserID(context);     String userName = _validateUserID(context);
     // begin processing the request     // begin processing the request
Line 2072 
Line 2262 
     else if (classEnum == PG_NAMESPACE)     else if (classEnum == PG_NAMESPACE)
     {     {
 #ifdef PEGASUS_OS_OS400 #ifdef PEGASUS_OS_OS400
             MessageLoaderParms mparms("ControlProviders.InteropProvider.MODIFY_INSTANCE_NOT_ALLOWED",              MessageLoaderParms mparms(
                   "ControlProviders.InteropProvider.MODIFY_INSTANCE_NOT_ALLOWED",
                                       "Modify instance operation not allowed by Interop Provider for class $0.",                                       "Modify instance operation not allowed by Interop Provider for class $0.",
                                       PG_NAMESPACE_CLASSNAME.getString());                                       PG_NAMESPACE_CLASSNAME.getString());
             throw CIMNotSupportedException(mparms);             throw CIMNotSupportedException(mparms);
Line 2085 
Line 2276 
     }     }
     else     else
     {     {
         PEGASUS_ASSERT(false);  // should never get here.          PEG_METHOD_EXIT();
           throw CIMNotSupportedException(
               className.getString() + " not supported by Interop Provider");
     }     }
  
     handler.complete();     handler.complete();
Line 2104 
Line 2297 
         PEG_METHOD_ENTER(TRC_CONTROLPROVIDER,         PEG_METHOD_ENTER(TRC_CONTROLPROVIDER,
                 "InteropProvider::enumerateInstanceNames()");                 "InteropProvider::enumerateInstanceNames()");
  
         // operation namespace needed internally to get class.          Tracer::trace(TRC_CONTROLPROVIDER, Tracer::LEVEL4,
         _operationNamespace = classReference.getNameSpace();              "%s enumerateInstanceNames. classReference= %s",
               thisProvider,
               (const char *) classReference.toString().getCString());
  
         targetClass classEnum  = _verifyValidClassInput(classReference.getClassName());          targetClass classEnum  =
                   _verifyValidClassInput(classReference.getClassName());
  
         String userName = _validateUserID(context);         String userName = _validateUserID(context);
  
Line 2117 
Line 2313 
         // Deliver a single instance because there should only be one instance.         // Deliver a single instance because there should only be one instance.
         if (classEnum == CIM_OBJECTMANAGER)         if (classEnum == CIM_OBJECTMANAGER)
         {         {
             CIMInstance instance = _getInstanceCIMObjectManager( true, true, CIMPropertyList());              CIMInstance instance = _getInstanceCIMObjectManager(
             CIMObjectPath ref = _buildInstancePath(_operationNamespace,                              classReference, true, true, CIMPropertyList());
   
               CIMObjectPath ref = _buildInstancePath(classReference,
                 CIM_OBJECTMANAGER_CLASSNAME, instance);                 CIM_OBJECTMANAGER_CLASSNAME, instance);
   
             handler.deliver(ref);             handler.deliver(ref);
             handler.complete();  
             PEG_METHOD_EXIT();  
             return;  
         }         }
  
         // Deliver all possible instances of this class         // Deliver all possible instances of this class
         if (classEnum == PG_CIMXMLCOMMUNICATIONMECHANISM)          else if (classEnum == PG_CIMXMLCOMMUNICATIONMECHANISM)
         {         {
             Array<CIMInstance> instances = _buildInstancesPGCIMXMLCommunicationMechanism(true,              Array<CIMInstance> instances =
                   _buildInstancesPGCIMXMLCommunicationMechanism(
                           classReference, true,
                  true, CIMPropertyList());                  true, CIMPropertyList());
  
             for (Uint32 i = 0 ; i < instances.size() ; i++)             for (Uint32 i = 0 ; i < instances.size() ; i++)
             {             {
                 CIMObjectPath ref = _buildInstancePath(_operationNamespace,                  CIMObjectPath ref = _buildInstancePath(classReference,
                     PG_CIMXMLCOMMUNICATIONMECHANISM_CLASSNAME, instances[i]);                     PG_CIMXMLCOMMUNICATIONMECHANISM_CLASSNAME, instances[i]);
                 handler.deliver(ref);                 handler.deliver(ref);
             }             }
             handler.complete();  
             PEG_METHOD_EXIT();  
             return;  
         }         }
  
         if (classEnum == CIM_NAMESPACEINMANAGER)          else if (classEnum == CIM_NAMESPACEINMANAGER)
         {         {
             handler.complete();  
             PEG_METHOD_EXIT();  
             return;  
         }         }
  
         if (classEnum == PG_NAMESPACE)          else if (classEnum == PG_NAMESPACE)
         {         {
             Array<CIMInstance> instances = _getInstancesCIMNamespace(false,              Array<CIMInstance> instances = _getInstancesCIMNamespace(
                                       classReference,
                                       false,
                                     false, CIMPropertyList());                                     false, CIMPropertyList());
             CDEBUG("EvalNames. Found instances. Count= " << instances.size());             CDEBUG("EvalNames. Found instances. Count= " << instances.size());
   
             for (Uint32 i = 0 ; i < instances.size() ; i++)             for (Uint32 i = 0 ; i < instances.size() ; i++)
             {             {
                 CIMObjectPath ref = _buildInstancePath(_operationNamespace,                  CIMObjectPath ref = _buildInstancePath(classReference,
                                             CIM_NAMESPACE_CLASSNAME, instances[i]);                                             CIM_NAMESPACE_CLASSNAME, instances[i]);
                 handler.deliver(ref);                 handler.deliver(ref);
             }             }
   
             handler.complete();  
             PEG_METHOD_EXIT();  
             return;  
         }         }
  
         if (classEnum == CIM_COMMMECHANISMFORMANAGERINST)          else if (classEnum == CIM_COMMMECHANISMFORMANAGERINST)
         {         {
             Array<CIMInstance> instances = _buildInstancesCommMechanismForManager();              Array<CIMInstance> instances =
                   _buildInstancesCommMechanismForManager(classReference);
   
             for (Uint32 i = 0 ; i < instances.size() ; i++ )             for (Uint32 i = 0 ; i < instances.size() ; i++ )
             {             {
                 CIMObjectPath ref = _buildObjectPath(_operationNamespace,                  CIMObjectPath ref = _buildObjectPath(classReference,
                         CIM_COMMMECHANISMFORMANAGER_CLASSNAME, instances[i]);                         CIM_COMMMECHANISMFORMANAGER_CLASSNAME, instances[i]);
                 handler.deliver(ref);                 handler.deliver(ref);
             }             }
         }         }
  
         if (classEnum == CIM_NAMESPACEINMANAGERINST)          else if (classEnum == CIM_NAMESPACEINMANAGERINST)
         {         {
             Array<CIMInstance> instances = _buildInstancesNamespaceInManager();              Array<CIMInstance> instances = _buildInstancesNamespaceInManager(classReference);
             for (Uint32 i = 0 ; i < instances.size() ; i++ )             for (Uint32 i = 0 ; i < instances.size() ; i++ )
             {             {
                 CIMObjectPath ref = _buildObjectPath(_operationNamespace,                  CIMObjectPath ref = _buildObjectPath(classReference,
                         CIM_NAMESPACEINMANAGER_CLASSNAME, instances[i]);                         CIM_NAMESPACEINMANAGER_CLASSNAME, instances[i]);
                 handler.deliver(ref);                 handler.deliver(ref);
             }             }
         }         }
           else
           {
               // ERROR: Code should never get here because of Enum tests.
               throw CIMNotSupportedException("Class not processed by Interop "
                    + classReference.getClassName().getString());
           }
  
  
         // ATTN: Exception response because of error         // ATTN: Exception response because of error
           handler.complete();
         PEG_METHOD_EXIT();         PEG_METHOD_EXIT();
     }     }
  
Line 2267 
Line 2467 
     CDEBUG("::referenceNames(): object= " << objectName.toString() << " result Class= " << resultClass.getString());     CDEBUG("::referenceNames(): object= " << objectName.toString() << " result Class= " << resultClass.getString());
  
     // operation namespace needed internally to get class.     // operation namespace needed internally to get class.
     _operationNamespace = objectName.getNameSpace();      // KS_TEMP _operationNamespace = objectName.getNameSpace();
     String userName = _validateUserID(context);     String userName = _validateUserID(context);
     // begin processing the request     // begin processing the request
     handler.processing();     handler.processing();
Line 2276 
Line 2476 
  
     CIMName targetAssocClassName = resultClass;     CIMName targetAssocClassName = resultClass;
  
     CIMName targetClassName = objectName.getClassName();      // KSTEMPCIMName targetClassName = objectName.getClassName();
  
     targetAssocClass classEnum  = _verifyValidAssocClassInput(targetAssocClassName);     targetAssocClass classEnum  = _verifyValidAssocClassInput(targetAssocClassName);
  
     Array<CIMInstance> assocInstances;     Array<CIMInstance> assocInstances;
  
     if (classEnum == CIM_COMMMECHANISMFORMANAGERASSOC)     if (classEnum == CIM_COMMMECHANISMFORMANAGERASSOC)
         assocInstances = _buildInstancesCommMechanismForManager();          assocInstances = _buildInstancesCommMechanismForManager(objectName);
  
     if (classEnum == CIM_NAMESPACEINMANAGERASSOC)     if (classEnum == CIM_NAMESPACEINMANAGERASSOC)
         assocInstances = _buildInstancesNamespaceInManager();          assocInstances = _buildInstancesNamespaceInManager(objectName);
  
     _filterAssocInstances(assocInstances, resultClass, role);     _filterAssocInstances(assocInstances, resultClass, role);
  
     for (Uint32 i = 0 ; i < assocInstances.size() ; i++ )     for (Uint32 i = 0 ; i < assocInstances.size() ; i++ )
     {     {
         CIMObjectPath ref = _buildObjectPath(_operationNamespace,          CIMObjectPath ref = _buildObjectPath(objectName,
                 targetAssocClassName, assocInstances[i]);                 targetAssocClassName, assocInstances[i]);
         CDEBUG("referenceNames returns: " << ref.toString());         CDEBUG("referenceNames returns: " << ref.toString());
         handler.deliver(ref);         handler.deliver(ref);

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