pegasus/src/Pegasus/Common/CimomMessage.cpp - diff

Return to CimomMessage.cpp CVS log

Up to [Pegasus] / pegasus / src / Pegasus / Common

Diff for /pegasus/src/Pegasus/Common/CimomMessage.cpp between version 1.10 and 1.34

version 1.10, 2002/03/11 02:36:18

version 1.34, 2008/12/01 17:49:51

Line 1

//%///-*-c++-*-/////////////////////////////////////////////////////////////////

//%LICENSE////////////////////////////////////////////////////////////////

// Licensed to The Open Group (TOG) under one or more contributor license

// The Open Group, Tivoli Systems

// agreements. Refer to the OpenPegasusNOTICE.txt file distributed with

// this work for additional information regarding copyright ownership.

// Each contributor licenses this file to you under the OpenPegasus Open

// Source License; you may not use this file except in compliance with the

// License.

// Permission is hereby granted, free of charge, to any person obtaining a copy

// Permission is hereby granted, free of charge, to any person obtaining a

// of this software and associated documentation files (the "Software"), to

// copy of this software and associated documentation files (the "Software"),

// deal in the Software without restriction, including without limitation the

// to deal in the Software without restriction, including without limitation

// rights to use, copy, modify, merge, publish, distribute, sublicense, and/or

// the rights to use, copy, modify, merge, publish, distribute, sublicense,

// sell copies of the Software, and to permit persons to whom the Software is

// and/or sell copies of the Software, and to permit persons to whom the

// furnished to do so, subject to the following conditions:

// Software is furnished to do so, subject to the following conditions:

// THE ABOVE COPYRIGHT NOTICE AND THIS PERMISSION NOTICE SHALL BE INCLUDED IN

// The above copyright notice and this permission notice shall be included

// ALL COPIES OR SUBSTANTIAL PORTIONS OF THE SOFTWARE. THE SOFTWARE IS PROVIDED

// in all copies or substantial portions of the Software.

// "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.

//==============================================================================

// 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.

// Author: Mike Day (mdday@us.ibm.com)

//////////////////////////////////////////////////////////////////////////

// Modified By:

//%/////////////////////////////////////////////////////////////////////////////

Line 31

Line 33

PEGASUS_NAMESPACE_BEGIN

const Uint32 async_results::OK = 0x00000000;

const Uint32 async_results::PARAMETER_ERROR = 0x00000001;

const Uint32 async_results::CIM_NAK = 0x00000001;

const Uint32 async_results::MODULE_ALREADY_REGISTERED = 0x00000002;

const Uint32 async_results::CIM_SERVICE_STOPPED = 0x00000002;

const Uint32 async_results::MODULE_NOT_FOUND = 0x00000003;

const Uint32 async_results::INTERNAL_ERROR = 0x00000004;

const Uint32 async_results::ASYNC_STARTED = 0x00000005;

const Uint32 async_results::ASYNC_PROCESSING = 0x00000006;

const Uint32 async_results::ASYNC_COMPLETE = 0x00000007;

const Uint32 async_results::ASYNC_CANCELLED = 0x00000008;

const Uint32 async_results::ASYNC_PAUSED = 0x00000009;

const Uint32 async_results::ASYNC_RESUMED = 0x0000000a;

const Uint32 async_results::CIM_SERVICE_STARTED = 0x0000000b;

const Uint32 async_results::CIM_SERVICE_STOPPED = 0x0000000c;

const Uint32 async_results::CIM_SERVICE_PAUSED = 0x0000000d;

const Uint32 async_results::CIM_SERVICE_RESUMED = 0x0000000e;

const Uint32 async_results::CIM_NAK = 0x0000000f;

const Uint32 async_results::ASYNC_PHASE_COMPLETE = 0x00000010;

const Uint32 async_results::ASYNC_CHILD_COMPLETE = 0x00000011;

const Uint32 async_results::ASYNC_PHASE_STARTED = 0x00000012;

const Uint32 async_results::ASYNC_CHILD_STARTED = 0x00000013;

const Uint32 async_results::CIM_PAUSED = 0x00000014;

const Uint32 async_results::CIM_STOPPED = 0x00000015;

const Uint32 async_messages::HEARTBEAT = 0x00000000;

AsyncMessage::AsyncMessage(

const Uint32 async_messages::REPLY = 0x00000000;

MessageType type,

const Uint32 async_messages::REGISTER_CIM_SERVICE = 0x00000001;

const Uint32 async_messages::DEREGISTER_CIM_SERVICE = 0x00000002;

const Uint32 async_messages::UPDATE_CIM_SERVICE = 0x00000003;

const Uint32 async_messages::IOCTL = 0x00000004;

const Uint32 async_messages::CIMSERVICE_START = 0x00000005;

const Uint32 async_messages::CIMSERVICE_STOP = 0x00000006;

const Uint32 async_messages::CIMSERVICE_PAUSE = 0x00000007;

const Uint32 async_messages::CIMSERVICE_RESUME = 0x00000008;

const Uint32 async_messages::ASYNC_OP_START = 0x00000009;

const Uint32 async_messages::ASYNC_OP_RESULT = 0x0000000a;

const Uint32 async_messages::ASYNC_LEGACY_OP_START = 0x0000000b;

const Uint32 async_messages::ASYNC_LEGACY_OP_RESULT = 0x0000000c;

const Uint32 async_messages::FIND_SERVICE_Q = 0x0000000d;

const Uint32 async_messages::FIND_SERVICE_Q_RESULT = 0x0000000e;

const Uint32 async_messages::ENUMERATE_SERVICE = 0x0000000f;

const Uint32 async_messages::ENUMERATE_SERVICE_RESULT = 0x00000010;

AsyncMessage::AsyncMessage(Uint32 type,

Uint32 destination,

Uint32 key,

Uint32 routing,

Uint32 mask,

AsyncOpNode *operation)

: Message(type, destination, key, routing, mask | message_mask::ha_async),

: Message(type, destination, mask | MessageMask::ha_async),

op(operation),

op(operation)

_myself(0),

_service(0)

{

}

AsyncRequest::AsyncRequest(Uint32 type,

AsyncRequest::AsyncRequest(

Uint32 key,

MessageType type,

Uint32 routing,

Uint32 mask,

AsyncOpNode *operation,

Uint32 destination,

Uint32 response,

Boolean blocking)

: AsyncMessage(type, destination, key, routing, mask | message_mask::ha_request, operation),

: AsyncMessage(

type, destination, mask | MessageMask::ha_request, operation),

resp(response),

block(blocking)

{

if( op != 0 )

op->put_request(this);

op->setRequest(this);

}

AsyncReply::AsyncReply(Uint32 type,

AsyncReply::AsyncReply(

Uint32 key,

MessageType type,

Uint32 routing,

Uint32 mask,

AsyncOpNode *operation,

Uint32 result_code,

Uint32 resultCode,

Uint32 destination,

Boolean blocking)

: AsyncMessage(type, destination, key, routing, mask | message_mask::ha_reply, operation),

: AsyncMessage(

result(result_code),

type, destination, mask | MessageMask::ha_reply, operation),

result(resultCode),

block(blocking)

{

if( op != 0 )

op->put_response(this);

op->setResponse(this);

}

RegisterCimService::RegisterCimService(Uint32 routing,

AsyncOpNode *operation,

Boolean blocking,

String service_name,

Uint32 service_capabilities,

Uint32 service_mask,

Uint32 service_queue)

: AsyncRequest( async_messages::REGISTER_CIM_SERVICE,

Message::getNextKey(),

routing, 0, operation, CIMOM_Q_ID,

service_queue, blocking),

name(service_name),

capabilities(service_capabilities),

mask(service_mask),

queue(service_queue)

{

}

DeRegisterCimService::DeRegisterCimService(Uint32 routing,

AsyncOpNode *operation,

Boolean blocking,

Uint32 service_queue)

: AsyncRequest( async_messages::DEREGISTER_CIM_SERVICE,

Message::getNextKey(),

routing, 0, operation, CIMOM_Q_ID,

service_queue, blocking),

queue(service_queue)

{

}

UpdateCimService::UpdateCimService(Uint32 routing,

AsyncOpNode *operation,

Boolean blocking,

Uint32 service_queue,

Uint32 service_capabilities,

Uint32 service_mask)

: AsyncRequest( async_messages::UPDATE_CIM_SERVICE,

Message::getNextKey(),

routing, 0, operation, CIMOM_Q_ID,

service_queue, blocking),

queue(service_queue),

capabilities(service_capabilities),

mask(service_mask)

{

}

AsyncIoClose::AsyncIoClose(

AsyncIoctl::AsyncIoctl(Uint32 routing,

AsyncOpNode *operation,

Uint32 destination,

Uint32 response,

Boolean blocking,

Boolean blocking)

Uint32 code,

: AsyncRequest(

Uint32 int_param,

ASYNC_IOCLOSE,

void *p_param)

: AsyncRequest( async_messages::IOCTL,

operation,

Message::getNextKey(),

destination,

routing, 0, operation,

response,

destination, response, blocking),

blocking)

ctl(code),

intp(int_param),

voidp(p_param)

{

}

CimServiceStart::CimServiceStart(

CimServiceStart::CimServiceStart(Uint32 routing,

AsyncOpNode *operation,

Uint32 destination,

Uint32 response,

Boolean blocking)

: AsyncRequest(async_messages::CIMSERVICE_START,

: AsyncRequest(

Message::getNextKey(), routing,

ASYNC_CIMSERVICE_START,

0, operation, destination,

response, blocking)

{

}

CimServiceStop::CimServiceStop(Uint32 routing,

CimServiceStop::CimServiceStop(

AsyncOpNode *operation,

Uint32 destination,

Uint32 response,

Boolean blocking)

: AsyncRequest(async_messages::CIMSERVICE_STOP,

: AsyncRequest(

Message::getNextKey(), routing,

ASYNC_CIMSERVICE_STOP,

0, operation, destination,

response, blocking)

{

}

AsyncOperationStart::AsyncOperationStart(

CimServicePause::CimServicePause(Uint32 routing,

AsyncOpNode *operation,

Uint32 destination,

Uint32 response,

Boolean blocking)

Boolean blocking,

: AsyncRequest(async_messages::CIMSERVICE_PAUSE,

Message* action)

Message::getNextKey(), routing,

: AsyncRequest(

0, operation, destination,

ASYNC_ASYNC_OP_START,

response, blocking)

operation,

destination, response, blocking),

_act(action)

{

}

Message* AsyncOperationStart::get_action()

{

Message* ret = _act;

_act = 0;

ret->put_async(0);

return ret;

}

CimServiceResume::CimServiceResume(Uint32 routing,

AsyncOperationResult::AsyncOperationResult(

AsyncOpNode *operation,

Uint32 resultCode,

Uint32 destination,

Uint32 response,

Boolean blocking)

: AsyncRequest(async_messages::CIMSERVICE_RESUME,

: AsyncReply(

Message::getNextKey(), routing,

ASYNC_ASYNC_OP_RESULT,

0, operation, destination,

response, blocking)

operation,

resultCode,

destination,

blocking)

{

}

AsyncOperationStart::AsyncOperationStart(Uint32 routing,

AsyncModuleOperationStart::AsyncModuleOperationStart(

AsyncOpNode *operation,

Uint32 destination,

Uint32 response,

Boolean blocking,

const String& targetModule,

Message *action)

: AsyncRequest(async_messages::ASYNC_OP_START,

: AsyncRequest(

Message::getNextKey(), routing, 0,

ASYNC_ASYNC_MODULE_OP_START,

operation,

destination, response, blocking),

destination,

response,

blocking),

_target_module(targetModule),

_act(action)

{

_act->put_async(this);

}

Message * AsyncOperationStart::get_action(void)

Message* AsyncModuleOperationStart::get_action()

{

Message *ret = _act;

_act = 0;

ret->put_async(0);

return ret;

}

AsyncModuleOperationResult::AsyncModuleOperationResult(

AsyncOperationResult::AsyncOperationResult(Uint32 key,

Uint32 routing,

AsyncOpNode *operation,

Uint32 result_code,

Uint32 resultCode,

Uint32 destination,

Uint32 blocking)

Boolean blocking,

: AsyncReply(async_messages::ASYNC_OP_RESULT,

const String& targetModule,

key, routing, 0,

Message* result)

operation, result_code, destination,

: AsyncReply(

blocking)

ASYNC_ASYNC_MODULE_OP_RESULT,

operation, resultCode, destination,

blocking),

_targetModule(targetModule),

_res(result)

{

_res->put_async(this);

}

Message* AsyncModuleOperationResult::get_result()

{

Message* ret = _res;

_res = 0;

ret->put_async(0);

return ret;

}

AsyncLegacyOperationStart::AsyncLegacyOperationStart(Uint32 routing,

AsyncLegacyOperationStart::AsyncLegacyOperationStart(

AsyncOpNode *operation,

Uint32 destination,

Message *action,

Message* action)

Uint32 action_destination)

: AsyncRequest(

: AsyncRequest(async_messages::ASYNC_LEGACY_OP_START,

ASYNC_ASYNC_LEGACY_OP_START,

Message::getNextKey(), routing, 0,

operation, destination, CIMOM_Q_ID, false),

_act(action) , _legacy_destination(action_destination)

_act(action)

{

_act->put_async(this);

}

Message * AsyncLegacyOperationStart::get_action(void)

Message* AsyncLegacyOperationStart::get_action()

{

Message *ret = _act;

_act = 0;

Line 328

Line 238

}

AsyncLegacyOperationResult::AsyncLegacyOperationResult(Uint32 key,

AsyncLegacyOperationResult::AsyncLegacyOperationResult(

Uint32 routing,

AsyncOpNode *operation,

Message *result)

: AsyncReply(async_messages::ASYNC_LEGACY_OP_RESULT,

: AsyncReply(

key, routing, 0, operation,

ASYNC_ASYNC_LEGACY_OP_RESULT,

0, operation,

0, CIMOM_Q_ID, false),

_res(result)

{

_res->put_async(this);

}

Message *AsyncLegacyOperationResult::get_result(void)

Message* AsyncLegacyOperationResult::get_result()

{

Message *ret = _res;

_res = 0;

Line 348

Line 258

return ret;

}

FindServiceQueue::FindServiceQueue(Uint32 routing,

AsyncMessage::~AsyncMessage()

AsyncOpNode *operation,

Uint32 response,

Boolean blocking,

String service_name,

Uint32 service_capabilities,

Uint32 service_mask)

: AsyncRequest(async_messages::FIND_SERVICE_Q,

Message::getNextKey(),

routing, 0, operation,

CIMOM_Q_ID,

response,

blocking),

name(service_name),

capabilities(service_capabilities),

mask(service_mask)

{

}

FindServiceQueueResult::FindServiceQueueResult(Uint32 key,

Uint32 routing,

AsyncOpNode *operation,

Uint32 result_code,

Uint32 destination,

Boolean blocking,

Array<Uint32> queue_ids)

: AsyncReply(async_messages::FIND_SERVICE_Q_RESULT,

key, routing, 0, operation,

result_code, destination, blocking),

qids(queue_ids)

{

}

EnumerateService::EnumerateService(Uint32 routing,

AsyncOpNode *operation,

Uint32 response,

Boolean blocking,

Uint32 queue_id)

: AsyncRequest(async_messages::ENUMERATE_SERVICE,

Message::getNextKey(),

routing, 0,

operation,

CIMOM_Q_ID,

response,

blocking),

qid(queue_id)

{

}

EnumerateServiceResponse::EnumerateServiceResponse(Uint32 key,

AsyncRequest::~AsyncRequest()

Uint32 routing,

AsyncOpNode *operation,

Uint32 result_code,

Uint32 response,

Boolean blocking,

String service_name,

Uint32 service_capabilities,

Uint32 service_mask,

Uint32 service_qid)

: AsyncReply(async_messages::ENUMERATE_SERVICE_RESULT,

key,

routing, 0,

operation,

result_code,

response,

blocking),

name(service_name),

capabilities(service_capabilities),

mask(service_mask),

qid(service_qid)

{

}

PEGASUS_NAMESPACE_END

Legend:

Removed from v.1.10
changed lines
	Added in v.1.34

No CVS admin address has been configured