modulecontroller.cpp

Pegasus is an open-source implementationof the DMTF CIM and WBEM standards. It is designed to be por

//%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 "ModuleController.h"
#include <Pegasus/Common/MessageLoader.h>
#include <Pegasus/Common/InternalException.h>

PEGASUS_NAMESPACE_BEGIN

PEGASUS_USING_STD;

RegisteredModuleHandle::RegisteredModuleHandle(
    const String& name,
    void* module_address,
    Message* (*receive_message)(Message *, void *),
    void (*async_callback)(Uint32, Message *, void *))
    : _name(name),
      _module_address(module_address),
      _module_receive_message(receive_message),
      _async_callback(async_callback)
{
    PEGASUS_ASSERT(_module_receive_message != 0);
}

RegisteredModuleHandle::~RegisteredModuleHandle()
{
}

const String & RegisteredModuleHandle::get_name() const
{
    return _name;
}

Message* RegisteredModuleHandle::_receive_message(Message* msg)
{
    return _module_receive_message(msg, _module_address);
}

void RegisteredModuleHandle::_send_async_callback(
    Uint32 msg_handle,
    Message* msg,
    void* parm)
{
    // ATTN: Assert this condition?
    if (_async_callback == 0)
    {
        throw NotImplemented("Module Async Receive");
    }

    _async_callback(msg_handle, msg, parm);
}


ModuleController::ModuleController(const char* name)
    : Base(name, MessageQueue::getNextQueueId(),
           module_capabilities::module_controller |
           module_capabilities::async),
      _modules()
{
}

ModuleController::~ModuleController()
{
    RegisteredModuleHandle* module;

    try
    {
        module = _modules.remove_front();
        while (module)
        {
            delete module;
            module = _modules.remove_front();
        }
    }
    catch (...)
    {
    }
}

// called by a module to register itself, returns a handle to the controller
ModuleController& ModuleController::register_module(
    const String& controller_name,
    const String& module_name,
    void* module_address,
    Message* (*receive_message)(Message *, void *),
    void (*async_callback)(Uint32, Message *, void *),
    RegisteredModuleHandle** instance)
{
    RegisteredModuleHandle *module;
    ModuleController *controller;

    Array<Uint32> services;

    MessageQueue *message_queue =
        MessageQueue::lookup(controller_name.getCString());

    if ((message_queue == NULL) || (!message_queue->isAsync()))
    {
        throw IncompatibleTypesException();
    }

    MessageQueueService *service =
        static_cast<MessageQueueService *>(message_queue);
    if ((service == NULL) ||
        !(service->get_capabilities() & module_capabilities::module_controller))
    {
        throw IncompatibleTypesException();
    }

    controller = static_cast<ModuleController *>(service);

    {

        // see if the module already exists in this controller.
        _module_lock lock(&(controller->_modules));

        module = controller->_modules.front();
        while (module != NULL)
        {
            if (module->get_name() == module_name)
            {
                MessageLoaderParms parms(
                    "Common.ModuleController.MODULE",
                    "module \"$0\"",
                    module_name);
                throw AlreadyExistsException(parms);
            }
            module = controller->_modules.next_of(module);
        }
    }

    // now reserve this module name with the meta dispatcher

    Uint32 result = 0;
    AutoPtr<RegisteredModule> request(new RegisteredModule(
        0,
        true,
        controller->getQueueId(),
        module_name));

    request->dest = CIMOM_Q_ID;

    AutoPtr<AsyncReply> response(controller->SendWait(request.get()));
    if (response.get() != NULL)
        result = response->result;

    request.reset();
    response.reset();
    if (result == async_results::MODULE_ALREADY_REGISTERED)
    {
        MessageLoaderParms parms(
            "Common.ModuleController.MODULE",
            "module \"$0\"", module_name);
        throw AlreadyExistsException(parms);
    }

    // the module does not exist, go ahead and create it.
    module = new RegisteredModuleHandle(
        module_name,
        module_address,
        receive_message,
        async_callback);

    controller->_modules.insert_back(module);

    if (instance != NULL)
        *instance = module;

    return *controller;
}


Boolean ModuleController::deregister_module(const String& module_name)
{
    AutoPtr<DeRegisteredModule> request(new DeRegisteredModule(
        0,
        true,
        getQueueId(),
        module_name));
    request->dest = _meta_dispatcher->getQueueId();

    AutoPtr<AsyncReply> response(SendWait(request.get()));

    request.reset();
    response.reset();

    RegisteredModuleHandle* module;

    _module_lock lock(&_modules);
    module = _modules.front();
    while (module != NULL)
    {
        if (module->get_name() == module_name)
        {
            _modules.remove(module);
            return true;
        }
        module = _modules.next_of(module);
    }
    return false;
}

Boolean ModuleController::verify_handle(RegisteredModuleHandle* handle)
{
    RegisteredModuleHandle *module;

    if (handle->_module_address == (void *)this)
        return true;

    _module_lock lock(&_modules);

    module = _modules.front();
    while (module != NULL)
    {
        if ( module == handle)
        {
            return true;
        }
        module = _modules.next_of(module);
    }
    return false;
}

// given a name, find a service's queue id
Uint32 ModuleController::find_service(
    const RegisteredModuleHandle& handle,
    const String& name)
{
    if (false == verify_handle(const_cast<RegisteredModuleHandle *>(&handle)))
        throw Permission(Threads::self());
    Array<Uint32> services;
    Base::find_services(name, 0, 0, &services);
    return services[0];
}


// returns the queue ID of the service hosting the named module,
// zero otherwise

Uint32 ModuleController::find_module_in_service(
    const RegisteredModuleHandle& handle,
    const String& name)
{
    if (false == verify_handle(const_cast<RegisteredModuleHandle *>(&handle)))
        throw(Permission(Threads::self()));

    Uint32 result = 0;

    AutoPtr<FindModuleInService> request(new FindModuleInService(
        0,
        true,
        _meta_dispatcher->getQueueId(),
        name));
    request->dest = _meta_dispatcher->getQueueId();
    AutoPtr<FindModuleInServiceResponse> response(
        static_cast<FindModuleInServiceResponse *>(SendWait(request.get())));
    if (response.get() != NULL)
        result = response->_module_service_queue;

    return result;
}


AsyncReply* ModuleController::_send_wait(
    Uint32 destination_q,
    AsyncRequest* request)
{
    request->dest = destination_q;
    AsyncReply* reply = Base::SendWait(request);
    return reply;
}


// sendwait to another service
AsyncReply* ModuleController::ModuleSendWait(
    const RegisteredModuleHandle& handle,
    Uint32 destination_q,
    AsyncRequest* request)
{
    if (false == verify_handle(const_cast<RegisteredModuleHandle *>(&handle)))
        throw(Permission(Threads::self()));

    return _send_wait(destination_q, request);
}

AsyncReply* ModuleController::_send_wait(
    Uint32 destination_q,
    const String& destination_module,
    AsyncRequest* message)
{
    AutoPtr<AsyncModuleOperationStart> request(new AsyncModuleOperationStart(
        0,
        destination_q,
        getQueueId(),
        true,
        destination_module,
        message));

    request->dest = destination_q;
    AutoPtr<AsyncModuleOperationResult> response(
        static_cast<AsyncModuleOperationResult *>(SendWait(request.get())));

    AsyncReply *ret = 0;

    if (response.get() != NULL &&
        response->getType() == async_messages::ASYNC_MODULE_OP_RESULT)
    {
        // clear the request out of the envelope so it can be deleted by the
        // module
        ret = static_cast<AsyncReply *>(response->get_result());
    }
    request->get_action();
    return ret;