(file) Return to CimomMessage.cpp CVS log (file) (dir) Up to [Pegasus] / pegasus / src / Pegasus / Common

Diff for /pegasus/src/Pegasus/Common/CimomMessage.cpp between version 1.8 and 1.31

version 1.8, 2002/02/18 12:31:29 version 1.31, 2008/10/14 17:25:58
Line 1 
Line 1 
 //%///-*-c++-*-/////////////////////////////////////////////////////////////////  //%2006////////////////////////////////////////////////////////////////////////
 // //
 // Copyright (c) 2000, 2001 BMC Software, Hewlett-Packard Company, IBM,  // Copyright (c) 2000, 2001, 2002 BMC Software; Hewlett-Packard Development
 // The Open Group, Tivoli Systems  // 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 // Permission is hereby granted, free of charge, to any person obtaining a copy
 // of this software and associated documentation files (the "Software"), to // of this software and associated documentation files (the "Software"), to
Line 21 
Line 29 
 // //
 //============================================================================== //==============================================================================
 // //
 // Author: Mike Day (mdday@us.ibm.com)  
 //  
 // Modified By:  
 //  
 //%///////////////////////////////////////////////////////////////////////////// //%/////////////////////////////////////////////////////////////////////////////
  
 #include "CimomMessage.h" #include "CimomMessage.h"
  
 PEGASUS_NAMESPACE_BEGIN PEGASUS_NAMESPACE_BEGIN
  
   
   
 const Uint32 async_results::OK =                        0x00000000; const Uint32 async_results::OK =                        0x00000000;
 const Uint32 async_results::PARAMETER_ERROR =           0x00000001; const Uint32 async_results::PARAMETER_ERROR =           0x00000001;
 const Uint32 async_results::MODULE_ALREADY_REGISTERED = 0x00000002; const Uint32 async_results::MODULE_ALREADY_REGISTERED = 0x00000002;
 const Uint32 async_results::MODULE_NOT_FOUND =          0x00000003; const Uint32 async_results::MODULE_NOT_FOUND =          0x00000003;
 const Uint32 async_results::INTERNAL_ERROR =            0x00000004; const Uint32 async_results::INTERNAL_ERROR =            0x00000004;
  
   
 const Uint32 async_results::ASYNC_STARTED =             0x00000005; const Uint32 async_results::ASYNC_STARTED =             0x00000005;
 const Uint32 async_results::ASYNC_PROCESSING =          0x00000006; const Uint32 async_results::ASYNC_PROCESSING =          0x00000006;
 const Uint32 async_results::ASYNC_COMPLETE =            0x00000007; const Uint32 async_results::ASYNC_COMPLETE =            0x00000007;
Line 62 
Line 63 
 const Uint32 async_results::CIM_STOPPED =               0x00000015; const Uint32 async_results::CIM_STOPPED =               0x00000015;
  
  
   AsyncMessage::AsyncMessage(
 const Uint32 async_messages::HEARTBEAT =                0x00000000;      MessageType type,
 const Uint32 async_messages::REPLY =                    0x00000000;  
 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 destination,
                            Uint32 key,  
                            Uint32 routing,  
                            Uint32 mask,                            Uint32 mask,
                            AsyncOpNode *operation)                            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,                            Uint32 mask,
                            AsyncOpNode *operation,                            AsyncOpNode *operation,
                            Uint32 destination,                            Uint32 destination,
                            Uint32 response,                            Uint32 response,
                            Boolean blocking)                            Boolean blocking)
    : AsyncMessage(type, destination, key, routing, mask | message_mask::ha_request, operation),      : AsyncMessage(
             type, destination, mask | MessageMask::ha_request, operation),
      resp(response),      resp(response),
      block(blocking)      block(blocking)
 { {
    if( op != 0 )    if( op != 0 )
       op->put_request(this);          op->setRequest(this);
 } }
  
 AsyncReply::AsyncReply(Uint32 type,  AsyncReply::AsyncReply(
                        Uint32 key,      MessageType type,
                        Uint32 routing,  
                        Uint32 mask,                        Uint32 mask,
                        AsyncOpNode *operation,                        AsyncOpNode *operation,
                        Uint32 result_code,      Uint32 resultCode,
                        Uint32 destination,                        Uint32 destination,
                        Boolean blocking)                        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)      block(blocking)
 { {
    if( op != 0 )    if( op != 0 )
       op->put_response(this);          op->setResponse(this);
 } }
  
   AsyncIoctl::AsyncIoctl(
   
   
 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)  
 {  
   
 }  
   
   
 AsyncIoctl::AsyncIoctl(Uint32 routing,  
                        AsyncOpNode *operation,                        AsyncOpNode *operation,
                        Uint32 destination,                        Uint32 destination,
                        Uint32 response,                        Uint32 response,
                        Boolean blocking,                        Boolean blocking,
                        Uint32 code,                        Uint32 code,
                        Uint32 int_param,      Uint32 intParam,
                        void *p_param)      void* pParam)
    : AsyncRequest( async_messages::IOCTL,      : AsyncRequest(
                    Message::getNextKey(),            ASYNC_IOCTL,
                    routing, 0, operation,            0, operation,
                    destination, response, blocking),                    destination, response, blocking),
      ctl(code),      ctl(code),
      intp(int_param),        intp(intParam),
      voidp(p_param)        voidp(pParam)
 { {
   
 } }
  
   CimServiceStart::CimServiceStart(
 CimServiceStart::CimServiceStart(Uint32 routing,  
                                  AsyncOpNode *operation,                                  AsyncOpNode *operation,
                                  Uint32 destination,                                  Uint32 destination,
                                  Uint32 response,                                  Uint32 response,
                                  Boolean blocking)                                  Boolean blocking)
    : AsyncRequest(async_messages::CIMSERVICE_START,      : AsyncRequest(
                   Message::getNextKey(), routing,            ASYNC_CIMSERVICE_START,
                   0, operation, destination,                   0, operation, destination,
                   response, blocking)                   response, blocking)
 { {
   
 } }
  
  
 CimServiceStop::CimServiceStop(Uint32 routing,  CimServiceStop::CimServiceStop(
                                AsyncOpNode *operation,                                AsyncOpNode *operation,
                                Uint32 destination,                                Uint32 destination,
                                Uint32 response,                                Uint32 response,
                                Boolean blocking)                                Boolean blocking)
    : AsyncRequest(async_messages::CIMSERVICE_STOP,      : AsyncRequest(
                   Message::getNextKey(), routing,            ASYNC_CIMSERVICE_STOP,
                   0, operation, destination,                   0, operation, destination,
                   response, blocking)                   response, blocking)
 { {
   
 } }
  
   AsyncOperationStart::AsyncOperationStart(
   
 CimServicePause::CimServicePause(Uint32 routing,  
                                  AsyncOpNode *operation,                                  AsyncOpNode *operation,
                                  Uint32 destination,                                  Uint32 destination,
                                  Uint32 response,                                  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)            0,
             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,                                    AsyncOpNode *operation,
       Uint32 resultCode,
                                    Uint32 destination,                                    Uint32 destination,
                                    Uint32 response,  
                                    Boolean blocking)                                    Boolean blocking)
    : AsyncRequest(async_messages::CIMSERVICE_RESUME,      : AsyncReply(
                   Message::getNextKey(), routing,            ASYNC_ASYNC_OP_RESULT,
                   0, operation, destination,            0,
                   response, blocking)            operation,
             resultCode,
             destination,
             blocking)
 { {
   
 } }
  
 AsyncOperationStart::AsyncOperationStart(Uint32 routing,  
   AsyncModuleOperationStart::AsyncModuleOperationStart(
                                          AsyncOpNode *operation,                                          AsyncOpNode *operation,
                                          Uint32 destination,                                          Uint32 destination,
                                          Uint32 response,                                          Uint32 response,
                                          Boolean blocking,                                          Boolean blocking,
       const String& targetModule,
                                          Message *action)                                          Message *action)
    : AsyncRequest(async_messages::ASYNC_OP_START,      : AsyncRequest(
                   Message::getNextKey(), routing, 0,            ASYNC_ASYNC_MODULE_OP_START,
             0,
                   operation,                   operation,
                   destination, response, blocking),            destination,
      act(action)            response,
             blocking),
         _target_module(targetModule),
         _act(action)
 { {
       _act->put_async(this);
 } }
  
  
 AsyncOperationResult::AsyncOperationResult(Uint32 key,  Message* AsyncModuleOperationStart::get_action()
                                            Uint32 routing,  
                                            AsyncOpNode *operation,  
                                            Uint32 result_code,  
                                            Uint32 destination,  
                                            Uint32 blocking)  
    : AsyncReply(async_messages::ASYNC_OP_RESULT,  
                 key, routing, 0,  
                 operation, result_code, destination,  
                 blocking)  
 { {
       Message* ret = _act;
       _act = 0;
       ret->put_async(0);
       return ret;
 } }
  
   AsyncModuleOperationResult::AsyncModuleOperationResult(
   
 AsyncLegacyOperationStart::AsyncLegacyOperationStart(Uint32 routing,  
                                                      AsyncOpNode *operation,                                                      AsyncOpNode *operation,
       Uint32 resultCode,
                                                      Uint32 destination,                                                      Uint32 destination,
                                                      Message *action,      Boolean blocking,
                                                      Uint32 action_destination)      const String& targetModule,
    : AsyncRequest(async_messages::ASYNC_LEGACY_OP_START,      Message* result)
                   Message::getNextKey(), routing, 0,      : AsyncReply(
                   operation, destination, CIMOM_Q_ID, false),            ASYNC_ASYNC_MODULE_OP_RESULT,
      act(action) , legacy_destination(action_destination)            0,
             operation, resultCode, destination,
             blocking),
         _targetModule(targetModule),
         _res(result)
 { {
    act->_async = this;      _res->put_async(this);
 } }
  
   Message* AsyncModuleOperationResult::get_result()
 AsyncLegacyOperationResult::AsyncLegacyOperationResult(Uint32 key,  
                                                        Uint32 routing,  
                                                        AsyncOpNode *operation,  
                                                        Message *result)  
    : AsyncReply(async_messages::ASYNC_LEGACY_OP_RESULT,  
                 key, routing, 0, operation,  
                 0, CIMOM_Q_ID, false),  
      res(result)  
 { {
    res->_async = this;      Message* ret = _res;
       _res = 0;
       ret->put_async(0);
       return ret;
 } }
  
  
   AsyncLegacyOperationStart::AsyncLegacyOperationStart(
 FindServiceQueue::FindServiceQueue(Uint32 routing,  
                                    AsyncOpNode *operation,                                    AsyncOpNode *operation,
                                    Uint32 response,      Uint32 destination,
                                    Boolean blocking,      Message* action)
                                    String service_name,      : AsyncRequest(
                                    Uint32 service_capabilities,            ASYNC_ASYNC_LEGACY_OP_START,
                                    Uint32 service_mask)            0,
    : AsyncRequest(async_messages::FIND_SERVICE_Q,            operation, destination, CIMOM_Q_ID, false),
                   Message::getNextKey(),        _act(action)
                   routing, 0, operation,  
                   CIMOM_Q_ID,  
                   response,  
                   blocking),  
      name(service_name),  
      capabilities(service_capabilities),  
      mask(service_mask)  
 { {
       _act->put_async(this);
 } }
  
  
   Message* AsyncLegacyOperationStart::get_action()
 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)  
 { {
       Message* ret = _act;
       _act = 0;
   //    ret->put_async(0);
       return ret;
  
 } }
  
 EnumerateService::EnumerateService(Uint32 routing,  AsyncLegacyOperationResult::AsyncLegacyOperationResult(
                                    AsyncOpNode *operation,                                    AsyncOpNode *operation,
                                    Uint32 response,      Message* result)
                                    Boolean blocking,      : AsyncReply(
                                    Uint32 queue_id)            ASYNC_ASYNC_LEGACY_OP_RESULT,
    : AsyncRequest(async_messages::ENUMERATE_SERVICE,            0, operation,
                   Message::getNextKey(),            0, CIMOM_Q_ID, false),
                   routing, 0,        _res(result)
                   operation,  
                   CIMOM_Q_ID,  
                   response,  
                   blocking),  
      qid(queue_id)  
 { {
       _res->put_async(this);
 } }
  
 EnumerateServiceResponse::EnumerateServiceResponse(Uint32 key,  Message* AsyncLegacyOperationResult::get_result()
                                                    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)  
 { {
       Message* ret = _res;
       _res = 0;
   //    ret->put_async(0);
       return ret;
   }
  
   AsyncMessage::~AsyncMessage()
   {
 } }
  
   AsyncRequest::~AsyncRequest()
   {
   }
  
 PEGASUS_NAMESPACE_END PEGASUS_NAMESPACE_END

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