static
void
globus_l_gram_streamer_data_callback(
void * arg,
globus_gass_transfer_request_t request,
globus_byte_t * bytes,
globus_size_t length,
globus_bool_t last_data)
{
globus_gram_streamer_monitor_t * monitor = arg;
globus_gram_stream_t * stream;
globus_gass_transfer_request_status_t
status;
globus_mutex_lock(&monitor->mutex);
stream = globus_gass_transfer_request_get_user_pointer(request);
free(bytes);
stream->blocks--;
status = globus_gass_transfer_request_get_status(request);
if (last_data && stream->blocks == 0)
{
switch (status)
{
case GLOBUS_GASS_TRANSFER_REQUEST_INVALID:
case GLOBUS_GASS_TRANSFER_REQUEST_STARTING:
case GLOBUS_GASS_TRANSFER_REQUEST_FAILED:
case GLOBUS_GASS_TRANSFER_REQUEST_DENIED:
case GLOBUS_GASS_TRANSFER_REQUEST_REFERRED:
globus_gass_transfer_request_destroy(request);
if (stream->state != GLOBUS_GRAM_STREAM_RESTART)
{
stream->state = GLOBUS_GRAM_STREAM_FAIL;
globus_cond_signal(&monitor->cond);
}
break;
case GLOBUS_GASS_TRANSFER_REQUEST_DONE:
globus_gass_transfer_request_destroy(request);
if (stream->state == GLOBUS_GRAM_STREAM_ACTIVE)
{
stream->state = GLOBUS_GRAM_STREAM_DONE;
}
globus_cond_signal(&monitor->cond);
break;
case GLOBUS_GASS_TRANSFER_REQUEST_PENDING:
break;
default:
fprintf(stderr, "%d:GASS Transfer returned invalid status: %d\n",
GLOBUS_GRAM_PROTOCOL_ERROR_MALLOC_FAILED,
(int) status);
exit(EXIT_FAILURE);
}
}
globus_mutex_unlock(&monitor->mutex);
}
static
void
globus_l_gram_streamer_request_ready(
void * arg,
globus_gass_transfer_request_t request)
{
globus_gram_streamer_monitor_t * monitor = arg;
globus_gram_stream_t * stream;
globus_gass_transfer_request_status_t
status;
globus_mutex_lock(&monitor->mutex);
stream = globus_gass_transfer_request_get_user_pointer(request);
status = globus_gass_transfer_request_get_status(request);
switch (status)
{
case GLOBUS_GASS_TRANSFER_REQUEST_INVALID:
case GLOBUS_GASS_TRANSFER_REQUEST_STARTING:
globus_gass_transfer_request_destroy(request);
stream->state = GLOBUS_GRAM_STREAM_FAIL;
globus_cond_signal(&monitor->cond);
break;
case GLOBUS_GASS_TRANSFER_REQUEST_FAILED:
case GLOBUS_GASS_TRANSFER_REQUEST_DENIED:
globus_gass_transfer_request_destroy(request);
stream->state = GLOBUS_GRAM_STREAM_FAIL;
globus_cond_signal(&monitor->cond);
break;
case GLOBUS_GASS_TRANSFER_REQUEST_REFERRED:
globus_gass_transfer_request_destroy(request);
stream->state = GLOBUS_GRAM_STREAM_DONE;
globus_cond_signal(&monitor->cond);
break;
case GLOBUS_GASS_TRANSFER_REQUEST_DONE:
globus_gass_transfer_request_destroy(request);
stream->state = GLOBUS_GRAM_STREAM_DONE;
globus_cond_signal(&monitor->cond);
break;
case GLOBUS_GASS_TRANSFER_REQUEST_PENDING:
stream->state = GLOBUS_GRAM_STREAM_ACTIVE;
break;
default:
fprintf(stderr, "%d:GASS Transfer returned invalid status: %d\n",
GLOBUS_GRAM_PROTOCOL_ERROR_MALLOC_FAILED,
(int) status);
exit(EXIT_FAILURE);
}
globus_mutex_unlock(&monitor->mutex);
}
/**
* @brief Determine if the job's processes are still running
*
* The globus_l_gram_streamer_waitpids() function is called periodically to
* check whether the pids associated with this streamer are still running.
* If they are all complete, globus_l_gram_streamer_waitpids() will signal
* the main thread and disable this callback from being called again.
*/
static
void
globus_l_gram_streamer_waitpids(
void * arg)
{
int i;
globus_gram_streamer_monitor_t * monitor = arg;
globus_mutex_lock(&monitor->mutex);
for (i = 0; i < STREAMER_MAX; i++)
{
if (monitor->pids[i] == 0)
{
continue;
}
if (kill(monitor->pids[i], 0) == -1)
{
monitor->pids[i] = 0;
monitor->pid_count--;
}
}
if (monitor->pid_count == 0)
{
globus_cond_signal(&monitor->cond);
globus_callback_unregister(
monitor->waitpids_poll_periodic,
NULL,
NULL,
NULL);
}
globus_mutex_unlock(&monitor->mutex);
}
void
test2_writev_callback(
void * callback_arg,
globus_io_handle_t * handle,
globus_result_t result,
struct iovec * iov,
globus_size_t iovcnt,
globus_size_t nbytes)
{
globus_object_t * err = GLOBUS_NULL;
test_monitor_t * monitor;
monitor = (test_monitor_t *) callback_arg;
if(result != GLOBUS_SUCCESS)
{
err = globus_error_get(result);
}
globus_mutex_lock(&monitor->mutex);
if(result != GLOBUS_SUCCESS &&
!globus_io_eof(err))
{
monitor->use_err = GLOBUS_TRUE;
monitor->err = err;
}
monitor->done = GLOBUS_TRUE;
globus_cond_signal(&monitor->cond);
globus_mutex_unlock(&monitor->mutex);
return;
}
static
void
globus_l_gfs_sigint(
void * user_arg)
{
GlobusGFSName(globus_l_gfs_sigint);
GlobusGFSDebugEnter();
globus_mutex_lock(&globus_l_gfs_mutex);
{
if(globus_l_gfs_sigint_caught)
{
globus_l_gfs_server_active = 0;
}
globus_l_gfs_sigint_caught = GLOBUS_TRUE;
globus_l_gfs_terminated = GLOBUS_TRUE;
if(!globus_l_gfs_server_active)
{
globus_cond_signal(&globus_l_gfs_cond);
}
else
{
globus_libc_printf("Embedded server stopping.\n");
globus_gridftp_server_embed_stop(globus_l_gfs_server_handle);
}
}
globus_mutex_unlock(&globus_l_gfs_mutex);
GlobusGFSDebugExit();
}
void
test1_read_callback(
void * callback_arg,
globus_io_handle_t * handle,
globus_result_t result,
globus_byte_t * buf,
globus_size_t nbytes)
{
globus_object_t * err;
test_monitor_t * monitor;
monitor = (test_monitor_t *) callback_arg;
if(result != GLOBUS_SUCCESS)
{
err = globus_error_get(result);
}
globus_mutex_lock(&monitor->mutex);
if(result != GLOBUS_SUCCESS &&
!globus_io_eof(err))
{
monitor->use_err = GLOBUS_TRUE;
monitor->err = err;
}
buf[nbytes >= test_buffer_size ? test_buffer_size-1 : nbytes] = '\0';
monitor->done = GLOBUS_TRUE;
globus_cond_signal(&monitor->cond);
globus_mutex_unlock(&monitor->mutex);
return;
}
static
void
example_submit_callback(
void * user_callback_arg,
globus_gram_protocol_error_t operation_failure_code,
const char * job_contact,
globus_gram_protocol_job_state_t job_state,
globus_gram_protocol_error_t job_failure_code)
{
struct monitor_t * monitor = user_callback_arg;
globus_mutex_lock(&monitor->mutex);
monitor->done = GLOBUS_TRUE;
globus_cond_signal(&monitor->cond);
if (operation_failure_code == GLOBUS_SUCCESS)
{
printf("Submitted job %s\n",
job_contact ? job_contact : "UNKNOWN");
}
else
{
printf("submit failed because %s (Error %d)\n",
globus_gram_client_error_string(operation_failure_code),
operation_failure_code);
}
globus_mutex_unlock(&monitor->mutex);
}
/**
* @brief Unlock a recursive mutex
* @ingroup globus_mutex
*
* @details
* The globus_rmutex_unlock() function decrements the lock count for
* the lock pointed to by @a rmutex. If the lock count is reduced to
* zero, it also unblocks a thread which is trying to acquire the lock
* if there is one.
*
* @param rmutex
* Mutex to unlock
*
* @return GLOBUS_SUCCESS
*/
int
globus_rmutex_unlock(
globus_rmutex_t * rmutex)
{
globus_mutex_lock(&rmutex->mutex);
{
/* I don't fail here because this is being used with libtool and it
* unlocks a mutex that was never locked
*/
if(rmutex->level > 0)
{
globus_assert(
globus_thread_equal(rmutex->thread_id, globus_thread_self()));
rmutex->level--;
if(rmutex->level == 0)
{
memset(&rmutex->thread_id,0,sizeof(rmutex->thread_id));
if(rmutex->waiting)
{
globus_cond_signal(&rmutex->cond);
}
}
}
}
globus_mutex_unlock(&rmutex->mutex);
return 0;
}
void
test1_connect_callback(
void * callback_arg,
globus_io_handle_t * handle,
globus_result_t result)
{
globus_object_t * err;
test_monitor_t * monitor;
monitor = (test_monitor_t *) callback_arg;
if(result != GLOBUS_SUCCESS)
{
err = globus_error_get(result);
}
globus_mutex_lock(&monitor->mutex);
if(result != GLOBUS_SUCCESS)
{
monitor->use_err = GLOBUS_TRUE;
monitor->err = err;
}
monitor->done = GLOBUS_TRUE;
globus_cond_signal(&monitor->cond);
globus_mutex_unlock(&monitor->mutex);
return;
}
static
void
wakeup_func(
void * arg)
{
globus_mutex_lock(&mutex);
done = GLOBUS_TRUE;
globus_cond_signal(&cond);
globus_mutex_unlock(&mutex);
}
static
void
test_l_gram_callback(
void * callback_arg,
char * job_contact,
int state,
int errorcode)
{
test_monitor_t *monitor = callback_arg;
globus_mutex_lock(&monitor->mutex);
monitor->failure_code = errorcode;
switch (monitor->status)
{
case GLOBUS_GRAM_PROTOCOL_JOB_STATE_UNSUBMITTED:
monitor->status = state;
break;
case GLOBUS_GRAM_PROTOCOL_JOB_STATE_STAGE_IN:
if (state != GLOBUS_GRAM_PROTOCOL_JOB_STATE_UNSUBMITTED)
{
monitor->status = state;
}
case GLOBUS_GRAM_PROTOCOL_JOB_STATE_PENDING:
if (state != GLOBUS_GRAM_PROTOCOL_JOB_STATE_UNSUBMITTED &&
state != GLOBUS_GRAM_PROTOCOL_JOB_STATE_STAGE_IN)
{
monitor->status = state;
}
break;
case GLOBUS_GRAM_PROTOCOL_JOB_STATE_ACTIVE:
if (state != GLOBUS_GRAM_PROTOCOL_JOB_STATE_UNSUBMITTED &&
state != GLOBUS_GRAM_PROTOCOL_JOB_STATE_PENDING &&
state != GLOBUS_GRAM_PROTOCOL_JOB_STATE_STAGE_IN)
{
monitor->status = state;
}
break;
case GLOBUS_GRAM_PROTOCOL_JOB_STATE_STAGE_OUT:
if (state != GLOBUS_GRAM_PROTOCOL_JOB_STATE_UNSUBMITTED &&
state != GLOBUS_GRAM_PROTOCOL_JOB_STATE_PENDING &&
state != GLOBUS_GRAM_PROTOCOL_JOB_STATE_STAGE_IN &&
state != GLOBUS_GRAM_PROTOCOL_JOB_STATE_ACTIVE)
{
monitor->status = state;
}
break;
case GLOBUS_GRAM_PROTOCOL_JOB_STATE_FAILED:
case GLOBUS_GRAM_PROTOCOL_JOB_STATE_DONE:
case GLOBUS_GRAM_PROTOCOL_JOB_STATE_ALL:
case GLOBUS_GRAM_PROTOCOL_JOB_STATE_SUSPENDED:
break;
}
globus_cond_signal(&monitor->cond);
globus_mutex_unlock(&monitor->mutex);
}
static void touch_ctl_cb(void *myargs, globus_ftp_client_handle_t *handle, globus_object_t *error)
{
if (error)
{
FPRINTF(stderr, "%s\n", globus_object_printable_to_string(error));
}
globus_mutex_lock(&lock);
touch_ctl_done=GLOBUS_TRUE;
globus_cond_signal(&cond);
globus_mutex_unlock(&lock);
}
void *
consumer(
void * nitems_arg)
{
int i;
long nitems;
prod_data_t * data;
long thread_id;
nitems = (long) nitems_arg;
thread_id_assign();
thread_id = thread_id_get();
wait_for_all();
for (i = 0; i < nitems ; i++)
{
globus_mutex_lock(&queue_mutex);
{
while(globus_fifo_empty(&queue))
{
# if (DEBUG_LEVEL > 1)
{
globus_stdio_lock();
{
printf("%04ld: consumer() - waiting for data item %d\n",
thread_id,
i);
}
globus_stdio_unlock();
}
# endif
globus_cond_wait(&queue_cond, &queue_mutex);
}
data = globus_fifo_dequeue(&queue);
}
globus_mutex_unlock(&queue_mutex);
globus_mutex_lock(&data->mutex);
{
data->done = GLOBUS_TRUE;
globus_cond_signal(&data->cond);
}
globus_mutex_unlock(&data->mutex);
}
wait_for_all();
return NULL;
}
void
signal_exit()
{
verbose_printf(2, "signal_exit() : start\n");
globus_mutex_lock(&monitor.mutex);
{
monitor.done = GLOBUS_TRUE;
monitor.count++;
globus_cond_signal(&monitor.cond);
}
globus_mutex_unlock(&monitor.mutex);
}
/**
* Callback for writing event to scheduler.
*
* @param handle
* @param result
* @param iovec
* @param count
* @param nbytes
* @param data_desc
* @param user_arg
*/
static
void
globus_l_seg_writev_callback(
globus_xio_handle_t handle,
globus_result_t result,
globus_xio_iovec_t * iovec,
int count,
globus_size_t nbytes,
globus_xio_data_descriptor_t data_desc,
void * user_arg)
{
int i;
globus_bool_t trigger_fault = GLOBUS_FALSE;
globus_bool_t reregister_write = GLOBUS_FALSE;
int do_shutdown = 0;
for (i = 0; i < count; i++)
{
globus_libc_free(iovec[i].iov_base);
}
globus_libc_free(iovec);
globus_mutex_lock(&globus_l_seg_mutex);
globus_l_seg_write_registered = GLOBUS_FALSE;
if (result != GLOBUS_SUCCESS)
{
trigger_fault = GLOBUS_TRUE;
}
else if (!globus_fifo_empty(&globus_l_seg_buffers))
{
reregister_write = GLOBUS_TRUE;
}
else if (globus_l_seg_shutdown)
{
do_shutdown = 1;
}
if (trigger_fault)
{
globus_scheduler_event_generator_fault(result);
}
if (reregister_write)
{
globus_l_seg_register_write(NULL);
}
if (do_shutdown)
{
globus_l_seg_shutdown = 2;
globus_cond_signal(&globus_l_seg_cond);
}
globus_mutex_unlock(&globus_l_seg_mutex);
}
static void writediscontig_ctl_cb(void *myargs, globus_ftp_client_handle_t *handle, globus_object_t *error)
{
if (error)
{
FPRINTF(stderr, "%s\n", globus_object_printable_to_string(error));
}
globus_mutex_lock(&writediscontig_ctl_lock);
if ( writediscontig_ctl_done!=GLOBUS_TRUE )
writediscontig_ctl_done=GLOBUS_TRUE;
globus_cond_signal(&writediscontig_ctl_cond);
globus_mutex_unlock(&writediscontig_ctl_lock);
return;
}
void
abort_cb(
globus_gridftp_server_control_op_t op,
int event_type,
void * user_arg)
{
globus_mutex_lock(&gs_l_mutex);
{
globus_l_done = GLOBUS_TRUE;
globus_cond_signal(&gs_l_cond);
}
globus_mutex_unlock(&gs_l_mutex);
}
static void done_cb( void * user_arg,
globus_ftp_client_handle_t * handle,
globus_object_t * err)
{
if(err){
fprintf(stderr, "%s", globus_object_printable_to_string(err));
}
globus_mutex_lock(&lock);
done = GLOBUS_TRUE;
globus_cond_signal(&cond);
globus_mutex_unlock(&lock);
return;
}
void *
server_func(
void * arg)
{
struct thread_arg * thread_args;
globus_bool_t authenticated;
gss_ctx_id_t context_handle = GSS_C_NO_CONTEXT;
char * user_id = NULL;
gss_cred_id_t credential = GSS_C_NO_CREDENTIAL;
gss_cred_id_t delegated_cred = GSS_C_NO_CREDENTIAL;
thread_args = (struct thread_arg *) arg;
authenticated = globus_gsi_gssapi_test_authenticate(
thread_args->fd,
GLOBUS_TRUE,
thread_args->credential,
&context_handle,
&user_id,
&delegated_cred);
if(authenticated == GLOBUS_FALSE)
{
fprintf(stderr, "SERVER: Authentication failed\n");
}
close(thread_args->fd);
free(thread_args);
globus_gsi_gssapi_test_cleanup(&context_handle,
user_id,
&delegated_cred);
globus_mutex_lock(&mutex);
{
server_thread_count--;
if(server_thread_count == 0)
{
globus_cond_signal(&done);
}
}
globus_mutex_unlock(&mutex);
return NULL;
}
static void
globus_l_done_cb(
globus_gridftp_server_control_t server,
globus_result_t res,
void * user_arg)
{
fprintf(stdout, "Done callback received\n");
test_res(res, __LINE__);
globus_mutex_lock(&globus_l_mutex);
{
globus_l_done = GLOBUS_TRUE;
globus_cond_signal(&globus_l_cond);
}
globus_mutex_unlock(&globus_l_mutex);
}
static void writecontig_ctl_cb(void *myargs, globus_ftp_client_handle_t *handle, globus_object_t *error)
{
if (error)
{
FPRINTF(stderr, "%s\n", globus_object_printable_to_string(error));
}
globus_mutex_lock(&writecontig_ctl_lock);
if ( writecontig_ctl_done!=GLOBUS_TRUE )
writecontig_ctl_done=GLOBUS_TRUE;
globus_cond_signal(&writecontig_ctl_cond);
globus_mutex_unlock(&writecontig_ctl_lock);
#ifdef PRINT_ERR_MSG
FPRINTF(stderr,"finished with contig write transaction\n");
#endif /* PRINT_ERR_MSG */
return;
}
/*
* globus_l_module_mutex_unlock()
*/
static void
globus_l_module_mutex_unlock(
globus_l_module_mutex_t * mutex)
{
globus_mutex_lock(&mutex->mutex);
{
globus_assert(mutex->level > 0);
globus_assert( globus_thread_equal( mutex->thread_id, globus_thread_self() ) );
mutex->level--;
if (mutex->level == 0)
{
globus_cond_signal(&mutex->cond);
}
}
globus_mutex_unlock(&mutex->mutex);
}
static void
close_cb(
globus_xio_handle_t handle,
globus_result_t result,
void * user_arg)
{
test_info_t * info;
info = (test_info_t *) user_arg;
globus_mutex_lock(&globus_l_mutex);
{
globus_l_closed = GLOBUS_TRUE;
globus_cond_signal(&globus_l_cond);
}
globus_mutex_unlock(&globus_l_mutex);
}
static
void
globus_l_state_callback(
void * callback_arg,
char * job_contact,
int state,
int errorcode)
{
monitor_t * monitor = callback_arg;
globus_mutex_lock(&monitor->mutex);
if (! strcmp(monitor->job_contact, job_contact))
{
monitor->job_status = state;
globus_cond_signal(&monitor->cond);
}
globus_mutex_unlock(&monitor->mutex);
}
static
void
gram_state_callback(
void * arg,
char * job_contact,
int state,
int errorcode)
{
monitor_t * monitor;
monitor = arg;
globus_mutex_lock(&monitor->mutex);
monitor->state = state;
monitor->errorcode = errorcode;
globus_cond_signal(&monitor->cond);
globus_mutex_unlock(&monitor->mutex);
}
static
void
client_callback(
void * arg,
globus_gram_protocol_handle_t handle,
globus_byte_t * message,
globus_size_t msgsize,
int errorcode,
char * uri)
{
monitor_t * monitor;
int rc;
monitor = (monitor_t *) arg;
globus_mutex_lock(&monitor->mutex);
if (errorcode != GLOBUS_SUCCESS)
{
fprintf(stderr,
"Failed connecting to service because %s.\n",
globus_gram_protocol_error_string(errorcode));
monitor->error++;
goto failed;
}
rc = globus_gram_protocol_unpack_status_reply(
message,
msgsize,
&monitor->job_status[0],
&monitor->failure_code[0],
&monitor->job_failure_code[0]);
if(rc != GLOBUS_SUCCESS)
{
fprintf(stderr,
"Failed unpacking reply because %s.\n",
globus_gram_protocol_error_string(rc));
monitor->error++;
}
failed:
monitor->done = GLOBUS_TRUE;
globus_cond_signal(&monitor->cond);
globus_mutex_unlock(&monitor->mutex);
}
static
void
done_cb(
void * user_arg,
globus_ftp_client_handle_t * handle,
globus_object_t * err)
{
char * tmpstr;
if(err) { tmpstr = globus_object_printable_to_string(err);
printf("done with error: %s\n", tmpstr);
error = GLOBUS_TRUE;
globus_libc_free(tmpstr); }
globus_mutex_lock(&lock);
done = GLOBUS_TRUE;
globus_cond_signal(&cond);
globus_mutex_unlock(&lock);
}
static
void
info_callback(
void * user_callback_arg,
const char * job_contact,
globus_gram_client_job_info_t * job_info)
{
struct monitor * monitor = user_callback_arg;
if (monitor)
{
globus_mutex_lock(&monitor->mutex);
monitor->job_state = job_info->job_state;
monitor->protocol_error_code = job_info->protocol_error_code;
monitor->done = GLOBUS_TRUE;
globus_cond_signal(&monitor->cond);
globus_mutex_unlock(&monitor->mutex);
}
}
static
void
done_cb(
void * user_arg,
globus_ftp_client_handle_t * handle,
globus_object_t * err)
{
char * tmpstr;
if(err) tmpstr = " an";
else tmpstr = "out";
printf("done with%s error\n", tmpstr);
globus_mutex_lock(&lock);
done = GLOBUS_TRUE;
globus_cond_signal(&cond);
globus_mutex_unlock(&lock);
}
void
list_read_data_callback(
void * callback_arg,
globus_ftp_control_handle_t * handle,
globus_object_t * error,
globus_byte_t * buffer,
globus_size_t length,
globus_off_t offset,
globus_bool_t eof)
{
get_put_info_t * get_put_info;
get_put_info = (get_put_info_t *) callback_arg;
if(error != GLOBUS_NULL)
{
verbose_printf(1, "unable to list files\n");
monitor.rc = GLOBUS_FALSE;
signal_exit();
}
buffer[length] = '\0';
verbose_printf(3, "%s", buffer);
if (!eof)
{
globus_ftp_control_data_read(
handle,
get_put_info->buffer,
get_put_info->buffer_size,
list_read_data_callback,
(void *) get_put_info);
}
else
{
verbose_printf(2, "we have eof\n");
globus_mutex_lock(&data_monitor.mutex);
{
data_monitor.done = GLOBUS_TRUE;
globus_cond_signal(&data_monitor.cond);
}
globus_mutex_unlock(&data_monitor.mutex);
}
}
