OW_CIMRepository2.cpp

Go to the documentation of this file.

/*******************************************************************************
* Copyright (C) 2002 Center 7, Inc All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions are met:
*
*  - Redistributions of source code must retain the above copyright notice,
*    this list of conditions and the following disclaimer.
*
*  - Redistributions in binary form must reproduce the above copyright notice,
*    this list of conditions and the following disclaimer in the documentation
*    and/or other materials provided with the distribution.
*
*  - Neither the name of Center 7 nor the names of its
*    contributors may be used to endorse or promote products derived from this
*    software without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS ``AS IS''
* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
* ARE DISCLAIMED. IN NO EVENT SHALL Center 7, Inc OR THE CONTRIBUTORS
* BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
* POSSIBILITY OF SUCH DAMAGE.
*******************************************************************************/
#include "OW_config.h"
#include "OW_CIMRepository2.hpp"
#include "OW_FileSystem.hpp"
#include "OW_CIMValueCast.hpp"
#include "OW_CIMOMHandleIFC.hpp"
#include "OW_ConfigOpts.hpp"
#include "OW_Format.hpp"
#include "OW_WQLIFC.hpp"
#include "OW_Assertion.hpp"
#include "OW_IOException.hpp"
#include "OW_CIMParamValue.hpp"
#include "OW_ConfigOpts.hpp"
#include "OW_Map.hpp"
#include "OW_CIMQualifierType.hpp"
#include "OW_CIMClass.hpp"
#include "OW_CIMInstance.hpp"
#include "OW_CIMProperty.hpp"
#include "OW_CIMValue.hpp"
#include "OW_CIMQualifier.hpp"
#include "OW_CIMObjectPath.hpp"
#include "OW_Logger.hpp"
#include "OW_dbUtils.hpp"

namespace OW_NAMESPACE
{

OW_DEFINE_EXCEPTION(CIMRepository2);

using namespace WBEMFlags;


namespace
{
LoggerRef g_logger;
void dbErrorCallback(const char *errpfx, char *msg)
{
   // have to use the global here since we can't pass in any sort of handle into db :-(
   if (g_logger)
   {
      OW_LOG_ERROR(g_logger, msg);
   }
}
}

CIMRepository2::CIMRepository2(ServiceEnvironmentIFCRef env)
   : RepositoryIFC()
   , m_iStore(env)
   , m_mStore(env)
#ifndef OW_DISABLE_ASSOCIATION_TRAVERSAL
   , m_classAssocDb(env)
   , m_instAssocDb(env)
#endif
   , m_env(env)
   , m_checkReferentialIntegrity(false)
   , m_dbenv(0)
{
   g_logger = m_env->getLogger(COMPONENT_NAME);

   if (m_env->getConfigItem(ConfigOpts::CHECK_REFERENTIAL_INTEGRITY_opt,
      OW_DEFAULT_CHECK_REFERENTIAL_INTEGRITY).equalsIgnoreCase("true"))
   {
      m_checkReferentialIntegrity = true;
   }

   OW_LOG_DEBUG(m_env->getLogger(COMPONENT_NAME), format("CIMRepository2 initializing with libdb version: %1", ::db_version(0, 0, 0)));

}
CIMRepository2::~CIMRepository2()
{
   try
   {
      close();
   }
   catch (...)
   {
      // don't let exceptions escape
   }
}

namespace
{
class DBTransactionScope
{
public:
   DBTransactionScope(::DB_ENV* env)
      : m_tid(0)
   {
      OW_ASSERT(env != 0);
      int ret = env->txn_begin(env, 0, &m_tid, 0);
      dbUtils::checkReturn(ret, "txn_begin");
   }
   ~DBTransactionScope()
   {
      if (m_tid != 0)
      {
         try
         {
            abort();
         }
         catch (...)
         {
            // can't let exceptions escape
         }
      }
   }
   void commit()
   {
      OW_ASSERT(m_tid != 0);
      int ret = m_tid->commit(m_tid, 0);
      dbUtils::checkReturn(ret, "txn_commit");
      m_tid = 0;
   }
   void abort()
   {
      OW_ASSERT(m_tid != 0);
      int ret = m_tid->abort(m_tid);
      dbUtils::checkReturn(ret, "txn_abort");
      m_tid = 0;
   }

   operator ::DB_TXN*()
   {
      return m_tid;
   }

private:
   ::DB_TXN* m_tid;
};
} // end unnamed namespace

void
CIMRepository2::open(const String& path)
{
   FileSystem::makeDirectory(path, 0700);
   if (!FileSystem::exists(path))
   {
      String msg("failed to create directory: " );
      msg += path;
      OW_THROW(IOException, msg.c_str());
   }
   else
   {
      if (!FileSystem::canWrite(path))
      {
         String msg("don't have write access to directory: ");
         msg += path;
         OW_THROW(IOException, msg.c_str());
      }
   }
   String fname = path;
   if (!fname.endsWith(String(OW_FILENAME_SEPARATOR)))
   {
      fname += OW_FILENAME_SEPARATOR;
   }
   
   // Create a db environment object and initialize it for error
   // reporting.
   int ret;
   if ((ret = ::db_env_create(&m_dbenv, 0)) != 0)
   {
      OW_THROW(CIMRepository2Exception, format("::db_env_create() failed: %1(%2)", ret, ::db_strerror(ret)).c_str());
   }
   m_dbenv->set_errcall(m_dbenv, dbErrorCallback);
   m_dbenv->set_errpfx(m_dbenv, "CIMRepository2");

   // We want to specify the shared memory buffer pool cachesize,
   // but everything else is the default.
   const int size = 64 * 1024;
   if ((ret = m_dbenv->set_cachesize(m_dbenv, 0, size, 0)) != 0)
   {
      m_dbenv->close(m_dbenv, 0);
      OW_THROW(CIMRepository2Exception, format("m_dbenv->set_cachesize() failed: %1(%2)", ret, ::db_strerror(ret)).c_str());
   }

#ifdef OW_DEBUG
   m_dbenv->set_verbose(m_dbenv,DB_VERB_CHKPOINT | DB_VERB_DEADLOCK | DB_VERB_RECOVERY | DB_VERB_REPLICATION | DB_VERB_WAITSFOR, 1);
#endif


   // Open the db environment with full transactional support.
   // DB_CREATE creates the db env if this is the first time we're running.  It's also required if DB_RECOVER is specified.
   // DB_INIT_LOCK | DB_INIT_LOG | DB_INIT_MPOOL | DB_INIT_TXN initializes the sub-systems we need for transactions.
   // DB_PRIVATE is used since we (currently) only access the db from the cimom.  Recovery has to run single-threaded and we don't have any way of
   // ensuring that if multiple processes are involved.  If the cimom is changed to use a fork() model this should be changed.
   // DB_THREAD since we are multi-threaded.  This shouldn't be removed if the cimom is changed to fork() for each connection unless all threads are removed.
   // DB_RECOVER replays the transaction logs and will clean up the db if the cimom didn't correctly shut down previously.
   ret = m_dbenv->open(m_dbenv, fname.c_str(),
      DB_CREATE |
      DB_INIT_LOCK | DB_INIT_LOG | DB_INIT_MPOOL | DB_INIT_TXN |
      DB_PRIVATE |
      DB_THREAD |
      DB_RECOVER,
      0600);
   dbUtils::checkReturn(ret, "m_dbenv->open");

   // opens happen in the context of a transaction
   DBTransactionScope tid(m_dbenv);
   m_iStore.open(m_dbenv, tid);

   m_mStore.open(m_dbenv, tid);
#ifndef OW_DISABLE_ASSOCIATION_TRAVERSAL
   m_classAssocDb.open("classassoc", m_dbenv, tid);
   m_instAssocDb.open("instanceassoc", m_dbenv, tid);
#endif
   tid.commit();
}
void
CIMRepository2::close()
{
   m_iStore.close();
   m_mStore.close();
#ifndef OW_DISABLE_ASSOCIATION_TRAVERSAL
   m_classAssocDb.close();
   m_instAssocDb.close();
#endif
   if (m_dbenv)
   {
      m_dbenv->close(m_dbenv, 0);
      m_dbenv = 0;
   }
}
#ifndef OW_DISABLE_INSTANCE_MANIPULATION

void
CIMRepository2::createNameSpace(const String& ns,
   OperationContext& context)
{
   m_mStore.createNameSpace(ns, context);

   if (m_env->getLogger(COMPONENT_NAME)->getLogLevel() == E_DEBUG_LEVEL)
   {
      OW_LOG_DEBUG(m_env->getLogger(COMPONENT_NAME), format("CIMRepository2 created namespace: %1", ns));
   }
}
void
CIMRepository2::deleteNameSpace(const String& ns,
   OperationContext& context)
{
   m_mStore.deleteNameSpace(ns, context);
   
   if (m_env->getLogger(COMPONENT_NAME)->getLogLevel() == E_DEBUG_LEVEL)
   {
      OW_LOG_DEBUG(m_env->getLogger(COMPONENT_NAME), format("CIMRepository2 deleted namespace: %1", ns));
   }
}
#endif

void
CIMRepository2::enumNameSpace(StringResultHandlerIFC& result,
   OperationContext& context)
{
   m_mStore.enumNameSpace(result, context);
   
   if (m_env->getLogger(COMPONENT_NAME)->getLogLevel() == E_DEBUG_LEVEL)
   {
      OW_LOG_DEBUG(m_env->getLogger(COMPONENT_NAME), "CIMRepository2 enumerated namespaces");
   }
}
CIMQualifierType
CIMRepository2::getQualifierType(const String& ns,
   const String& qualifierName,
   OperationContext&)
{
   CIMQualifierType rv = m_mStore.getQualifierType(ns, qualifierName);
   if (m_env->getLogger(COMPONENT_NAME)->getLogLevel() == E_DEBUG_LEVEL)
   {
      OW_LOG_DEBUG(m_env->getLogger(COMPONENT_NAME), format("CIMRepository2 getting qualifier type: %1",
         CIMObjectPath(qualifierName,ns).toString()));
   }
   return rv;
}
#ifndef OW_DISABLE_QUALIFIER_DECLARATION

void
CIMRepository2::enumQualifierTypes(
   const String& ns,
   CIMQualifierTypeResultHandlerIFC& result,
   OperationContext&)
{
   m_mStore.enumQualifierTypes(ns, result);
   if (m_env->getLogger(COMPONENT_NAME)->getLogLevel() == E_DEBUG_LEVEL)
   {
      OW_LOG_DEBUG(m_env->getLogger(COMPONENT_NAME), format("CIMRepository2 enumerated qualifiers in namespace: %1", ns));
   }
}
void
CIMRepository2::deleteQualifierType(const String& ns, const String& qualName,
   OperationContext&)
{
   // TODO: What happens if the qualifier is being used???
   if (!m_mStore.deleteQualifierType(ns, qualName))
   {
      if (m_mStore.nameSpaceExists(ns))
      {
         OW_THROWCIMMSG(CIMException::NOT_FOUND,
            String(ns + "/" + qualName).c_str());
      }
      else
      {
         OW_THROWCIMMSG(CIMException::INVALID_NAMESPACE,
            String(ns + "/" + qualName).c_str());
      }
   }
   
   if (m_env->getLogger(COMPONENT_NAME)->getLogLevel() == E_DEBUG_LEVEL)
   {
      OW_LOG_DEBUG(m_env->getLogger(COMPONENT_NAME), format("CIMRepository2 deleted qualifier type: %1 in namespace: %2", qualName, ns));
   }
}
void
CIMRepository2::setQualifierType(
   const String& ns,
   const CIMQualifierType& qt, OperationContext&)
{
   m_mStore.setQualifierType(ns, qt);
   if (m_env->getLogger(COMPONENT_NAME)->getLogLevel() == E_DEBUG_LEVEL)
   {
      OW_LOG_DEBUG(m_env->getLogger(COMPONENT_NAME), format("CIMRepository2 set qualifier type: %1 in "
         "namespace: %2", qt.toString(), ns));
   }
}
#endif // #ifndef OW_DISABLE_QUALIFIER_DECLARATION

CIMClass
CIMRepository2::getClass(
   const String& ns, const String& className,
   ELocalOnlyFlag localOnly, EIncludeQualifiersFlag includeQualifiers,
   EIncludeClassOriginFlag includeClassOrigin, const StringArray* propertyList,
   OperationContext&)
{
   CIMClass theClass(CIMNULL);
   CIMException::ErrNoType rval = m_mStore.getCIMClass(ns, className,
      localOnly, includeQualifiers, includeClassOrigin, propertyList,
      theClass);
   checkGetClassRvalAndThrow(rval, ns, className);
   if (m_env->getLogger(COMPONENT_NAME)->getLogLevel() == E_DEBUG_LEVEL)
   {
      OW_LOG_DEBUG(m_env->getLogger(COMPONENT_NAME), format("CIMRepository2 got class: %1 from "
         "namespace: %2", theClass.getName(), ns));
   }
   return theClass;
}
CIMClass
CIMRepository2::_getClass(const String& ns, const String& className)
{
   CIMClass theClass(CIMNULL);
   CIMException::ErrNoType rval = m_mStore.getCIMClass(ns, className, E_NOT_LOCAL_ONLY, E_INCLUDE_QUALIFIERS, E_INCLUDE_CLASS_ORIGIN, 0, theClass);
   checkGetClassRvalAndThrow(rval, ns, className);
   return theClass;
}
CIMClass
CIMRepository2::_instGetClass(const String& ns, const String& className)
{
   CIMClass theClass(CIMNULL);
   CIMException::ErrNoType rval = m_mStore.getCIMClass(ns, className, E_NOT_LOCAL_ONLY, E_INCLUDE_QUALIFIERS, E_INCLUDE_CLASS_ORIGIN, 0, theClass);
   checkGetClassRvalAndThrowInst(rval, ns, className);
   return theClass;
}
#ifndef OW_DISABLE_SCHEMA_MANIPULATION

namespace
{
   class CIMClassDeleter : public CIMClassResultHandlerIFC
   {
   public:
      CIMClassDeleter(MetaRepository2& mr, const String& ns_,
         InstanceRepository2& mi
#ifndef OW_DISABLE_ASSOCIATION_TRAVERSAL
         , AssocDb2& m_assocDb_
#endif
         )
      : m_mStore(mr)
      , ns(ns_)
      , m_iStore(mi)
#ifndef OW_DISABLE_ASSOCIATION_TRAVERSAL
      , m_assocDb(m_assocDb_)
#endif
      {}
   protected:
      virtual void doHandle(const CIMClass &c)
      {
         String cname = c.getName();
         // TODO: this doesn't work quite right. Fix deleteInstance to also delete
         // associations, then we could just call enumInstances and then
         // deleteInstance for all instances.
         // delete any instances of the class
         //m_iStore.deleteClass(ns, cname);
#ifndef OW_DISABLE_ASSOCIATION_TRAVERSAL
         // remove class from association index
         if (c.isAssociation())
         {
            m_assocDb.deleteEntries(ns,c);
         }
#endif
         if (!m_mStore.deleteClass(ns, cname))
         {
            OW_THROWCIM(CIMException::NOT_FOUND);
         }
      }
   private:
      MetaRepository2& m_mStore;
      const String& ns;
      InstanceRepository2& m_iStore;
#ifndef OW_DISABLE_ASSOCIATION_TRAVERSAL
      AssocDb2& m_assocDb;
#endif
   };
}
CIMClass
CIMRepository2::deleteClass(const String& ns, const String& className,
   OperationContext& acl)
{
   CIMClass cc = _getClass(ns, className);
   OW_ASSERT(cc);
   // TODO: delete associations to the instances we delete
   CIMClassDeleter ccd(m_mStore, ns, m_iStore
#ifndef OW_DISABLE_ASSOCIATION_TRAVERSAL
      , m_classAssocDb
#endif
      );
   this->enumClasses(ns, className, ccd,
      E_DEEP, E_LOCAL_ONLY,
      E_EXCLUDE_QUALIFIERS,
      E_EXCLUDE_CLASS_ORIGIN,
      acl);
   ccd.handle(cc);
   if (m_env->getLogger(COMPONENT_NAME)->getLogLevel() == E_DEBUG_LEVEL)
   {
      OW_LOG_DEBUG(m_env->getLogger(COMPONENT_NAME), format("CIMRepository2 deleted class: %1:%2",
         ns, className));
   }
   return cc;
}
void
CIMRepository2::createClass(const String& ns, const CIMClass& cimClass_,
   OperationContext&)
{
   // m_mStore.createClass modifies cimClass to be consistent with base
   // classes, etc.
   CIMClass cimClass(cimClass_);
   m_mStore.createClass(ns, cimClass);
   // we need to re-get the class, so that it will be consistent.  currently
   // cimClass only contains "unique" items that are added in the child class.
   cimClass = _getClass(ns, cimClass.getName());
#ifndef OW_DISABLE_ASSOCIATION_TRAVERSAL
   if (cimClass.isAssociation())
   {
      m_classAssocDb.addEntries(ns,cimClass);
   }
#endif
   if (m_env->getLogger(COMPONENT_NAME)->getLogLevel() == E_DEBUG_LEVEL)
   {
      OW_LOG_DEBUG(m_env->getLogger(COMPONENT_NAME), format("Created class: %1:%2", ns, cimClass.toMOF()));
   }
}
CIMClass
CIMRepository2::modifyClass(
   const String& ns,
   const CIMClass& cc,
   OperationContext&)
{
   OW_ASSERT(cc);
   CIMClass origClass = _getClass(ns, cc.getName());
   // TODO: this needs to update the subclasses of the modified class.
   //       If that's not possible, then we need to throw a
   //       CLASS_HAS_CHILDREN CIMException.
   // TODO: Need to update the instances of the class and any subclasses.
   //       If that's not possible, then we need to throw a
   //       CLASS_HAS_INSTANCES CIMException.
   m_mStore.modifyClass(ns, cc);
   OW_ASSERT(origClass);
   if (m_env->getLogger(COMPONENT_NAME)->getLogLevel() == E_DEBUG_LEVEL)
   {
      OW_LOG_DEBUG(m_env->getLogger(COMPONENT_NAME), format("Modified class: %1:%2 from %3 to %4", ns,
         cc.getName(), origClass.toMOF(), cc.toMOF()));
   }
   return origClass;
}
#endif // #ifndef OW_DISABLE_SCHEMA_MANIPULATION

void
CIMRepository2::enumClasses(const String& ns,
      const String& className,
      CIMClassResultHandlerIFC& result,
      EDeepFlag deep, ELocalOnlyFlag localOnly, EIncludeQualifiersFlag includeQualifiers,
      EIncludeClassOriginFlag includeClassOrigin, OperationContext&)
{
   m_mStore.enumClass(ns, className,
      result, deep,
      localOnly, includeQualifiers, includeClassOrigin);
   if (m_env->getLogger(COMPONENT_NAME)->getLogLevel() == E_DEBUG_LEVEL)
   {
      OW_LOG_DEBUG(m_env->getLogger(COMPONENT_NAME), format("CIMRepository2 enumerated classes: %1:%2", ns,
         className));
   }
}
void
CIMRepository2::enumClassNames(
   const String& ns,
   const String& className,
   StringResultHandlerIFC& result,
   EDeepFlag deep, OperationContext&)
{
   m_mStore.enumClassNames(ns, className, result, deep);
   if (m_env->getLogger(COMPONENT_NAME)->getLogLevel() == E_DEBUG_LEVEL)
   {
      OW_LOG_DEBUG(m_env->getLogger(COMPONENT_NAME), format("CIMRepository2 enumerated class names: %1:%2", ns,
         className));
   }
}
namespace {
class stringArrayBuilder : public StringResultHandlerIFC
{
public:
   stringArrayBuilder(StringArray& result)
      : m_result(result)
   {}
   void doHandle(const String& name)
   {
      m_result.push_back(name);
   }
private:
   StringArray& m_result;
};
// utility function
StringArray getClassChildren(MetaRepository2& rep, const String& ns, const String& clsName)
{
   StringArray result;
   stringArrayBuilder handler(result);
   rep.enumClassNames(ns, clsName, handler, E_DEEP);
   return result;
}
}
void
CIMRepository2::enumInstanceNames(
   const String& ns,
   const String& className,
   CIMObjectPathResultHandlerIFC& result,
   EDeepFlag deep,
   OperationContext&)
{
   CIMClass theClass = _instGetClass(ns, className);
   m_iStore.getInstanceNames(ns, theClass, result);
   if (m_env->getLogger(COMPONENT_NAME)->getLogLevel() == E_DEBUG_LEVEL)
   {
      OW_LOG_DEBUG(m_env->getLogger(COMPONENT_NAME), format("CIMRepository2 enumerated instance names: %1:%2", ns,
         className));
   }
   if (!deep)
   {
      return;
   }
   // This code probably won't ever be executed, because CIMServer
   // has to do each class at a time because of providers, and will
   // thus only call us with deep=false.
   // If the situation ever changes, fix and enable the code below.
   OW_THROWCIMMSG(CIMException::FAILED, "Internal server error");
   // TODO: Switch this to use a callback interface.
   /*
   StringArray classNames = m_mStore.getClassChildren(ns,
      theClass.getName());
   for (size_t i = 0; i < classNames.size(); i++)
   {
      theClass = _instGetClass(ns, classNames[i]);
      m_iStore.getInstanceNames(ns, theClass, result);
      if (m_env->getLogger(COMPONENT_NAME)->getLogLevel() == E_DEBUG_LEVEL)
      {
         OW_LOG_DEBUG(m_env->getLogger(COMPONENT_NAME), format("CIMRepository2 enumerated derived instance names: %1:%2", ns,
            classNames[i]));
      }
   }
   */
}
namespace {
class instEnumerator : public StringResultHandlerIFC
{
public:
   instEnumerator(CIMRepository2& rep_,
      const String& ns_,
      const CIMClass& theTopClass_,
      CIMInstanceResultHandlerIFC& result_,
      EDeepFlag deep_,
      ELocalOnlyFlag localOnly_,
      EIncludeQualifiersFlag includeQualifiers_,
      EIncludeClassOriginFlag includeClassOrigin_,
      const StringArray* propertyList_)
      : rep(rep_)
      , ns(ns_)
      , theTopClass(theTopClass_)
      , result(result_)
      , deep(deep_)
      , localOnly(localOnly_)
      , includeQualifiers(includeQualifiers_)
      , includeClassOrigin(includeClassOrigin_)
      , propertyList(propertyList_)
   {}
   void doHandle(const String& className)
   {
      CIMClass theClass = rep._instGetClass(ns, className);
      rep.m_iStore.getCIMInstances(ns, className, theTopClass, theClass, result,
         deep, localOnly, includeQualifiers, includeClassOrigin, propertyList);
      if (rep.m_env->getLogger(COMPONENT_NAME)->getLogLevel() == E_DEBUG_LEVEL)
      {
         OW_LOG_DEBUG(rep.m_env->getLogger(COMPONENT_NAME), format("CIMRepository2 Enumerated derived instances: %1:%2", ns, className));
      }
   }
private:
   CIMRepository2& rep;
   const String& ns;
   const CIMClass& theTopClass;
   CIMInstanceResultHandlerIFC& result;
   EDeepFlag deep;
   ELocalOnlyFlag localOnly;
   EIncludeQualifiersFlag includeQualifiers;
   EIncludeClassOriginFlag includeClassOrigin;
   const StringArray* propertyList;
};
} // end unnamed namespace
void
CIMRepository2::enumInstances(
   const String& ns,
   const String& className,
   CIMInstanceResultHandlerIFC& result, EDeepFlag deep,
   ELocalOnlyFlag localOnly,
   EIncludeQualifiersFlag includeQualifiers,
   EIncludeClassOriginFlag includeClassOrigin,
   const StringArray* propertyList,
   EEnumSubclassesFlag enumSubclasses, OperationContext&)
{
   // deep means a different thing here than for enumInstanceNames.  See the spec.
   CIMClass theTopClass = _instGetClass(ns, className);
   m_iStore.getCIMInstances(ns, className, theTopClass, theTopClass, result,
      deep, localOnly, includeQualifiers, includeClassOrigin, propertyList);
   
   if (m_env->getLogger(COMPONENT_NAME)->getLogLevel() == E_DEBUG_LEVEL)
   {
      OW_LOG_DEBUG(m_env->getLogger(COMPONENT_NAME), format("CIMRepository2 Enumerated instances: %1:%2", ns,
         className));
   }
   if (enumSubclasses)
   {
      instEnumerator ie(*this, ns, theTopClass, result, deep, localOnly, includeQualifiers, includeClassOrigin, propertyList);
      m_mStore.enumClassNames(ns, className, ie, E_DEEP);
   }
}
CIMInstance
CIMRepository2::getInstance(
   const String& ns,
   const CIMObjectPath& instanceName,
   ELocalOnlyFlag localOnly,
   EIncludeQualifiersFlag includeQualifiers,
   EIncludeClassOriginFlag includeClassOrigin,
   const StringArray* propertyList, OperationContext& context)
{
   return getInstance(ns, instanceName, localOnly, includeQualifiers, includeClassOrigin,
      propertyList, NULL, context);
}
CIMInstance
CIMRepository2::getInstance(
   const String& ns,
   const CIMObjectPath& instanceName,
   ELocalOnlyFlag localOnly,
   EIncludeQualifiersFlag includeQualifiers, EIncludeClassOriginFlag includeClassOrigin,
   const StringArray* propertyList, CIMClass* pOutClass,
   OperationContext&)
{
   StringArray lpropList;
   if (propertyList)
   {
      lpropList = *propertyList;
   }
   CIMInstance ci(CIMNULL);
   CIMClass cc(_instGetClass(ns, instanceName.getClassName()));
   ci = m_iStore.getCIMInstance(ns, instanceName, cc, localOnly,
      includeQualifiers, includeClassOrigin, propertyList);
   OW_ASSERT(ci);
   if (pOutClass)
   {
      *pOutClass = cc;
   }
   
   return ci;
}
#ifndef OW_DISABLE_INSTANCE_MANIPULATION

CIMInstance
CIMRepository2::deleteInstance(const String& ns, const CIMObjectPath& cop_,
   OperationContext& acl)
{
   CIMObjectPath cop(cop_);
   cop.setNameSpace(ns);
   if (m_env->getLogger(COMPONENT_NAME)->getLogLevel() == E_DEBUG_LEVEL)
   {
      OW_LOG_DEBUG(m_env->getLogger(COMPONENT_NAME), format("CIMRepository2::deleteInstance.  cop = %1",
         cop.toString()));
   }
   CIMClass theClass(CIMNULL);
   CIMInstance oldInst = getInstance(ns, cop, E_NOT_LOCAL_ONLY, E_INCLUDE_QUALIFIERS, E_INCLUDE_CLASS_ORIGIN, NULL,
      &theClass, acl);
#ifndef OW_DISABLE_ASSOCIATION_TRAVERSAL
   // Ensure no associations exist for this instance
   if (m_instAssocDb.hasAssocEntries(ns, cop))
   {
      // TODO: Revisit this.  Instead of throwing, it is allowed in the
      // spec to to delete the associations that reference the instance.
      // See http://dmtf.org/standards/documents/WBEM/DSP200.html
      //   2.3.2.4. DeleteInstance
      OW_THROWCIMMSG(CIMException::FAILED,
         format("Instance %1 has associations", cop.toString()).c_str());
   }
   // TODO: It would be good to check for Min(1) relationships to the
   // instance.
   
   // If we're deleting an association instance, then remove all
   // traces of it in the association database.
   if (theClass.isAssociation())
   {
      m_instAssocDb.deleteEntries(ns, oldInst);
   }
#endif
   // Delete the instance from the instance repository
   m_iStore.deleteInstance(ns, cop, theClass);
   OW_ASSERT(oldInst);
   return oldInst;
}
CIMObjectPath
CIMRepository2::createInstance(
   const String& ns,
   const CIMInstance& ci,
   OperationContext&)
{
   CIMObjectPath rval(ns, ci);
   if (m_env->getLogger(COMPONENT_NAME)->getLogLevel() == E_DEBUG_LEVEL)
   {
      OW_LOG_DEBUG(