(file) Return to EmbeddedServer.cpp CVS log (file) (dir) Up to [Pegasus] / pegasus / vxworks / cimserver / Attic

Diff for /pegasus/vxworks/cimserver/Attic/EmbeddedServer.cpp between version 1.1 and 1.1.2.1

version 1.1, 2008/04/28 18:04:04 version 1.1.2.1, 2008/04/28 18:04:04
Line 0 
Line 1 
   //%2006////////////////////////////////////////////////////////////////////////
   //
   // Copyright (c) 2000, 2001, 2002 BMC Software; Hewlett-Packard Development
   // Company, L.P.; IBM Corp.; The Open Group; Tivoli Systems.
   // Copyright (c) 2003 BMC Software; Hewlett-Packard Development Company, L.P.;
   // IBM Corp.; EMC Corporation, The Open Group.
   // Copyright (c) 2004 BMC Software; Hewlett-Packard Development Company, L.P.;
   // IBM Corp.; EMC Corporation; VERITAS Software Corporation; The Open Group.
   // Copyright (c) 2005 Hewlett-Packard Development Company, L.P.; IBM Corp.;
   // EMC Corporation; VERITAS Software Corporation; The Open Group.
   // Copyright (c) 2006 Hewlett-Packard Development Company, L.P.; IBM Corp.;
   // EMC Corporation; Symantec Corporation; The Open Group.
   //
   // Permission is hereby granted, free of charge, to any person obtaining a copy
   // of this software and associated documentation files (the "Software"), to
   // deal in the Software without restriction, including without limitation the
   // rights to use, copy, modify, merge, publish, distribute, sublicense, and/or
   // sell copies of the Software, and to permit persons to whom the Software is
   // furnished to do so, subject to the following conditions:
   //
   // THE ABOVE COPYRIGHT NOTICE AND THIS PERMISSION NOTICE SHALL BE INCLUDED IN
   // ALL COPIES OR SUBSTANTIAL PORTIONS OF THE SOFTWARE. THE SOFTWARE IS PROVIDED
   // "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT
   // LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR
   // PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
   // HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
   // ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
   // WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
   //
   //==============================================================================
   //
   //%/////////////////////////////////////////////////////////////////////////////
   
   #include "EmbeddedServer.h"
   #include <Pegasus/Common/Logger.h>
   #include <Pegasus/Server/ProviderTable.h>
   #include <Pegasus/Repository/MemoryResidentRepository.h>
   
   #define STATIC_MODULE "Static_Module"
   
   PEGASUS_NAMESPACE_BEGIN
   
   //==============================================================================
   //
   // Local definitions:
   //
   //==============================================================================
   
   extern void* (*lookupSymbolCallback)(
       const char* path, const char* name, void* data);
   
   extern void* lookupSymbolData;
   
   struct Symbol
   {
       String path;
       String name;
       void* address;
       Symbol* next;
   };
   
   struct EmbeddedServerRep
   {
       MemoryResidentRepository* mrr;
   
       static void initializeCallback(MemoryResidentRepository* mrr, void* data_)
       {
           EmbeddedServer* es = (EmbeddedServer*)data_;
           EmbeddedServerRep* rep = (EmbeddedServerRep*)es->_opaque;
           rep->mrr = mrr;
           es->initialize();
           rep->mrr = 0;
       }
   
       Symbol* symbols;
   };
   
   static void _logCallback(
       int type,
       const char* system,
       int level,
       const char* message,
       void* data)
   {
       EmbeddedServer* es = (EmbeddedServer*)data;
       es->putLog(type, system, level, message);
   }
   
   static void _saveCallback(const Buffer& buffer, void* data_)
   {
       EmbeddedServer* es = (EmbeddedServer*)data_;
   
       Array<Uint8> data((const Uint8*)buffer.getData(), buffer.size());
       es->saveRepository(data);
   }
   
   static void _loadCallback(Buffer& buffer, void* data_)
   {
       EmbeddedServer* es = (EmbeddedServer*)data_;
   
       buffer.clear();
       Array<Uint8> data;
       es->loadRepository(data);
   
       if (data.size())
           buffer.append((const char*)data.getData(), data.size());
   }
   
   static void* _lookupSymbolCallback(
       const char* path,
       const char* name,
       void* data)
   {
       EmbeddedServerRep* rep = (EmbeddedServerRep*)data;
   
       for (Symbol* p = rep->symbols; p; p = p->next)
       {
           if (p->path == path && p->name == name)
               return p->address;
       }
   
       // Not found!
       return 0;
   }
   
   //==============================================================================
   //
   // class EmbeddedServer
   //
   //==============================================================================
   
   const Uint32 EmbeddedServer::INSTANCE_PROVIDER_TYPE = 1;
   const Uint32 EmbeddedServer::ASSOCIATION_PROVIDER_TYPE = 2;
   const Uint32 EmbeddedServer::INDICATION_PROVIDER_TYPE = 4;
   const Uint32 EmbeddedServer::METHOD_PROVIDER_TYPE = 8;
   const Uint32 EmbeddedServer::INSTANCE_QUERY_PROVIDER_TYPE = 16;
   
   EmbeddedServer::EmbeddedServer() : _createdStaticProviderModule(false)
   {
       // Initialize representation object:
   
       EmbeddedServerRep* rep = (EmbeddedServerRep*)_opaque;
       memset(rep, 0, sizeof(EmbeddedServerRep));
   
       // Install the callbacks:
   
       Logger::installLogCallback(_logCallback, this);
   
       MemoryResidentRepository::installSaveCallback(_saveCallback, this);
   
       MemoryResidentRepository::installLoadCallback(_loadCallback, this);
   
       MemoryResidentRepository::installInitializeCallback(
           EmbeddedServerRep::initializeCallback, this);
   
       lookupSymbolCallback = _lookupSymbolCallback;
       lookupSymbolData = rep;
   }
   
   EmbeddedServer::~EmbeddedServer()
   {
   }
   
   void EmbeddedServer::initialize()
   {
   }
   
   #if 0
   Boolean EmbeddedServer::addProvider(
       const String& moduleName,
       const String& providerName,
       const CIMNamespaceName& nameSpace,
       const CIMName& className,
       CIMProvider* (*createProvider)(const String& providerName))
   {
       if (providerTableSize == MAX_PROVIDER_TABLE_SIZE)
           return false;
   
       ProviderTableEntry entry;
       entry.moduleName = strdup(moduleName.getCString());
       entry.providerName = strdup(providerName.getCString());
       entry.nameSpace = strdup(nameSpace.getString().getCString());
       entry.className = strdup(className.getString().getCString());
       entry.createProvider = createProvider;
   
       providerTable[providerTableSize++] = entry;
   
       return true;
   }
   #endif
   
   Boolean EmbeddedServer::addNameSpace(const SchemaNameSpace* nameSpace)
   {
       return MemoryResidentRepository::addNameSpace(nameSpace);
   }
   
   void EmbeddedServer::loadRepository(Array<Uint8>& data)
   {
       // No implementation!
   }
   
   void EmbeddedServer::saveRepository(const Array<Uint8>& data)
   {
       // No implementation!
   }
   
   void EmbeddedServer::putLog(
       int type,
       const char* system,
       int level,
       const char* message)
   {
       // No implementation!
   }
   
   extern "C" int PegasusServerMain(int argc, char** argv);
   
   Boolean EmbeddedServer::run(int argc, char** argv)
   {
       try
       {
           PegasusServerMain(argc, argv);
           return true;
       }
       catch (...)
       {
           return false;
       }
   
       return true;
   }
   
   static Boolean _providerModuleInstanceExists(
       MemoryResidentRepository* mrr,
       const String& name)
   {
       try
       {
           CIMObjectPath cop;
           Array<CIMKeyBinding> bindings;
           bindings.append(CIMKeyBinding("Name", name, CIMKeyBinding::STRING));
           cop.setClassName("PG_ProviderModule");
           cop.setKeyBindings(bindings);
   
           CIMInstance ci = mrr->getInstance(true,
               "root/PG_InterOp", cop, true, false, false, CIMPropertyList());
   
           return true;
       }
       catch (...)
       {
           return false;
       }
   
       return false;
   }
   
   static Boolean _providerInstanceExists(
       MemoryResidentRepository* mrr,
       const String& providerModuleName,
       const String& name)
   {
       try
       {
           CIMObjectPath cop;
           Array<CIMKeyBinding> bindings;
           bindings.append(CIMKeyBinding("Name", name, CIMKeyBinding::STRING));
           bindings.append(CIMKeyBinding(
               "ProviderModuleName", providerModuleName, CIMKeyBinding::STRING));
           cop.setClassName("PG_Provider");
           cop.setKeyBindings(bindings);
   
           CIMInstance ci = mrr->getInstance(true,
               "root/PG_InterOp", cop, true, false, false, CIMPropertyList());
   
           return true;
       }
       catch (...)
       {
           return false;
       }
   
       return false;
   }
   
   Boolean EmbeddedServer::_create_PG_ProviderModule(
       const String& moduleName,
       const String& location,
       ProviderInterface providerInterface)
   {
       EmbeddedServerRep* rep = (EmbeddedServerRep*)_opaque;
   
       // Reject if repository is null at this point.
   
       if (!rep->mrr)
           return false;
   
       //
       // Create instance of PG_ProviderModule:
       //
       //     instance of PG_ProviderModule
       //     {
       //         Name = "...";
       //         Vendor = "OpenPegasus";
       //         Version = "2.5.0";
       //         InterfaceType = "C++Default";
       //         InterfaceVersion = "2.5.0";
       //         Location = "cimplePerson";
       //     };
       //
   
       CIMInstance ci("PG_ProviderModule");
       ci.addProperty(CIMProperty("Name", moduleName));
       ci.addProperty(CIMProperty("Vendor", String("OpenPegasus")));
   
       String version;
       String interfaceType;
       String interfaceVersion;
   
       if (providerInterface == PEGASUS_PROVIDER_INTERFACE)
       {
           version = "2.6.0";
           interfaceType = "C++Default";
           interfaceVersion = "2.6.0";
       }
       else
       {
           version = "2.0.0";
           interfaceType = "CMPI";
           interfaceVersion = "2.0.0";
       }
   
       ci.addProperty(CIMProperty("Version", version));
       ci.addProperty(CIMProperty("InterfaceType", interfaceType));
       ci.addProperty(CIMProperty("InterfaceVersion", interfaceVersion));
       ci.addProperty(CIMProperty("Location", location));
   
       try
       {
           CIMObjectPath cop = rep->mrr->createInstance(
               false, "root/PG_InterOp", ci, ContentLanguageList());
       }
       catch (Exception& e)
       {
           return false;
       }
       catch (...)
       {
           return false;
       }
   
       return true;
   }
   
   Boolean EmbeddedServer::_create_PG_Provider(
       const String& moduleName,
       const String& providerName)
   {
       EmbeddedServerRep* rep = (EmbeddedServerRep*)_opaque;
   
       // Reject if repository is null at this point.
   
       if (!rep->mrr)
           return false;
   
       // Reject if provider module does not exist:
   
       if (!_providerModuleInstanceExists(rep->mrr, moduleName))
           return false;
   
       //
       // Create instance of PG_ProviderModule:
       //
       //     instance of PG_Provider
       //     {
       //         Name = "Person_Provider";
       //         ProviderModuleName = "Person_Module";
       //     };
       //
   
       CIMInstance ci("PG_Provider");
       ci.addProperty(CIMProperty("Name", providerName));
       ci.addProperty(CIMProperty("ProviderModuleName", moduleName));
   
       try
       {
           CIMObjectPath cop = rep->mrr->createInstance(
               false, "root/PG_InterOp", ci, ContentLanguageList());
       }
       catch (Exception& e)
       {
           return false;
       }
       catch (...)
       {
           return false;
       }
   
       return true;
   }
   
   Boolean EmbeddedServer::_create_PG_ProviderCapabilities(
       const String& moduleName,
       const String& providerName,
       const String& capabilityId,
       const CIMName& className,
       const Array<CIMNamespaceName>& nameSpaces,
       Uint32 providerTypes)
   {
       EmbeddedServerRep* rep = (EmbeddedServerRep*)_opaque;
   
       // Reject if repository is null at this point.
   
       if (!rep->mrr)
           return false;
   
       // Reject if provider module instance does not exist:
   
       if (!_providerModuleInstanceExists(rep->mrr, moduleName))
           return false;
   
       // Reject if provider instance does not exist:
   
       if (!_providerInstanceExists(rep->mrr, moduleName, providerName))
           return false;
   
       // Validate the namespaces:
       {
           if (nameSpaces.size() == 0)
               return false;
   
           Array<CIMNamespaceName> tmp;
   
           try
           {
               tmp = rep->mrr->enumerateNameSpaces(false);
           }
           catch (...)
           {
               return false;
           }
   
           for (Uint32 i = 0; i < nameSpaces.size(); i++)
           {
               Boolean found = false;
   
               for (Uint32 j = 0; j < tmp.size(); j++)
               {
                   if (nameSpaces[i] == tmp[j])
                   {
                       found = true;
                       break;
                   }
               }
   
               if (!found)
                   return false;
           }
       }
   
       //
       // Create instance of PG_ProviderCapabilities:
       //
       //     instance of PG_ProviderCapabilities
       //     {
       //         CapabilityID = "Person";
       //         ProviderModuleName = "Person_Module";
       //         ProviderName = "Person_Provider";
       //         ClassName = "Person";
       //         Namespaces = {"root/cimv2"};
       //         ProviderType = {2};
       //         supportedProperties = NULL;
       //         supportedMethods = NULL;
       //     };
       //
       CIMInstance ci("PG_ProviderCapabilities");
   
       // PG_ProviderCapabilities.CapabilityID:
       ci.addProperty(CIMProperty("CapabilityID", capabilityId));
   
       // PG_ProviderCapabilities.ProviderModuleName:
       ci.addProperty(CIMProperty("ProviderModuleName", moduleName));
   
       // PG_ProviderCapabilities.ProviderName:
       ci.addProperty(CIMProperty("ProviderName", providerName));
   
       // PG_ProviderCapabilities.ClassName:
       ci.addProperty(CIMProperty("ClassName", className.getString()));
   
       // PG_ProviderCapabilities.NameSpaces:
       {
           Array<String> tmp;
   
           for (Uint32 i = 0; i < nameSpaces.size(); i++)
               tmp.append(nameSpaces[i].getString());
   
           ci.addProperty(CIMProperty("Namespaces", tmp));
       }
   
       // PG_ProviderCapabilities.supportedProperties:
       ci.addProperty(
           CIMProperty("supportedProperties", CIMValue(CIMTYPE_STRING, true)));
   
       // PG_ProviderCapabilities.supportedMethods:
       ci.addProperty(
           CIMProperty("supportedMethods", CIMValue(CIMTYPE_STRING, true)));
   
       // PG_ProviderCapabilities.Namespaces:
       {
           Array<Uint16> tmp;
   
           if (providerTypes & EmbeddedServer::INSTANCE_PROVIDER_TYPE)
               tmp.append(2);
   
           if (providerTypes & EmbeddedServer::ASSOCIATION_PROVIDER_TYPE)
               tmp.append(3);
   
           if (providerTypes & EmbeddedServer::INDICATION_PROVIDER_TYPE)
               tmp.append(4);
   
           if (providerTypes & EmbeddedServer::METHOD_PROVIDER_TYPE)
               tmp.append(5);
   
           if (providerTypes & EmbeddedServer::INSTANCE_QUERY_PROVIDER_TYPE)
               tmp.append(7);
   
           ci.addProperty(CIMProperty("ProviderType", tmp));
       }
   
       // Create the instance:
       try
       {
           CIMObjectPath cop = rep->mrr->createInstance(
               false, "root/PG_InterOp", ci, ContentLanguageList());
       }
       catch (Exception& e)
       {
           return false;
       }
       catch (...)
       {
           return false;
       }
   
       return true;
   }
   
   Boolean EmbeddedServer::registerProvider(
       const Array<CIMNamespaceName>& nameSpaces,
       const CIMName& className,
       ProviderInterface providerInterface,
       Uint32 providerTypes)
   {
       // Register PG_ProviderModule:
   
       if (!_createdStaticProviderModule)
       {
           if (!_create_PG_ProviderModule(
               STATIC_MODULE, STATIC_MODULE, providerInterface))
           {
               return false;
           }
   
           _createdStaticProviderModule = true;
       }
   
       // Register PG_Provider:
   
       String providerName = className.getString() + "_Provider";
   
       if (!_create_PG_Provider(STATIC_MODULE, providerName))
       {
           return false;
       }
   
       // Register PG_ProviderCapabilities:
   
       String capabilityId = className.getString();
   
       if (!_create_PG_ProviderCapabilities(
           STATIC_MODULE, providerName, capabilityId,
           className, nameSpaces, providerTypes))
       {
           return false;
       }
   
       return true;
   }
   
   static Boolean _addSymbol(
       EmbeddedServerRep* rep,
       const String& path,
       const String& name,
       void* address)
   {
   
       if (_lookupSymbolCallback(path.getCString(), name.getCString(), rep))
           return false;
   
       Symbol* symbol = new Symbol;
       symbol->path = path;
       symbol->name = name;
       symbol->address = address;
   
       symbol->next = rep->symbols;
       rep->symbols = symbol;
   
       return true;
   }
   
   Boolean EmbeddedServer::registerPegasusProviderEntryPoint(
       const String& location,
       class CIMProvider* (*entryPoint)(const String&))
   {
       EmbeddedServerRep* rep = (EmbeddedServerRep*)_opaque;
   
       return _addSymbol(
           rep, location, "PegasusCreateProvider", (void*)entryPoint);
   }
   
   Boolean EmbeddedServer::registerPegasusCreateProviderEntryPoint(
       PegasusCreateProviderEntryPoint entryPoint)
   {
       return registerPegasusProviderEntryPoint(STATIC_MODULE, entryPoint);
   }
   
   #ifdef PEGASUS_ENABLE_CMPI_PROVIDER_MANAGER
   
   Boolean EmbeddedServer::registerCMPIProviderEntryPoint(
       const String& location,
       const String& providerName,
       CreateInstanceMIEntryPoint entryPoint)
   {
       EmbeddedServerRep* rep = (EmbeddedServerRep*)_opaque;
       String name = providerName + "_Create_InstanceMI";
       return _addSymbol(rep, location, name, (void*)entryPoint);
   }
   
   Boolean EmbeddedServer::registerCMPIProviderEntryPoint(
       const String& location,
       const String& providerName,
       CreateAssociationMIEntryPoint entryPoint)
   {
       EmbeddedServerRep* rep = (EmbeddedServerRep*)_opaque;
       String name = providerName + "_Create_AssociationMI";
       return _addSymbol(rep, location, name, (void*)entryPoint);
   }
   
   Boolean EmbeddedServer::registerCMPIProviderEntryPoint(
       const String& location,
       const String& providerName,
       CreateMethodMIEntryPoint entryPoint)
   {
       EmbeddedServerRep* rep = (EmbeddedServerRep*)_opaque;
       String name = providerName + "_Create_MethodMI";
       return _addSymbol(rep, location, name, (void*)entryPoint);
   }
   
   Boolean EmbeddedServer::registerCMPIProviderEntryPoint(
       const String& location,
       const String& providerName,
       CreateIndicationMIEntryPoint entryPoint)
   {
       EmbeddedServerRep* rep = (EmbeddedServerRep*)_opaque;
       String name = providerName + "_Create_IndicationMI";
       return _addSymbol(rep, location, name, (void*)entryPoint);
   }
   
   Boolean EmbeddedServer::registerCMPIProviderEntryPoint(
       const String& location,
       const String& providerName,
       CreatePropertyMIEntryPoint entryPoint)
   {
       EmbeddedServerRep* rep = (EmbeddedServerRep*)_opaque;
       String name = providerName + "_Create_PropertyMI";
       return _addSymbol(rep, location, name, (void*)entryPoint);
   }
   
   #endif /* PEGASUS_ENABLE_CMPI_PROVIDER_MANAGER */
   
   PEGASUS_NAMESPACE_END

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