void Adapter::enableIndications( CMPIIndicationMI* mi, const CMPIContext* context) { TRACE; _context_tls.set((void*)context); Adapter* adapter = (Adapter*)mi->hdl; Auto_RMutex auto_lock(adapter->_lock); // Ignore request if indications already enabled. if (adapter->_indications_enabled) return; adapter->_indications_enabled = true; // Invoke the provider: Enable_Indications_Status status = adapter->enable_indications( _indication_proc, adapter); switch (status) { case ENABLE_INDICATIONS_OK: break; case ENABLE_INDICATIONS_FAILED: break; } }
void Adapter::disableIndications( CMPIIndicationMI* mi, const CMPIContext* context) { TRACE; _context_tls.set((void*)context); Adapter* adapter = (Adapter*)mi->hdl; Auto_RMutex auto_lock(adapter->_lock); // Ignore if indications are not enabled. if (!adapter->_indications_enabled) return; // Invoke the provider: Disable_Indications_Status status = adapter->disable_indications(); switch (status) { case DISABLE_INDICATIONS_OK: break; case DISABLE_INDICATIONS_FAILED: break; } adapter->_indications_enabled = false; }
CMPIStatus Adapter::associators( CMPIAssociationMI* mi, const CMPIContext* context, const CMPIResult* result, const CMPIObjectPath* cmpi_op, const char* assoc_class_, const char* result_class_, const char* role_, const char* result_role_, const char** properties) { TRACE; const char* assoc_class = assoc_class_ ? assoc_class_ : ""; const char* result_class = result_class_ ? result_class_ : ""; const char* role = role_ ? role_ : ""; const char* result_role = result_role_ ? result_role_ : ""; _context_tls.set((void*)context); Adapter* adapter = (Adapter*)mi->hdl; Auto_RMutex auto_lock(adapter->_lock); CIMPLE_ASSERT(strcasecmp(assoc_class, adapter->_mc->name) == 0); // Lookup meta class for cmpi_op (not the same as the provider class). const Meta_Class* mc = adapter->_find_meta_class(class_name(cmpi_op)); if (!mc) CMReturn(CMPI_RC_ERR_INVALID_CLASS); // Convert to CIMPLE reference: Instance* cimple_ref = 0; CMPIrc rc = make_cimple_reference(mc, cmpi_op, cimple_ref); Destroyer<Instance> cimple_ref_d(cimple_ref); if (rc != CMPI_RC_OK) CMReturn(rc); // Invoke the provider: associators::Data data = { adapter->broker, context, result, name_space(cmpi_op), properties, CMPI_RC_OK }; Enum_Associator_Names_Status status = adapter->enum_associator_names( cimple_ref, result_class, role, result_role, associators::_proc, &data); CMReturn(CMPI_RC_OK); }
CMPIStatus Adapter::enumInstanceNames( CMPIInstanceMI* mi, const CMPIContext* context, const CMPIResult* result, const CMPIObjectPath* cmpi_op) { TRACE; _context_tls.set((void*)context); Adapter* adapter = (Adapter*)mi->hdl; Auto_RMutex auto_lock(adapter->_lock); // Convert to CIMPLE reference: const Meta_Class* mc = adapter->_mc; Instance* cimple_ref = 0; CMPIrc rc = make_cimple_reference(mc, cmpi_op, cimple_ref); if (rc != CMPI_RC_OK) CMReturn(rc); Destroyer<Instance> cimple_ref_d(cimple_ref); // Nullify non-key properties (this is a reference). nullify_non_keys(cimple_ref); // Invoke provider: const char* ns = name_space(cmpi_op); enum_instance_names::Data data = { adapter->broker, result, ns, CMPI_RC_OK }; Enum_Instances_Status status = adapter->enum_instances(cimple_ref, enum_instance_names::_proc, &data); switch (status) { case ENUM_INSTANCES_OK: CMReturnDone(result); CMReturn(CMPI_RC_OK); case ENUM_INSTANCES_FAILED: CMReturn(CMPI_RC_ERR_FAILED); } // Unreachable! CMReturn(CMPI_RC_OK); }
CMPIStatus Adapter::enumInstances( CMPIInstanceMI* mi, const CMPIContext* context, const CMPIResult* result, const CMPIObjectPath* cmpi_op, const char** properties) { TRACE; _context_tls.set((void*)context); Adapter* adapter = (Adapter*)mi->hdl; Auto_RMutex auto_lock(adapter->_lock); // Convert to CIMPLE reference: const Meta_Class* mc = adapter->_mc; Instance* cimple_ref = 0; CMPIrc rc = make_cimple_reference(mc, cmpi_op, cimple_ref); Destroyer<Instance> cimple_ref_d(cimple_ref); if (rc != CMPI_RC_OK) CMReturn(rc); // Filter properties: if (properties) filter_properties(cimple_ref, properties); // Invoke provider: enum_instances::Data data = { adapter->broker, result, cmpi_op, properties, CMPI_RC_OK }; Enum_Instances_Status status = adapter->enum_instances(cimple_ref, enum_instances::_proc, &data); switch (status) { case ENUM_INSTANCES_OK: break; case ENUM_INSTANCES_FAILED: CMReturn(CMPI_RC_ERR_FAILED); } CMReturnDone(result); CMReturn(CMPI_RC_OK); }
CMPIStatus Adapter::modifyInstance( CMPIInstanceMI* mi, const CMPIContext* context, const CMPIResult* result, const CMPIObjectPath* cmpi_op, const CMPIInstance* cmpi_inst, const char** properties) { TRACE; _context_tls.set((void*)context); Adapter* adapter = (Adapter*)mi->hdl; Auto_RMutex auto_lock(adapter->_lock); // Create CIMPLE instance: const Meta_Class* mc = adapter->_mc; Instance* cimple_inst = 0; CMPIrc rc = make_cimple_instance(mc, cmpi_inst, cimple_inst); if (rc != CMPI_RC_OK) CMReturn(rc); Destroyer<Instance> cmpi_inst_d(cimple_inst); // Invoke the provider: Modify_Instance_Status status = adapter->modify_instance(cimple_inst); switch (status) { case MODIFY_INSTANCE_OK: CMReturnObjectPath(result, cmpi_op); CMReturnDone(result); CMReturn(CMPI_RC_OK); case MODIFY_INSTANCE_NOT_FOUND: CMReturn(CMPI_RC_ERR_NOT_FOUND); case MODIFY_INSTANCE_UNSUPPORTED: CMReturn(CMPI_RC_ERR_NOT_SUPPORTED); } CMReturn(CMPI_RC_OK); }
void* Adapter::_timer_thread_proc(void* arg) { TRACE; Adapter* adapter = (Adapter*)arg; CBAttachThread(adapter->broker, adapter->_timer_context); _context_tls.set((void*)adapter->_timer_context); // ATTN: there is currently no logic to stop this thread. while (!adapter->_stop_timer_thread) adapter->_sched->dispatch(); CBDetachThread(adapter->broker, adapter->_timer_context); return 0; }
CMPIStatus Adapter::deleteInstance( CMPIInstanceMI* mi, const CMPIContext* context, const CMPIResult* result, const CMPIObjectPath* cmpi_op) { TRACE; _context_tls.set((void*)context); Adapter* adapter = (Adapter*)mi->hdl; Auto_RMutex auto_lock(adapter->_lock); // Convert to CIMPLE reference: const Meta_Class* mc = adapter->_mc; Instance* cimple_ref = 0; CMPIrc rc = make_cimple_reference(mc, cmpi_op, cimple_ref); Destroyer<Instance> cimple_ref_d(cimple_ref); if (rc != CMPI_RC_OK) CMReturn(rc); // Invoke provider: Delete_Instance_Status status = adapter->delete_instance(cimple_ref); switch (status) { case DELETE_INSTANCE_OK: break; case DELETE_INSTANCE_NOT_FOUND: CMReturn(CMPI_RC_ERR_NOT_FOUND); case DELETE_INSTANCE_UNSUPPORTED: CMReturn(CMPI_RC_ERR_NOT_SUPPORTED); } CMReturnDone(result); CMReturn(CMPI_RC_OK); }
CMPIStatus Adapter::invokeMethod( CMPIMethodMI* mi, const CMPIContext* context, const CMPIResult* result, const CMPIObjectPath* cmpi_op, const char* method, const CMPIArgs* in, CMPIArgs* out) { TRACE; _context_tls.set((void*)context); Adapter* adapter = (Adapter*)mi->hdl; Auto_RMutex auto_lock(adapter->_lock); // Find CIMPLE method object: const Meta_Class* mc = adapter->_mc; const Meta_Method* mm = find_method(mc, method); if (!mm) CMReturn(CMPI_RC_ERR_METHOD_NOT_FOUND); // Validate the object path: const char* cn = class_name(cmpi_op); if (!cn || strcasecmp(cn, mm->name) == 0) CMReturn(CMPI_RC_ERR_INVALID_CLASS); if (CMGetKeyCount(cmpi_op, NULL) > 0 && (mm->flags & CIMPLE_FLAG_STATIC)) CMReturn(CMPI_RC_ERR_FAILED); // Convert to CIMPLE reference: Instance* cimple_ref = 0; CMPIrc rc = make_cimple_reference(mc, cmpi_op, cimple_ref); if (rc != CMPI_RC_OK) CMReturn(rc); Destroyer<Instance> cimple_ref_d(cimple_ref); // Create the method: Instance* cimple_meth = 0; rc = make_method(mm, in, cimple_meth); if (rc != CMPI_RC_OK) CMReturn(rc); Destroyer<Instance> cimple_meth_d(cimple_meth); // Invoke the provider: Invoke_Method_Status status = adapter->invoke_method( cimple_ref, cimple_meth); switch (status) { case INVOKE_METHOD_OK: break; case INVOKE_METHOD_FAILED: CMReturn(CMPI_RC_ERR_FAILED); case INVOKE_METHOD_UNSUPPORTED: CMReturn(CMPI_RC_ERR_NOT_SUPPORTED); } // Convert to CMPI out arguments: CMPIValue return_value; CMPIType return_type; const char* ns = name_space(cmpi_op); rc = make_method_out( adapter->broker, ns, cimple_meth, out, return_value, return_type); if (rc != CMPI_RC_OK) CMReturn(rc); // Append CMPI out args: CMReturnData(result, &return_value, return_type); CMReturnDone(result); CMReturn(CMPI_RC_OK); }
CMPIStatus Adapter::getInstance( CMPIInstanceMI* mi, const CMPIContext* context, const CMPIResult* result, const CMPIObjectPath* cmpi_op, const char** properties) { TRACE; _context_tls.set((void*)context); Adapter* adapter = (Adapter*)mi->hdl; Auto_RMutex auto_lock(adapter->_lock); // Convert to CIMPLE reference: const Meta_Class* mc = adapter->_mc; Instance* cimple_ref = 0; CMPIrc rc = make_cimple_reference(mc, cmpi_op, cimple_ref); Destroyer<Instance> cimple_ref_d(cimple_ref); if (rc != CMPI_RC_OK) CMReturn(rc); // Filter properties: if (properties) filter_properties(cimple_ref, properties); // Invoke provider: Instance* cimple_inst = 0; Get_Instance_Status status = adapter->get_instance(cimple_ref, cimple_inst); switch (status) { case GET_INSTANCE_OK: break; case GET_INSTANCE_NOT_FOUND: CMReturn(CMPI_RC_ERR_NOT_FOUND); case GET_INSTANCE_UNSUPPORTED: CMReturn(CMPI_RC_ERR_FAILED); } // Create CMPI instance: CMPIInstance* cmpi_inst; rc = make_cmpi_instance( adapter->broker, cimple_inst, name_space(cmpi_op), cmpi_op, cmpi_inst); if (rc == CMPI_RC_OK) { CMReturnInstance(result, cmpi_inst); CMReturnDone(result); CMReturn(CMPI_RC_OK); } CMReturn(rc); }
CMPIStatus Adapter::referenceNames( CMPIAssociationMI* mi, const CMPIContext* context, const CMPIResult* result, const CMPIObjectPath* cmpi_op, const char* result_class_, const char* role_) { TRACE; _context_tls.set((void*)context); Adapter* adapter = (Adapter*)mi->hdl; Auto_RMutex auto_lock(adapter->_lock); const char* result_class = result_class_ ? result_class_ : ""; const char* role = role_ ? role_ : ""; // Lookup meta class for cmpi_op (not the same as the provider class). const Meta_Class* mc = adapter->_find_meta_class(class_name(cmpi_op)); if (!mc) CMReturn(CMPI_RC_ERR_INVALID_CLASS); CIMPLE_ASSERT(strcasecmp(result_class, adapter->_mc->name) == 0); // Convert to CIMPLE reference: Instance* cimple_ref = 0; CMPIrc rc = make_cimple_reference(mc, cmpi_op, cimple_ref); Destroyer<Instance> cimple_ref_d(cimple_ref); if (rc != CMPI_RC_OK) CMReturn(rc); // Create a model. const Meta_Class* model_meta_class = 0; adapter->get_meta_class(model_meta_class); Instance* cimple_model = cimple::create(model_meta_class); nullify_non_keys(cimple_model); // Invoke the provider: reference_names::Data data = { adapter->broker, context, result, name_space(cmpi_op), CMPI_RC_OK }; Enum_References_Status status = adapter->enum_references( cimple_ref, cimple_model, role, reference_names::_proc, &data); destroy(cimple_model); switch (status) { case ENUM_REFERENCES_OK: CMReturn(CMPI_RC_OK); case ENUM_REFERENCES_FAILED: case ENUM_REFERENCES_UNSUPPORTED: CMReturn(CMPI_RC_ERR_FAILED); } // Unreachable! CMReturn(CMPI_RC_OK); }