adb_AttachVolumeResponse_t *AttachVolumeMarshal(adb_AttachVolume_t *attachVolume, const axutil_env_t *env) {
adb_AttachVolumeResponse_t *ret=NULL;
adb_attachVolumeResponseType_t *avrt=NULL;
adb_attachVolumeType_t *avt=NULL;
int rc;
axis2_bool_t status=AXIS2_TRUE;
char statusMessage[256];
char *volumeId=NULL, *instanceId=NULL, *remoteDev=NULL, *localDev=NULL;
ncMetadata ccMeta;
avt = adb_AttachVolume_get_AttachVolume(attachVolume, env);
EUCA_MESSAGE_UNMARSHAL(attachVolumeType, avt, (&ccMeta));
volumeId = adb_attachVolumeType_get_volumeId(avt, env);
instanceId = adb_attachVolumeType_get_instanceId(avt, env);
remoteDev = adb_attachVolumeType_get_remoteDev(avt, env);
localDev = adb_attachVolumeType_get_localDev(avt, env);
status = AXIS2_TRUE;
if (!DONOTHING) {
rc = doAttachVolume(&ccMeta, volumeId, instanceId, remoteDev, localDev);
if (rc) {
logprintf("ERROR: doAttachVolume() returned FAIL\n");
status = AXIS2_FALSE;
snprintf(statusMessage, 255, "ERROR");
}
}
avrt = adb_attachVolumeResponseType_create(env);
adb_attachVolumeResponseType_set_return(avrt, env, status);
if (status == AXIS2_FALSE) {
adb_attachVolumeResponseType_set_statusMessage(avrt, env, statusMessage);
}
adb_attachVolumeResponseType_set_correlationId(avrt, env, ccMeta.correlationId);
adb_attachVolumeResponseType_set_userId(avrt, env, ccMeta.userId);
ret = adb_AttachVolumeResponse_create(env);
adb_AttachVolumeResponse_set_AttachVolumeResponse(ret, env, avrt);
return(ret);
}
adb_ncAttachVolumeResponse_t* ncAttachVolumeMarshal (adb_ncAttachVolume_t* ncAttachVolume, const axutil_env_t *env)
{
pthread_mutex_lock(&ncHandlerLock);
adb_ncAttachVolumeType_t * input = adb_ncAttachVolume_get_ncAttachVolume(ncAttachVolume, env);
adb_ncAttachVolumeResponse_t * response = adb_ncAttachVolumeResponse_create(env);
adb_ncAttachVolumeResponseType_t * output = adb_ncAttachVolumeResponseType_create(env);
// get standard fields from input
axis2_char_t * correlationId = adb_ncAttachVolumeType_get_correlationId(input, env);
axis2_char_t * userId = adb_ncAttachVolumeType_get_userId(input, env);
// get operation-specific fields from input
axis2_char_t * instanceId = adb_ncAttachVolumeType_get_instanceId(input, env);
axis2_char_t * volumeId = adb_ncAttachVolumeType_get_volumeId(input, env);
axis2_char_t * remoteDev = adb_ncAttachVolumeType_get_remoteDev(input, env);
axis2_char_t * localDev = adb_ncAttachVolumeType_get_localDev(input, env);
eventlog("NC", userId, correlationId, "AttachVolume", "begin");
{ // do it
ncMetadata meta = { correlationId, userId };
int error = doAttachVolume (&meta, instanceId, volumeId, remoteDev, localDev);
if (error) {
logprintfl (EUCAERROR, "ERROR: doAttachVolume() failed error=%d\n", error);
adb_ncAttachVolumeResponseType_set_return(output, env, AXIS2_FALSE);
adb_ncAttachVolumeResponseType_set_correlationId(output, env, correlationId);
adb_ncAttachVolumeResponseType_set_userId(output, env, userId);
} else {
// set standard fields in output
adb_ncAttachVolumeResponseType_set_return(output, env, AXIS2_TRUE);
adb_ncAttachVolumeResponseType_set_correlationId(output, env, correlationId);
adb_ncAttachVolumeResponseType_set_userId(output, env, userId);
// no operation-specific fields in output
}
}
// set response to output
adb_ncAttachVolumeResponse_set_ncAttachVolumeResponse(response, env, output);
pthread_mutex_unlock(&ncHandlerLock);
eventlog("NC", userId, correlationId, "AttachVolume", "end");
return response;
}
//!
//! Handles the client attach 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
//!
//! @return the result of doAttachVolume()
//!
//! @see doAttachVolume()
//!
int ncAttachVolumeStub(ncStub * pStub, ncMetadata * pMeta, char *instanceId, char *volumeId, char *remoteDev, char *localDev)
{
return doAttachVolume(pMeta, instanceId, volumeId, remoteDev, localDev);
}
