operationresponsehandler.cpp

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

String GetInstanceResponseHandler::getClass() const
{
    return String("GetInstanceResponseHandler");
}

void GetInstanceResponseHandler::transfer()
{
    if (size() > 0)
    {
        CIMGetInstanceResponseMessage& msg =
            *static_cast<CIMGetInstanceResponseMessage*>(getResponse());

        msg.cimInstance = getObjects()[0];
    }
}

void GetInstanceResponseHandler::validate()
{
    if (getResponseObjectTotal() == 0)
    {
        // error? provider claims success,
        // but did not deliver an instance.
        setStatus(CIM_ERR_NOT_FOUND);
    }
}

//
// EnumerateInstancesResponseHandler
//

EnumerateInstancesResponseHandler::EnumerateInstancesResponseHandler(
    CIMEnumerateInstancesRequestMessage* request,
    CIMEnumerateInstancesResponseMessage* response,
    PEGASUS_RESPONSE_CHUNK_CALLBACK_T responseChunkCallback)
    : OperationResponseHandler(request, response, responseChunkCallback)
{
#ifdef PEGASUS_ENABLE_OBJECT_NORMALIZATION
    // Attempt to get the cached class definition used to validate results of
    // this operation. If it does not exist, then this feature is disabled
    // for this operation.
    CIMClass cimClass;

    if (request->operationContext.contains(
            CachedClassDefinitionContainer::NAME))
    {
        CachedClassDefinitionContainer container =
            request->operationContext.get(
                CachedClassDefinitionContainer::NAME);
        cimClass = container.getClass();
    }

    AutoPtr<NormalizerContext> tmpContext(new CIMOMHandleContext());
    ObjectNormalizer tmpNormalizer(
        cimClass,
        request->includeQualifiers,
        request->includeClassOrigin,
        request->nameSpace,
        tmpContext);
    _normalizer = tmpNormalizer;
#endif
}

void EnumerateInstancesResponseHandler::deliver(const CIMInstance& cimInstance)
{
    if (cimInstance.isUninitialized())
    {
        MessageLoaderParms message(
            "Common.Exception.UNINITIALIZED_OBJECT_EXCEPTION",
            "The object is not initialized.");

        throw CIMException(CIM_ERR_FAILED, message);
    }

#ifdef PEGASUS_ENABLE_OBJECT_NORMALIZATION
    SimpleInstanceResponseHandler::deliver(
        _normalizer.processInstance(cimInstance));
#else
    SimpleInstanceResponseHandler::deliver(cimInstance);
#endif
}

String EnumerateInstancesResponseHandler::getClass() const
{
    return String("EnumerateInstancesResponseHandler");
}

void EnumerateInstancesResponseHandler::transfer()
{
    CIMEnumerateInstancesResponseMessage& msg =
        *static_cast<CIMEnumerateInstancesResponseMessage*>(getResponse());

    msg.cimNamedInstances = getObjects();
}

//
// EnumerateInstanceNamesResponseHandler
//

EnumerateInstanceNamesResponseHandler::EnumerateInstanceNamesResponseHandler(
    CIMEnumerateInstanceNamesRequestMessage* request,
    CIMEnumerateInstanceNamesResponseMessage* response,
    PEGASUS_RESPONSE_CHUNK_CALLBACK_T responseChunkCallback)
    : OperationResponseHandler(request, response, responseChunkCallback)
{
#ifdef PEGASUS_ENABLE_OBJECT_NORMALIZATION
    // Attempt to get the cached class definition used to validate results of
    // this operation. If it does not exist, then this feature is disabled
    // for this operation.
    CIMClass cimClass;

    if (request->operationContext.contains(
            CachedClassDefinitionContainer::NAME))
    {
        CachedClassDefinitionContainer container =
            request->operationContext.get(
                CachedClassDefinitionContainer::NAME);

        cimClass = container.getClass();
    }

    AutoPtr<NormalizerContext> tmpContext(new CIMOMHandleContext());
    ObjectNormalizer tmpNormalizer(
        cimClass,
        false,
        false,
        request->nameSpace,
        tmpContext);
    _normalizer = tmpNormalizer;
#endif
}

void EnumerateInstanceNamesResponseHandler::deliver(
    const CIMObjectPath& cimObjectPath)
{
    if (cimObjectPath.getClassName().isNull())
    {
        MessageLoaderParms message(
            "Common.Exception.UNINITIALIZED_OBJECT_EXCEPTION",
            "The object is not initialized.");

        throw CIMException(CIM_ERR_FAILED, message);
    }

#ifdef PEGASUS_ENABLE_OBJECT_NORMALIZATION
    SimpleObjectPathResponseHandler::deliver(
        _normalizer.processInstanceObjectPath(cimObjectPath));
#else
    SimpleObjectPathResponseHandler::deliver(cimObjectPath);
#endif
}

String EnumerateInstanceNamesResponseHandler::getClass() const
{
    return String("EnumerateInstanceNamesResponseHandler");
}

void EnumerateInstanceNamesResponseHandler::transfer()
{
    CIMEnumerateInstanceNamesResponseMessage& msg =
        *static_cast<CIMEnumerateInstanceNamesResponseMessage*>(getResponse());

    msg.instanceNames = getObjects();
}

//
// CreateInstanceResponseHandler
//

CreateInstanceResponseHandler::CreateInstanceResponseHandler(
    CIMCreateInstanceRequestMessage* request,
    CIMCreateInstanceResponseMessage* response,
    PEGASUS_RESPONSE_CHUNK_CALLBACK_T responseChunkCallback)
    : OperationResponseHandler(request, response, responseChunkCallback)
{
}

void CreateInstanceResponseHandler::deliver(const CIMObjectPath& cimObjectPath)
{
    if (cimObjectPath.getClassName().isNull())
    {
        MessageLoaderParms message(
            "Common.Exception.UNINITIALIZED_OBJECT_EXCEPTION",
            "The object is not initialized.");

        throw CIMException(CIM_ERR_FAILED, message);
    }

    if (SimpleObjectPathResponseHandler::size() != 0)
    {
        MessageLoaderParms message(
            "Server.OperationResponseHandler.TOO_MANY_OBJECTS_DELIVERED",
            "Too many objects delivered.");

        throw CIMException(CIM_ERR_FAILED, message);
    }

    SimpleObjectPathResponseHandler::deliver(cimObjectPath);
}

void CreateInstanceResponseHandler::complete()
{
    if (SimpleObjectPathResponseHandler::size() == 0)
    {
        MessageLoaderParms message(
            "Server.OperationResponseHandler.TOO_FEW_OBJECTS_DELIVERED",
            "Too few objects delivered.");

        throw CIMException(CIM_ERR_FAILED, message);
    }

    SimpleObjectPathResponseHandler::complete();
}

String CreateInstanceResponseHandler::getClass() const
{
    return String("CreateInstanceResponseHandler");
}

#if 0
// ATTN: is it an error to not return instance name?
void CreateInstanceResponseHandler::validate()
{
    if (getResponseObjectTotal() == 0)
    {
        setStatus(CIM_ERR_NOT_FOUND);
    }
}
#endif

void CreateInstanceResponseHandler::transfer()
{
    if (size() > 0)
    {
        CIMCreateInstanceResponseMessage& msg =
            *static_cast<CIMCreateInstanceResponseMessage*>(getResponse());

        msg.instanceName = getObjects()[0];
    }
}

//
// ModifyInstanceResponseHandler
//

ModifyInstanceResponseHandler::ModifyInstanceResponseHandler(
    CIMModifyInstanceRequestMessage* request,
    CIMModifyInstanceResponseMessage* response,
    PEGASUS_RESPONSE_CHUNK_CALLBACK_T responseChunkCallback)
    : OperationResponseHandler(request, response, responseChunkCallback)
{
}

String ModifyInstanceResponseHandler::getClass() const
{
    return String("ModifyInstanceResponseHandler");
}

//
// DeleteInstanceResponseHandler
//

DeleteInstanceResponseHandler::DeleteInstanceResponseHandler(
    CIMDeleteInstanceRequestMessage* request,
    CIMDeleteInstanceResponseMessage* response,
    PEGASUS_RESPONSE_CHUNK_CALLBACK_T responseChunkCallback)
    : OperationResponseHandler(request, response, responseChunkCallback)
{
}

String DeleteInstanceResponseHandler::getClass() const
{
    return String("DeleteInstanceResponseHandler");
}

//
// GetPropertyResponseHandler
//

GetPropertyResponseHandler::GetPropertyResponseHandler(
    CIMGetPropertyRequestMessage* request,
    CIMGetPropertyResponseMessage* response,
    PEGASUS_RESPONSE_CHUNK_CALLBACK_T responseChunkCallback)
    : OperationResponseHandler(request, response, responseChunkCallback)
{
}

void GetPropertyResponseHandler::deliver(const CIMValue& cimValue)
{
    if (cimValue.isNull())
    {
        MessageLoaderParms message(
            "Common.Exception.UNINITIALIZED_OBJECT_EXCEPTION",
            "The object is not initialized.");

        throw CIMException(CIM_ERR_FAILED, message);
    }

    SimpleValueResponseHandler::deliver(cimValue);
}

String GetPropertyResponseHandler::getClass() const
{
    return String("GetPropertyResponseHandler");
}

void GetPropertyResponseHandler::transfer()
{
    if (size() > 0)
    {
        CIMGetPropertyResponseMessage& msg =
            *static_cast<CIMGetPropertyResponseMessage*>(getResponse());

        msg.value = getObjects()[0];
    }
}

void GetPropertyResponseHandler::validate()
{
    // error? provider claims success,
    // but did not deliver an instance.
    if (getResponseObjectTotal() == 0)
    {
        setStatus(CIM_ERR_NOT_FOUND);
    }
}

//
// SetPropertyResponseHandler
//

SetPropertyResponseHandler::SetPropertyResponseHandler(
    CIMSetPropertyRequestMessage* request,
    CIMSetPropertyResponseMessage* response,
    PEGASUS_RESPONSE_CHUNK_CALLBACK_T responseChunkCallback)
    : OperationResponseHandler(request, response, responseChunkCallback)
{
}

String SetPropertyResponseHandler::getClass() const
{
    return String("SetPropertyResponseHandler");
}

//
// ExecQueryResponseHandler
//

ExecQueryResponseHandler::ExecQueryResponseHandler(
    CIMExecQueryRequestMessage* request,
    CIMExecQueryResponseMessage* response,
    PEGASUS_RESPONSE_CHUNK_CALLBACK_T responseChunkCallback)
    : OperationResponseHandler(request, response, responseChunkCallback)
{
}

void ExecQueryResponseHandler::deliver(const CIMInstance& cimInstance)
{
    if (cimInstance.isUninitialized())
    {
        MessageLoaderParms message(
            "Common.Exception.UNINITIALIZED_OBJECT_EXCEPTION",
            "The object is not initialized.");

        throw CIMException(CIM_ERR_FAILED, message);
    }

    SimpleInstance2ObjectResponseHandler::deliver(cimInstance);
}