adb_DetachVolumeResponse_t *DetachVolumeMarshal(adb_DetachVolume_t *detachVolume, const axutil_env_t *env) {
adb_DetachVolumeResponse_t *ret=NULL;
adb_detachVolumeResponseType_t *dvrt=NULL;
adb_detachVolumeType_t *dvt=NULL;
int rc;
axis2_bool_t status=AXIS2_TRUE, forceBool=AXIS2_FALSE;
char statusMessage[256];
char *volumeId=NULL, *instanceId=NULL, *remoteDev=NULL, *localDev=NULL;
int force;
ncMetadata ccMeta;
dvt = adb_DetachVolume_get_DetachVolume(detachVolume, env);
EUCA_MESSAGE_UNMARSHAL(detachVolumeType, dvt, (&ccMeta));
volumeId = adb_detachVolumeType_get_volumeId(dvt, env);
instanceId = adb_detachVolumeType_get_instanceId(dvt, env);
remoteDev = adb_detachVolumeType_get_remoteDev(dvt, env);
localDev = adb_detachVolumeType_get_localDev(dvt, env);
forceBool = adb_detachVolumeType_get_force(dvt, env);
if (forceBool == AXIS2_TRUE) {
force = 1;
} else {
force = 0;
}
status = AXIS2_TRUE;
if (!DONOTHING) {
rc = doDetachVolume(&ccMeta, volumeId, instanceId, remoteDev, localDev, force);
if (rc) {
logprintf("ERROR: doDetachVolume() returned FAIL\n");
status = AXIS2_FALSE;
snprintf(statusMessage, 255, "ERROR");
}
}
dvrt = adb_detachVolumeResponseType_create(env);
adb_detachVolumeResponseType_set_return(dvrt, env, status);
if (status == AXIS2_FALSE) {
adb_detachVolumeResponseType_set_statusMessage(dvrt, env, statusMessage);
}
adb_detachVolumeResponseType_set_correlationId(dvrt, env, ccMeta.correlationId);
adb_detachVolumeResponseType_set_userId(dvrt, env, ccMeta.userId);
ret = adb_DetachVolumeResponse_create(env);
adb_DetachVolumeResponse_set_DetachVolumeResponse(ret, env, dvrt);
return(ret);
}
adb_ncDetachVolumeResponse_t* ncDetachVolumeMarshal (adb_ncDetachVolume_t* ncDetachVolume, const axutil_env_t *env)
{
pthread_mutex_lock(&ncHandlerLock);
adb_ncDetachVolumeType_t * input = adb_ncDetachVolume_get_ncDetachVolume(ncDetachVolume, env);
adb_ncDetachVolumeResponse_t * response = adb_ncDetachVolumeResponse_create(env);
adb_ncDetachVolumeResponseType_t * output = adb_ncDetachVolumeResponseType_create(env);
// get standard fields from input
axis2_char_t * correlationId = adb_ncDetachVolumeType_get_correlationId(input, env);
axis2_char_t * userId = adb_ncDetachVolumeType_get_userId(input, env);
// get operation-specific fields from input
axis2_char_t * instanceId = adb_ncDetachVolumeType_get_instanceId(input, env);
axis2_char_t * volumeId = adb_ncDetachVolumeType_get_volumeId(input, env);
axis2_char_t * remoteDev = adb_ncDetachVolumeType_get_remoteDev(input, env);
axis2_char_t * localDev = adb_ncDetachVolumeType_get_localDev(input, env);
int force = adb_ncDetachVolumeType_get_force(input, env);
eventlog("NC", userId, correlationId, "DetachVolume", "begin");
{ // do it
ncMetadata meta = { correlationId, userId };
int error = doDetachVolume (&meta, instanceId, volumeId, remoteDev, localDev, force);
if (error) {
logprintfl (EUCAERROR, "ERROR: doDetachVolume() failed error=%d\n", error);
adb_ncDetachVolumeResponseType_set_return(output, env, AXIS2_FALSE);
adb_ncDetachVolumeResponseType_set_correlationId(output, env, correlationId);
adb_ncDetachVolumeResponseType_set_userId(output, env, userId);
} else {
// set standard fields in output
adb_ncDetachVolumeResponseType_set_return(output, env, AXIS2_TRUE);
adb_ncDetachVolumeResponseType_set_correlationId(output, env, correlationId);
adb_ncDetachVolumeResponseType_set_userId(output, env, userId);
// no operation-specific fields in output
}
}
// set response to output
adb_ncDetachVolumeResponse_set_ncDetachVolumeResponse(response, env, output);
pthread_mutex_unlock(&ncHandlerLock);
eventlog("NC", userId, correlationId, "DetachVolume", "end");
return response;
}
//!
//! Handles the client detach volume request.
//!
//! @param[in] pStub a pointer to the node controller (NC) stub structure
//! @param[in] pMeta a pointer to the node controller (NC) metadata structure
//! @param[in] instanceId the instance identifier string (i-XXXXXXXX)
//! @param[in] volumeId the volume identifier string (vol-XXXXXXXX)
//! @param[in] remoteDev the target device name
//! @param[in] localDev the local device name
//! @param[in] force if set to 1, this will force the volume to detach
//!
//! @return the result of doDetachVolume()
//!
//! @see doDetachVolume()
//!
int ncDetachVolumeStub(ncStub * pStub, ncMetadata * pMeta, char *instanceId, char *volumeId, char *remoteDev, char *localDev, int force)
{
return doDetachVolume(pMeta, instanceId, volumeId, remoteDev, localDev, force, 1);
}
