version 1.1, 2007/11/05 18:28:15
|
version 1.1.2.9, 2007/12/01 18:18:25
|
|
|
|
//%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> |
|
|
|
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() |
|
{ |
|
// 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::registerProviderModule( |
|
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::registerProvider( |
|
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::registerProviderCapabilities( |
|
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::registerSingletonProvider( |
|
const Array<CIMNamespaceName>& nameSpaces, |
|
const CIMName& className, |
|
ProviderInterface providerInterface, |
|
Uint32 providerTypes) |
|
{ |
|
// Register PG_ProviderModule: |
|
|
|
String moduleName = className.getString() + "_Module"; |
|
String location = moduleName; |
|
|
|
if (!registerProviderModule(moduleName, location, providerInterface)) |
|
{ |
|
return false; |
|
} |
|
|
|
// Register PG_Provider: |
|
|
|
String providerName = className.getString() + "_Provider"; |
|
|
|
if (!registerProvider(moduleName, providerName)) |
|
{ |
|
return false; |
|
} |
|
|
|
// Register PG_ProviderCapabilities: |
|
|
|
|
|
String capabilityId = className.getString(); |
|
|
|
if (!registerProviderCapabilities(moduleName, 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); |
|
} |
|
|
|
#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 |