/**
* Operator: write
*/
ngemResult_t
ngrcOperatorWrite(
ngrcOperator_t *op,
void *buf,
size_t size,
size_t *nWrite,
bool *canceled)
{
globus_result_t gResult;
ngemResult_t ret = NGEM_FAILED;
bool locked = false;
ngLog_t *log = NULL;
ngrclOperatorCallbackArg_t arg;
NGEM_FNAME(ngrcOperatorWrite);
log = ngemLogGetDefault();
NGEM_ASSERT(op != NULL);
NGEM_ASSERT(size >= 0);
NGEM_ASSERT(nWrite != NULL);
NGEM_ASSERT(canceled != NULL);
*canceled = false;
gResult = globus_mutex_lock(&op->ngo_mutex);
if (gResult != GLOBUS_SUCCESS) {
ngcpLogGlobusError(log, NGRC_LOGCAT_GT, fName,
"globus_mutex_lock", gResult);
goto finalize;
}
locked = true;
ngrclOperatorCallbackArgInitialize(&arg, op);
if (op->ngo_canceled) {
*canceled = true;
} else {
ngLogDebug(log, NGRC_LOGCAT_GT, fName,
"user_data = %p.\n", &arg);
gResult = globus_xio_register_write(
op->ngo_handle, buf, size, size, NULL,
ngrclGlobusCallback, &arg);
if (gResult != GLOBUS_SUCCESS) {
ngcpLogGlobusError(log, NGRC_LOGCAT_GT, fName,
"globus_xio_register_write", gResult);
goto finalize;
}
while (arg.ngoca_done == false) {
gResult = globus_cond_wait(&op->ngo_cond, &op->ngo_mutex);
if (gResult != GLOBUS_SUCCESS) {
ngcpLogGlobusError(log, NGRC_LOGCAT_GT, fName,
"globus_cond_wait", gResult);
}
}
if (arg.ngoca_result != GLOBUS_SUCCESS) {
if (globus_xio_error_is_canceled(arg.ngoca_result) == GLOBUS_FALSE) {
ngcpLogGlobusError(log, NGRC_LOGCAT_GT, fName,
"Callback function for writing", arg.ngoca_result);
goto finalize;
}
*canceled = true;
} else {
ngLogDebug(log, NGRC_LOGCAT_GT, fName,
"Writes %lu bytes\n", (unsigned long)arg.ngoca_bytes);
*nWrite = arg.ngoca_bytes;
}
}
ret = NGEM_SUCCESS;
finalize:
ngrclOperatorCallbackArgFinalize(&arg);
if (locked) {
gResult = globus_mutex_unlock(&op->ngo_mutex);
if (gResult != GLOBUS_SUCCESS) {
ngcpLogGlobusError(log, NGRC_LOGCAT_GT, fName,
"globus_mutex_unlock", gResult);
ret = NGEM_FAILED;
}
locked = false;
}
return ret;
}
static void
read_cb(
globus_xio_handle_t handle,
globus_result_t result,
globus_byte_t * buffer,
globus_size_t len,
globus_size_t nbytes,
globus_xio_data_descriptor_t data_desc,
void * user_arg)
{
test_info_t * info;
globus_result_t res;
if(!globus_xio_error_is_eof(result) &&
!globus_xio_error_is_canceled(result))
{
test_res(GLOBUS_XIO_TEST_FAIL_FINISH_READ, result, __LINE__, __FILE__);
}
info = (test_info_t *) user_arg;
globus_mutex_lock(&info->mutex);
{
if(len < nbytes)
{
failed_exit("read wait for has failed");
}
else if(nbytes > len)
{
failed_exit("too many bytes were read.");
}
info->nread += nbytes;
if(info->nread >= info->total_read_bytes && !info->read_done)
{
info->closed++;
info->read_done = GLOBUS_TRUE;
if(info->closed == 2 || info->write_count == 0)
{
res = globus_xio_register_close(
handle,
NULL,
close_cb,
user_arg);
test_res(GLOBUS_XIO_TEST_FAIL_NONE, res, __LINE__, __FILE__);
}
}
else if(!info->read_done)
{
res = globus_xio_register_read(
handle,
info->buffer,
info->buffer_length,
info->buffer_length,
NULL,
read_cb,
user_arg);
test_res(GLOBUS_XIO_TEST_FAIL_PASS_READ, res, __LINE__, __FILE__);
}
}
globus_mutex_unlock(&info->mutex);
}
/**
* Operator: read
*/
ngemResult_t
ngrcOperatorRead(
ngrcOperator_t *op,
void *buf,
size_t size,
size_t *nRead,
bool *canceled)
{
ngemResult_t ret = NGEM_FAILED;
globus_result_t gResult;
ngLog_t *log = NULL;
bool locked = false;
ngrclOperatorCallbackArg_t arg;
NGEM_FNAME(ngrcOperatorRead);
log = ngemLogGetDefault();
NGEM_ASSERT(op != NULL);
NGEM_ASSERT(size >= 0);
NGEM_ASSERT(nRead != NULL);
NGEM_ASSERT(canceled != NULL);
*canceled = false;
gResult = globus_mutex_lock(&op->ngo_mutex);
if (gResult != GLOBUS_SUCCESS) {
ngcpLogGlobusError(log, NGRC_LOGCAT_GT, fName,
"globus_mutex_lock", gResult);
goto finalize;
}
locked = true;
ngrclOperatorCallbackArgInitialize(&arg, op);
if (op->ngo_canceled) {
*canceled = true;
ret = NGEM_SUCCESS;
goto finalize;
}
gResult = globus_xio_register_read(
op->ngo_handle, buf, size, 1, NULL,
ngrclGlobusCallback, &arg);
if (gResult != GLOBUS_SUCCESS) {
ngcpLogGlobusError(log, NGRC_LOGCAT_GT, fName,
"globus_xio_register_read", gResult);
goto finalize;
}
while (arg.ngoca_done == false) {
gResult = globus_cond_wait(&op->ngo_cond, &op->ngo_mutex);
if (gResult != GLOBUS_SUCCESS) {
ngcpLogGlobusError(log, NGRC_LOGCAT_GT, fName,
"globus_cond_wait", gResult);
}
}
if (arg.ngoca_result != GLOBUS_SUCCESS) {
if (globus_xio_error_is_canceled(arg.ngoca_result) == GLOBUS_TRUE) {
*canceled = true;
} else if (globus_xio_error_is_eof(arg.ngoca_result) == GLOBUS_TRUE) {
*nRead = 0;
} else {
ngcpLogGlobusError(log, NGRC_LOGCAT_GT, fName,
"Callback function for reading", arg.ngoca_result);
goto finalize;
}
} else {
*nRead = arg.ngoca_bytes;
NGEM_ASSERT(*nRead > 0);
}
ret = NGEM_SUCCESS;
finalize:
ngrclOperatorCallbackArgFinalize(&arg);
if (locked) {
gResult = globus_mutex_unlock(&op->ngo_mutex);
if (gResult != GLOBUS_SUCCESS) {
ngcpLogGlobusError(log, NGRC_LOGCAT_GT, fName,
"globus_mutex_unlock", gResult);
ret = NGEM_FAILED;
}
locked = false;
}
return ret;
}
