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);
}
