void ADIOI_GRIDFTP_Delete(char *filename, int *error_code) { char myname[]="ADIOI_GRIDFTP_Delete"; int myrank, nprocs; globus_ftp_client_handle_t handle; globus_result_t result; *error_code = MPI_SUCCESS; MPI_Comm_size(MPI_COMM_WORLD, &nprocs); MPI_Comm_rank(MPI_COMM_WORLD, &myrank); globus_module_activate(GLOBUS_FTP_CLIENT_MODULE); result=globus_ftp_client_handle_init(&handle,GLOBUS_NULL); if (result != GLOBUS_SUCCESS ) { globus_err_handler("globus_ftp_client_handle_init",myname,result); *error_code= MPIO_Err_create_code(MPI_SUCCESS, MPIR_ERR_RECOVERABLE, myname, __LINE__, MPI_ERR_IO, "**io", "**io %s", globus_object_printable_to_string(globus_error_get(result))); return; } delete_done=GLOBUS_FALSE; delete_success=GLOBUS_FALSE; result=globus_ftp_client_delete(&handle,filename,GLOBUS_NULL,delete_cb,GLOBUS_NULL); if (result != GLOBUS_SUCCESS ) { globus_err_handler("globus_ftp_client_delete",myname,result); *error_code= MPIO_Err_create_code(MPI_SUCCESS, MPIR_ERR_RECOVERABLE, myname, __LINE__, MPI_ERR_IO, "**io", "**io %s", globus_object_printable_to_string(globus_error_get(result))); return; } globus_mutex_lock(&lock); while ( delete_done!=GLOBUS_TRUE ) globus_cond_wait(&cond,&lock); globus_mutex_unlock(&lock); result=globus_ftp_client_handle_destroy(&handle); if (result != GLOBUS_SUCCESS ) { globus_err_handler("globus_ftp_client_handle_destroy",myname,result); *error_code= MPIO_Err_create_code(MPI_SUCCESS, MPIR_ERR_RECOVERABLE, myname, __LINE__, MPI_ERR_IO, "**io", "**io %s", globus_object_printable_to_string(globus_error_get(result))); return; } if ( delete_success!=GLOBUS_TRUE ) { *error_code= MPIO_Err_create_code(MPI_SUCCESS, MPIR_ERR_RECOVERABLE, myname, __LINE__, MPI_ERR_IO, "**io", "**io %s", globus_object_printable_to_string(globus_error_get(result))); } }
int main(int argc, char *argv[]) { int rc; int i; struct monitor_t monitor; if (argc < 3) { fprintf(stderr, "Usage: %s RESOURCE-MANAGER-CONTACT RSL-SPEC...\n", argv[0]); rc = 1; goto out; } printf("Submiting %d jobs to %s\n", argc-2, argv[1]); /* * Always activate the GLOBUS_GRAM_CLIENT_MODULE prior to using any * functions from the GRAM Client API or behavior is undefined. */ rc = globus_module_activate(GLOBUS_GRAM_CLIENT_MODULE); if (rc != GLOBUS_SUCCESS) { fprintf(stderr, "Error activating %s because %s (Error %d)\n", GLOBUS_GRAM_CLIENT_MODULE->module_name, globus_gram_client_error_string(rc), rc); goto out; } rc = globus_mutex_init(&monitor.mutex, NULL); if (rc != GLOBUS_SUCCESS) { fprintf(stderr, "Error initializing mutex %d\n", rc); goto deactivate; } rc = globus_cond_init(&monitor.cond, NULL); if (rc != GLOBUS_SUCCESS) { fprintf(stderr, "Error initializing condition variable %d\n", rc); goto destroy_mutex; } monitor.submit_pending = 0; /* Submits jobs from argv[2] until end of the argv array. At most * CONCURRENT_SUBMITS will be pending at any given time. */ globus_mutex_lock(&monitor.mutex); for (i = 2; i < argc; i++) { /* This throttles the number of concurrent job submissions */ while (monitor.submit_pending >= CONCURRENT_SUBMITS) { globus_cond_wait(&monitor.cond, &monitor.mutex); } /* When the job has been submitted, the example_submit_callback * will be called, either from another thread or from a * globus_cond_wait in a nonthreaded build */ rc = globus_gram_client_register_job_request( argv[1], argv[i], 0, NULL, NULL, example_submit_callback, &monitor); if (rc != GLOBUS_SUCCESS) { fprintf(stderr, "Unable to submit job %s because %s (Error %d)\n", argv[i], globus_gram_client_error_string(rc), rc); } else { monitor.submit_pending++; } } /* Wait until the example_submit_callback function has been called for * each job submission */ while (monitor.submit_pending > 0) { globus_cond_wait(&monitor.cond, &monitor.mutex); } globus_mutex_unlock(&monitor.mutex); printf("Submitted %d jobs (%d successfully)\n", argc-2, monitor.successful_submits); globus_cond_destroy(&monitor.cond); destroy_mutex: globus_mutex_destroy(&monitor.mutex); deactivate: /* * Deactivating the module allows it to free memory and close network * connections. */ rc = globus_module_deactivate(GLOBUS_GRAM_CLIENT_MODULE); out: return rc; }
void ADIOI_GRIDFTP_ReadDiscontig(ADIO_File fd, void *buf, int count, MPI_Datatype datatype, int file_ptr_type, ADIO_Offset offset, ADIO_Status *status, int *error_code) { char myname[]="ADIOI_GRIDFTP_ReadDiscontig"; int myrank,nprocs; /* size and extent of buffer in memory */ MPI_Aint btype_size,btype_extent; /* size and extent of file record layout */ MPI_Aint ftype_size,ftype_extent; /* size of file elemental type; seeks are done in units of this */ MPI_Aint etype_size; MPI_Aint extent; ADIOI_Flatlist_node *flat_file; int i,buf_contig,boff,nblks; globus_off_t start,end,goff; globus_size_t bytes_read; globus_result_t result; globus_byte_t *tmp; if ( fd->access_mode&MPI_MODE_WRONLY ) { *error_code=MPIR_ERR_MODE_WRONLY; return; } *error_code=MPI_SUCCESS; MPI_Comm_rank(fd->comm,&myrank); MPI_Comm_size(fd->comm,&nprocs); etype_size=fd->etype_size; MPI_Type_size(fd->filetype,&ftype_size); MPI_Type_extent(fd->filetype,&ftype_extent); /* This is arguably unnecessary, as this routine assumes that the buffer in memory is contiguous */ MPI_Type_size(datatype,&btype_size); MPI_Type_extent(datatype,&btype_extent); ADIOI_Datatype_iscontig(datatype,&buf_contig); if ( ( btype_extent!=btype_size ) || ( ! buf_contig ) ) { FPRINTF(stderr,"[%d/%d] %s called with discontigous memory buffer\n", myrank,nprocs,myname); fflush(stderr); *error_code = MPIO_Err_create_code(MPI_SUCCESS, MPIR_ERR_RECOVERABLE, myname, __LINE__, MPI_ERR_IO, "**io", 0 ); return; } /* from here we can assume btype_extent==btype_size */ /* Flatten out fd->filetype so we know which blocks to skip */ ADIOI_Flatten_datatype(fd->filetype); flat_file = ADIOI_Flatlist; while (flat_file->type != fd->filetype && flat_file->next!=NULL) flat_file = flat_file->next; /* Figure out how big the area to read is */ start=(globus_off_t)(offset*etype_size); goff=start; boff=0; extent=0; nblks=0; while ( boff < (count*btype_size) ) { int blklen=0; for (i=0;i<flat_file->count;i++) { /* find the length of the next block */ if ( (boff+flat_file->blocklens[i]) < (count*btype_size) ) blklen=flat_file->blocklens[i]; else blklen=(count*btype_size)-boff; /* increment buffer size to be used */ boff+=blklen; /* compute extent -- the nblks*ftype_extent bit is there so we remember how many ftypes we've already been through */ extent=MAX(extent,nblks*ftype_extent+flat_file->indices[i]+blklen); if ( boff>=(count*btype_size) ) break; } nblks++; } if ( extent < count*btype_size ) { fprintf(stderr,"[%d/%d] %s error in computing extent -- extent %d is smaller than total bytes requested %d!\n", myrank,nprocs,myname,extent,count*btype_size); fflush(stderr); *error_code = MPIO_Err_create_code(MPI_SUCCESS, MPIR_ERR_RECOVERABLE, myanem, __LINE__, MPI_ERR_IO, "**io", 0); return; } end=start+(globus_off_t)extent; tmp=(globus_byte_t *)malloc((size_t)extent*sizeof(globus_byte_t)); /* start up the globus partial read */ globus_mutex_init(&readdiscontig_ctl_lock, GLOBUS_NULL); globus_cond_init(&readdiscontig_ctl_cond, GLOBUS_NULL); readdiscontig_ctl_done=GLOBUS_FALSE; if ( (result=globus_ftp_client_partial_get(&(gridftp_fh[fd->fd_sys]), fd->filename, &(oattr[fd->fd_sys]), GLOBUS_NULL, start, end, readdiscontig_ctl_cb, GLOBUS_NULL))!=GLOBUS_SUCCESS ) { globus_err_handler("globus_ftp_client_partial_get",myname,result); *error_code = MPIO_Err_create_code(MPI_SUCCESS, MPIR_ERR_RECOVERABLE, myanem, __LINE__, MPI_ERR_IO, "**io", "**io %s", globus_object_printable_to_string(result)); return; } /* Do all the actual I/Os */ /* Since globus_ftp_client_register_read() is brain-dead and doesn't let you specify an offset, we have to slurp the entire extent into memory and then parse out the pieces we want... Sucks, doesn't it? This should probably be done in chunks (preferably of a size set using a file hint), but that'll have to come later. --TB */ if ( (result=globus_ftp_client_register_read(&(gridftp_fh[fd->fd_sys]), tmp, (globus_size_t)extent, readdiscontig_data_cb, (void *)(&bytes_read)))!=GLOBUS_SUCCESS ) { globus_err_handler("globus_ftp_client_register_read",myname,result); *error_code = MPIO_Err_create_code(MPI_SUCESS, MPIR_ERR_RECOVERABLE, myname, __LINE__, MPI_ERR_IO, "**io", "**io %s", globus_object_printable_to_string(result)); return; } /* The ctl callback won't start till the data callbacks complete, so it's safe to wait on just the ctl callback */ globus_mutex_lock(&readdiscontig_ctl_lock); while ( readdiscontig_ctl_done!=GLOBUS_TRUE ) globus_cond_wait(&readdiscontig_ctl_cond,&readdiscontig_ctl_lock); globus_mutex_unlock(&readdiscontig_ctl_lock); globus_mutex_destroy(&readdiscontig_ctl_lock); globus_cond_destroy(&readdiscontig_ctl_cond); boff=0; nblks=0; goff=0; while ( boff < (count*btype_size) ) { int i,blklen; for (i=0;i<flat_file->count;i++) { if ( (boff+flat_file->blocklens[i]) < (count*btype_size) ) blklen=flat_file->blocklens[i]; else blklen=(count*btype_size)-boff; if ( blklen > 0 ) { goff=nblks*ftype_extent+flat_file->indices[i]; memcpy((globus_byte_t *)buf+boff,tmp+goff,(size_t)blklen); boff+=blklen; if ( boff>=(count*btype_size) ) break; } } nblks++; } free(tmp); #ifdef HAVE_STATUS_SET_BYTES MPIR_Status_set_bytes(status, datatype, bytes_read); #endif if (file_ptr_type != ADIO_EXPLICIT_OFFSET) { fd->fp_ind += extent; fd->fp_sys_posn = fd->fp_ind; } else { fd->fp_sys_posn = offset + extent; } }
int main( int argc, char ** argv) { int opt; globus_gram_streamer_monitor_t monitor; int rc; char local_path[16]; globus_result_t result; globus_reltime_t period; globus_module_descriptor_t * modules[] = { GLOBUS_COMMON_MODULE, GLOBUS_GASS_TRANSFER_MODULE, NULL }; globus_module_descriptor_t * failed_module; memset(&monitor, 0, sizeof(globus_gram_streamer_monitor_t)); globus_mutex_init(&monitor.request.mutex, NULL); globus_cond_init(&monitor.request.cond, NULL); while ((opt = getopt(argc, argv, "s:p:d:h")) != -1) { switch (opt) { case 's': monitor.request.job_state_file = optarg; /* * Assume that the remote I/O file will not be newer than the * current time */ monitor.remote_io_url_file_time = time(NULL); rc = globus_gram_job_manager_state_file_read(&monitor.request); if (rc != GLOBUS_SUCCESS) { fprintf(stderr, "%d:Error reading state file %s\n", rc, optarg); } break; case 'p': if ((monitor.pid_count+1) == STREAMER_MAX) { fprintf(stderr, "%d:Too many pids for streamer\n", GLOBUS_GRAM_PROTOCOL_ERROR_NO_RESOURCES); exit(EXIT_FAILURE); } monitor.pids[monitor.pid_count++] = (pid_t) strtol(optarg, NULL, 10); break; case 'd': rc = chdir(optarg); if (rc != 0) { int save_errno = errno; fprintf(stderr, "%d:Error accessing job state directory: %s (%d)\n", GLOBUS_GRAM_PROTOCOL_ERROR_BAD_DIRECTORY, strerror(save_errno), save_errno); exit(EXIT_FAILURE); } break; case 'h': printf("Usage: %s -s STATE-FILE -p pid [-p pid]...\n", argv[0]); exit(EXIT_SUCCESS); break; case '?': default: fprintf(stderr, "%d:Unknown option: %c\n", GLOBUS_GRAM_PROTOCOL_ERROR_GATEKEEPER_MISCONFIGURED, (char) opt); exit(EXIT_FAILURE); } } rc = globus_module_activate_array(modules, &failed_module); if (rc != GLOBUS_SUCCESS) { fprintf(stderr, "%d:Activation failed: %s %d\n", GLOBUS_GRAM_PROTOCOL_ERROR_GATEKEEPER_MISCONFIGURED, failed_module->module_name, rc); exit(EXIT_FAILURE); } strcpy(local_path, "stdout"); monitor.output_stream.fd = open(local_path, O_RDONLY); strcpy(local_path, "stderr"); monitor.error_stream.fd = open(local_path, O_RDONLY); rc = globus_mutex_init(&monitor.mutex, NULL); if (rc != GLOBUS_SUCCESS) { fprintf(stderr, "%d:Mutex init failed\n", GLOBUS_GRAM_PROTOCOL_ERROR_MALLOC_FAILED); exit(EXIT_FAILURE); } rc = globus_cond_init(&monitor.cond, NULL); if (rc != GLOBUS_SUCCESS) { fprintf(stderr, "%d:Mutex init failed\n", GLOBUS_GRAM_PROTOCOL_ERROR_MALLOC_FAILED); exit(EXIT_FAILURE); } globus_mutex_lock(&monitor.mutex); GlobusTimeReltimeSet(period, 5, 0); result = globus_callback_register_periodic( &monitor.local_poll_periodic, &globus_i_reltime_zero, &period, globus_l_gram_streamer_local_poll, &monitor); if (result != GLOBUS_SUCCESS) { char * errstr = globus_error_print_friendly(globus_error_peek(result)); fprintf(stderr, "%d:Initialization error: %s\n", GLOBUS_GRAM_PROTOCOL_ERROR_MALLOC_FAILED, errstr); free(errstr); exit(EXIT_FAILURE); } result = globus_callback_register_periodic( &monitor.waitpids_poll_periodic, &globus_i_reltime_zero, &period, globus_l_gram_streamer_waitpids, &monitor); if (result != GLOBUS_SUCCESS) { char * errstr = globus_error_print_friendly(globus_error_peek(result)); fprintf(stderr, "%d:Initialization error: %s\n", GLOBUS_GRAM_PROTOCOL_ERROR_MALLOC_FAILED, errstr); free(errstr); exit(EXIT_FAILURE); } rc = globus_l_gram_streamer_get_destinations( &monitor); if (rc != GLOBUS_SUCCESS) { exit(EXIT_FAILURE); } if (monitor.output_stream.fd != -1 && monitor.output_stream.destination != NULL) { rc = globus_l_gram_streamer_open_destination( &monitor, &monitor.output_stream); if (rc != GLOBUS_SUCCESS) { fprintf(stderr, "%d:Error opening stdout destination %s (%d)\n", GLOBUS_GRAM_PROTOCOL_ERROR_OPENING_STDOUT, monitor.output_stream.destination, rc); exit(EXIT_FAILURE); } monitor.output_stream.state = GLOBUS_GRAM_STREAM_NEW; } else { monitor.output_stream.state = GLOBUS_GRAM_STREAM_NONE; } if (monitor.error_stream.fd != -1 && monitor.error_stream.destination != NULL) { rc = globus_l_gram_streamer_open_destination( &monitor, &monitor.error_stream); if (rc != GLOBUS_SUCCESS) { fprintf(stderr, "%d:Error opening stderr destination %s (%d)\n", GLOBUS_GRAM_PROTOCOL_ERROR_OPENING_STDERR, monitor.error_stream.destination, rc); exit(EXIT_FAILURE); } monitor.error_stream.state = GLOBUS_GRAM_STREAM_NEW; } else { monitor.error_stream.state = GLOBUS_GRAM_STREAM_NONE; } while (monitor.pid_count > 0 || (monitor.output_stream.state != GLOBUS_GRAM_STREAM_NONE && monitor.output_stream.state != GLOBUS_GRAM_STREAM_DONE && monitor.output_stream.state != GLOBUS_GRAM_STREAM_FAIL) || (monitor.error_stream.state != GLOBUS_GRAM_STREAM_NONE && monitor.error_stream.state != GLOBUS_GRAM_STREAM_DONE && monitor.error_stream.state != GLOBUS_GRAM_STREAM_FAIL)) { globus_cond_wait(&monitor.cond, &monitor.mutex); } if (monitor.output_stream.state == GLOBUS_GRAM_STREAM_DONE) { printf("%s %s\n", monitor.output_stream.source, monitor.output_stream.destination); } if (monitor.error_stream.state == GLOBUS_GRAM_STREAM_DONE) { printf("%s %s\n", monitor.error_stream.source, monitor.error_stream.destination); } globus_mutex_unlock(&monitor.mutex); globus_module_deactivate(GLOBUS_GASS_TRANSFER_MODULE); globus_module_activate(GLOBUS_COMMON_MODULE); exit(EXIT_SUCCESS); }
int main(int argc, char *argv[]) { char * callback_contact; char * job_contact; char * rm_contact; monitor_t monitor; int rc = 0; LTDL_SET_PRELOADED_SYMBOLS(); printf("1..1\n"); rm_contact = getenv("CONTACT_STRING"); if (argc == 2) { rm_contact = argv[1]; } if (rm_contact == NULL) { fprintf(stderr, "Usage: %s resource-manager-contact\n", argv[0]); exit(1); } rc = globus_module_activate(GLOBUS_COMMON_MODULE); if(rc) { goto end; } rc = globus_module_activate(GLOBUS_GRAM_CLIENT_MODULE); if(rc) { goto disable_modules; } globus_mutex_init(&monitor.mutex ,GLOBUS_NULL); globus_cond_init(&monitor.cond, GLOBUS_NULL); monitor.state = GLOBUS_GRAM_PROTOCOL_JOB_STATE_PENDING; rc = globus_gram_client_callback_allow(gram_state_callback, &monitor, &callback_contact); if(rc != GLOBUS_SUCCESS) { fprintf(stderr, "Error creating callback contact %s.\n", globus_gram_client_error_string(rc)); goto error_exit; } globus_mutex_lock(&monitor.mutex); rc = globus_gram_client_job_request( rm_contact, "&(executable=/bin/sleep)(arguments=300)", GLOBUS_GRAM_PROTOCOL_JOB_STATE_ALL, callback_contact, &job_contact); if(rc != GLOBUS_SUCCESS) { fprintf(stderr, "Error submitting job request %s.\n", globus_gram_client_error_string(rc)); goto destroy_callback_contact; } while(monitor.state != GLOBUS_GRAM_PROTOCOL_JOB_STATE_ACTIVE && monitor.state != GLOBUS_GRAM_PROTOCOL_JOB_STATE_FAILED && monitor.state != GLOBUS_GRAM_PROTOCOL_JOB_STATE_DONE) { globus_cond_wait(&monitor.cond, &monitor.mutex); } if(monitor.state == GLOBUS_GRAM_PROTOCOL_JOB_STATE_ACTIVE) { rc = globus_gram_client_job_cancel(job_contact); if(rc != GLOBUS_SUCCESS) { fprintf(stderr, "Error cancelling job %s.\n", globus_gram_client_error_string(rc)); goto destroy_callback_contact; } } while(monitor.state != GLOBUS_GRAM_PROTOCOL_JOB_STATE_DONE && monitor.state != GLOBUS_GRAM_PROTOCOL_JOB_STATE_FAILED) { globus_cond_wait(&monitor.cond, &monitor.mutex); } rc = monitor.errorcode; if(rc == GLOBUS_GRAM_PROTOCOL_ERROR_USER_CANCELLED) { rc = GLOBUS_SUCCESS; } destroy_callback_contact: globus_mutex_unlock(&monitor.mutex); globus_gram_client_callback_disallow(callback_contact); free(callback_contact); free(job_contact); error_exit: globus_mutex_destroy(&monitor.mutex); globus_cond_destroy(&monitor.cond); disable_modules: globus_module_deactivate_all(); end: printf("%s - cancel-test\n", rc == 0 ? "ok" : "not ok"); return rc; }
int main( int argc, char ** argv) { int rc = 0; globus_result_t result; char * cs; globus_xio_contact_t parsed_contact; char * new_banner; char * old_banner; GlobusGFSName(main); /* activte globus stuff */ if((rc = globus_module_activate(GLOBUS_COMMON_MODULE)) != GLOBUS_SUCCESS || (rc = globus_module_activate( GLOBUS_GRIDFTP_SERVER_MODULE)) != GLOBUS_SUCCESS) { fprintf(stderr, "Error: Failed to initialize:\n%s", globus_error_print_friendly(globus_error_peek(rc))); goto error_activate; } /* initialize global variables */ globus_mutex_init(&globus_l_gfs_mutex, GLOBUS_NULL); globus_cond_init(&globus_l_gfs_cond, GLOBUS_NULL); globus_l_gfs_signal_init(); globus_libc_printf("Embedded server starting.\n"); globus_mutex_lock(&globus_l_gfs_mutex); { result = globus_gridftp_server_embed_init( &globus_l_gfs_server_handle, argv); if(result != GLOBUS_SUCCESS) { rc = 1; goto error_lock; } /* add our acl module */ globus_gfs_acl_add_module(&globus_gfs_acl_test_module); /* customize some config */ old_banner = globus_gridftp_server_embed_config_get_string( globus_l_gfs_server_handle, "banner"); new_banner = globus_common_create_string( "%s\nEMBEDDED", old_banner); globus_gridftp_server_embed_config_set_ptr( globus_l_gfs_server_handle, "banner", new_banner); globus_free(old_banner); globus_gridftp_server_embed_config_set_int( globus_l_gfs_server_handle, "connections_max", 10); globus_gridftp_server_embed_config_set_int( globus_l_gfs_server_handle, "auth_level", 1 | /* identity check */ 2 | /* file access checks */ 4 | /* disable setuid (not really needed with gridmap disabled)*/ 8); /* disable gridmap lookup */ result = globus_gridftp_server_embed_start( globus_l_gfs_server_handle, globus_l_gfs_event_cb, NULL); if(result != GLOBUS_SUCCESS) { rc = 1; goto error_lock; } globus_l_gfs_server_active = GLOBUS_TRUE; cs = globus_gridftp_server_embed_config_get_string( globus_l_gfs_server_handle, "contact_string"); globus_xio_contact_parse(&parsed_contact, cs); globus_libc_printf( "Server listening on port %s.\n", parsed_contact.port); globus_xio_contact_destroy(&parsed_contact); /* run until we are done */ while(!globus_l_gfs_terminated || globus_l_gfs_server_active) { globus_cond_wait(&globus_l_gfs_cond, &globus_l_gfs_mutex); } } globus_mutex_unlock(&globus_l_gfs_mutex); globus_module_deactivate_all(); GlobusGFSDebugExit(); return 0; error_lock: globus_mutex_unlock(&globus_l_gfs_mutex); error_activate: globus_module_deactivate_all(); GlobusGFSDebugExitWithError(); return rc; }
int gsiftp_put(char *filename, FILE **gsiftpfile, int num_streams) { int i; char gsiurl[MAXLEN]; globus_ftp_client_handle_t handle; globus_ftp_client_operationattr_t attr; globus_ftp_client_handleattr_t handle_attr; globus_ftp_control_parallelism_t parallelism; globus_ftp_control_layout_t layout; globus_byte_t * buffer; globus_size_t buffer_length = sizeof(buffer); globus_result_t result; globus_ftp_client_restart_marker_t restart; globus_ftp_control_type_t filetype; globus_module_activate(GLOBUS_FTP_CLIENT_MODULE); globus_mutex_init(&lock, GLOBUS_NULL); globus_cond_init(&cond, GLOBUS_NULL); globus_ftp_client_handle_init(&handle, GLOBUS_NULL); globus_ftp_client_handleattr_init(&handle_attr); globus_ftp_client_operationattr_init(&attr); layout.mode = GLOBUS_FTP_CONTROL_STRIPING_NONE; globus_ftp_client_restart_marker_init(&restart); globus_ftp_client_operationattr_set_mode( &attr, GLOBUS_FTP_CONTROL_MODE_EXTENDED_BLOCK); if (num_streams >= 1) { parallelism.mode = GLOBUS_FTP_CONTROL_PARALLELISM_FIXED; parallelism.fixed.size = num_streams; globus_ftp_client_operationattr_set_parallelism( &attr, ¶llelism); } globus_ftp_client_operationattr_set_layout(&attr, &layout); filetype = GLOBUS_FTP_CONTROL_TYPE_IMAGE; globus_ftp_client_operationattr_set_type (&attr, filetype); globus_ftp_client_handle_init(&handle, &handle_attr); done = GLOBUS_FALSE; strcpy(gsiurl,"gsiftp://"); if (strlen(gsiurl)+strlen(filename) > MAXLEN-1) { ffpmsg("file name too long (gsiftp_put)"); return (FILE_NOT_OPENED); } strcat(gsiurl,filename); *gsiftpfile = fopen(gsiftp_tmpfile,"r"); if (!*gsiftpfile) { ffpmsg("Unable to open temporary file!"); return (FILE_NOT_OPENED); } result = globus_ftp_client_put(&handle, gsiurl, &attr, &restart, done_cb, 0); if(result != GLOBUS_SUCCESS) { globus_object_t * err; err = globus_error_get(result); fprintf(stderr, "%s", globus_object_printable_to_string(err)); done = GLOBUS_TRUE; } else { int rc; int curr_offset; for (i = 0; i< 2 * num_streams && feof(*gsiftpfile) == 0; i++) { buffer = malloc(MAX_BUFFER_SIZE_W); globus_mutex_lock(&lock); curr_offset = global_offset; rc = fread(buffer, 1, MAX_BUFFER_SIZE_W, *gsiftpfile); global_offset += rc; globus_mutex_unlock(&lock); globus_ftp_client_register_write( &handle, buffer, rc, curr_offset, feof(*gsiftpfile) != 0, data_cb_write, (void*) *gsiftpfile); } } globus_mutex_lock(&lock); while(!done) { globus_cond_wait(&cond, &lock); } globus_mutex_unlock(&lock); globus_ftp_client_handle_destroy(&handle); globus_module_deactivate_all(); return 0; }
int main(int argc, char **argv) { globus_ftp_client_handle_t handle; globus_ftp_client_operationattr_t attr; globus_byte_t * buffer; globus_result_t result; globus_ftp_client_handleattr_t handle_attr; char * src; char * dst; int i; globus_size_t parallelism_level = 1; globus_ftp_control_parallelism_t parallelism; globus_ftp_control_layout_t layout; LTDL_SET_PRELOADED_SYMBOLS(); globus_module_activate(GLOBUS_FTP_CLIENT_MODULE); globus_ftp_client_handleattr_init(&handle_attr); globus_ftp_client_operationattr_init(&attr); /* Parse local arguments */ for(i = 1; i < argc; i++) { if(strcmp(argv[i], "-P") == 0 && i + 1 < argc) { parallelism_level = atoi(argv[i+1]); test_remove_arg(&argc, argv, &i, 1); } } test_parse_args(argc, argv, &handle_attr, &attr, &src, &dst); if(parallelism_level < 1) { parallelism_level = 1; } parallelism.mode = GLOBUS_FTP_CONTROL_PARALLELISM_FIXED; parallelism.fixed.size = parallelism_level; layout.mode = GLOBUS_FTP_CONTROL_STRIPING_BLOCKED_ROUND_ROBIN; layout.round_robin.block_size = 64*1024; globus_mutex_init(&lock, GLOBUS_NULL); globus_cond_init(&cond, GLOBUS_NULL); globus_ftp_client_operationattr_set_mode( &attr, GLOBUS_FTP_CONTROL_MODE_EXTENDED_BLOCK); globus_ftp_client_operationattr_set_parallelism(&attr, ¶llelism); globus_ftp_client_operationattr_set_layout(&attr, &layout); globus_ftp_client_handle_init(&handle, &handle_attr); done = GLOBUS_FALSE; result = globus_ftp_client_put(&handle, dst, &attr, GLOBUS_NULL, done_cb, 0); globus_mutex_lock(&lock); if(result != GLOBUS_SUCCESS) { globus_object_t * err; err = globus_error_get(result); fprintf(stderr, "%s", globus_object_printable_to_string(err)); done = GLOBUS_TRUE; } else { int rc=1; int i; for(i = 0; i < parallelism_level && rc != 0; i++) { buffer = malloc(MYSIZE); rc = read(0, buffer, MYSIZE); globus_ftp_client_register_write( &handle, buffer, rc, global_offset, rc == 0, data_cb, 0); global_offset += rc; } } while(!done) { globus_cond_wait(&cond, &lock); } globus_mutex_unlock(&lock); globus_ftp_client_handle_destroy(&handle); globus_module_deactivate_all(); if(test_abort_count && error) { return 0; } return error; }
/** * 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; }
void ADIOI_GRIDFTP_Fcntl(ADIO_File fd, int flag, ADIO_Fcntl_t *fcntl_struct, int *error_code) { MPI_Datatype copy_etype, copy_filetype; int combiner, i, j, k, filetype_is_contig, err; ADIOI_Flatlist_node *flat_file; char myname[]="ADIOI_GRIDFTP_Fcntl"; int myrank, nprocs; *error_code = MPI_SUCCESS; MPI_Comm_size(fd->comm, &nprocs); MPI_Comm_rank(fd->comm, &myrank); switch(flag) { case ADIO_FCNTL_GET_FSIZE: { globus_result_t result; globus_off_t fsize=0; globus_mutex_init(&fcntl_size_lock,GLOBUS_NULL); globus_cond_init(&fcntl_size_cond,GLOBUS_NULL); fcntl_size_done=GLOBUS_FALSE; if ( (result=globus_ftp_client_size(&(gridftp_fh[fd->fd_sys]), fd->filename, &(oattr[fd->fd_sys]), &(fsize), fcntl_size_cb, GLOBUS_NULL))!=GLOBUS_SUCCESS ) { globus_err_handler("globus_ftp_client_size",myname,result); *error_code = MPIO_Err_create_code(MPI_SUCCESS, MPIR_ERR_RECOVERABLE, myname, __LINE__, MPI_ERR_IO, "**io", "**io %s", globus_object_printable_to_string(globus_error_get(result))); return; } globus_mutex_lock(&fcntl_size_lock); while ( fcntl_size_done!=GLOBUS_TRUE ) globus_cond_wait(&fcntl_size_lock,&fcntl_size_cond); globus_mutex_unlock(&fcntl_size_lock); globus_mutex_destroy(&fcntl_size_lock); globus_cond_destroy(&fcntl_size_cond); fcntl_struct->fsize=fsize; } *error_code = MPI_SUCCESS; break; case ADIO_FCNTL_SET_DISKSPACE: ADIOI_GEN_Prealloc(fd, fcntl_struct->diskspace, error_code); break; case ADIO_FCNTL_SET_ATOMICITY: default: *error_code = MPIO_Err_create_code(MPI_SUCCESS, MPIR_ERR_RECOVERABLE, myname, __LINE__, MPI_ERR_ARG, "**flag", "**flag %d", flag); } }
/* Test Case: * Submit a job that generates output after a short time. * Before that output is generated, send a STDIO_UPDATE signal, to * direct the output to a different port. * Verify that the output arrives at the new port */ int test_stdio_update(void) { char *old_listener_url, *new_listener_url; char *old_job_contact; int rc; char *callback_contact; char *old_rsl, *new_rsl; test_monitor_t monitor; const char rsl_spec[] = "&(executable=/bin/sh)" "(arguments=-c 'sleep 30; echo hello;')" "(rsl_substitution = (TEST_GASS_URL %s))" "(stdout = $(TEST_GASS_URL)/out)"; const char stdio_update_rsl_spec[] = "&(stdout = %s/out)"; globus_mutex_init(&monitor.mutex, NULL); globus_cond_init(&monitor.cond, NULL); memset(monitor.old_output, 0, sizeof(monitor.old_output)); memset(monitor.new_output, 0, sizeof(monitor.new_output)); monitor.old_request = GLOBUS_NULL_HANDLE; monitor.new_request = GLOBUS_NULL_HANDLE; monitor.status = GLOBUS_GRAM_PROTOCOL_JOB_STATE_UNSUBMITTED; monitor.failure_code = 0; /* Create a pair of listeners and get their base URLs. The job will be * submitted with stdout directed to the first, then redirected to the * second via a stdio update signal */ rc = globus_gass_transfer_create_listener( &monitor.old_listener, NULL, "https"); test_assert_gram_rc_equals(rc, GLOBUS_SUCCESS); test_assert(monitor.old_listener != GLOBUS_NULL_HANDLE); old_listener_url = globus_gass_transfer_listener_get_base_url( monitor.old_listener); test_assert(old_listener_url != NULL); rc = globus_gass_transfer_register_listen( monitor.old_listener, test_l_old_listener_callback, &monitor); test_assert_gram_rc_equals(rc, GLOBUS_SUCCESS); rc = globus_gass_transfer_create_listener( &monitor.new_listener, NULL, "https"); test_assert_gram_rc_equals(rc, GLOBUS_SUCCESS); test_assert(monitor.new_listener != GLOBUS_NULL_HANDLE); new_listener_url = globus_gass_transfer_listener_get_base_url( monitor.new_listener); test_assert(new_listener_url != NULL); rc = globus_gass_transfer_register_listen( monitor.new_listener, test_l_new_listener_callback, &monitor); test_assert(rc == GLOBUS_SUCCESS); old_rsl = globus_common_create_string(rsl_spec, old_listener_url); test_assert(old_rsl != NULL); /* Submit the job, do the two-phase commit, then submit a restart * request with the new stdout destination */ rc = globus_gram_client_callback_allow( test_l_gram_callback, &monitor, &callback_contact); test_assert_gram_rc_equals(rc, GLOBUS_SUCCESS); test_assert(callback_contact != NULL); rc = globus_gram_client_job_request( contact_string, old_rsl, GLOBUS_GRAM_PROTOCOL_JOB_STATE_UNSUBMITTED| GLOBUS_GRAM_PROTOCOL_JOB_STATE_STAGE_IN| GLOBUS_GRAM_PROTOCOL_JOB_STATE_PENDING| GLOBUS_GRAM_PROTOCOL_JOB_STATE_ACTIVE| GLOBUS_GRAM_PROTOCOL_JOB_STATE_STAGE_OUT| GLOBUS_GRAM_PROTOCOL_JOB_STATE_DONE| GLOBUS_GRAM_PROTOCOL_JOB_STATE_FAILED, callback_contact, &old_job_contact); test_assert_gram_rc_equals(rc, GLOBUS_SUCCESS); test_assert(old_job_contact != NULL); globus_mutex_lock(&monitor.mutex); while (monitor.status == GLOBUS_GRAM_PROTOCOL_JOB_STATE_UNSUBMITTED) { globus_cond_wait(&monitor.cond, &monitor.mutex); } new_rsl = globus_common_create_string( stdio_update_rsl_spec, new_listener_url); test_assert(new_rsl != NULL); rc = globus_gram_client_job_signal( old_job_contact, GLOBUS_GRAM_PROTOCOL_JOB_SIGNAL_STDIO_UPDATE, new_rsl, &monitor.status, &monitor.failure_code); test_assert_gram_rc_equals(rc, GLOBUS_SUCCESS); /* Wait for job to complete. After it's done, check to see which * destination got stdout */ while (monitor.status != GLOBUS_GRAM_PROTOCOL_JOB_STATE_DONE && monitor.status != GLOBUS_GRAM_PROTOCOL_JOB_STATE_FAILED) { globus_cond_wait(&monitor.cond, &monitor.mutex); } if (monitor.old_request) { globus_gass_transfer_fail(monitor.old_request, test_l_gass_fail, NULL); } globus_mutex_unlock(&monitor.mutex); if (monitor.new_output[0] == 0) { fprintf(stderr, "Didn't get expected output to new handle\n"); test_assert(strcmp((char *) monitor.new_output, "hello\n") == 0); } if (monitor.old_output[0] != 0) { fprintf(stderr, "Unexpected output to old handle: %s", monitor.old_output); test_assert(monitor.old_output[0] == 0); } return rc; }
int main(int argc, char *argv[]) { int rc = 1; monitor_t monitor; char * rsl; if (argc < 4 || (!globus_l_get_mode(&monitor, argv[2])) || ((monitor.timeout = atoi(argv[3])) < 0)) { globus_libc_fprintf(stderr, "Usage: %s RM-CONTACT MODE SAVE_STATE TIMEOUT\n" " RM-CONTACT: resource manager contact\n" " MODE: no-commit|no-commit-end|commit|late-commit-end\n" " TIMEOUT: two-phase timeout in seconds\n", argv[0]); goto error_exit; } rc = globus_module_activate(GLOBUS_GRAM_CLIENT_MODULE); if (rc != GLOBUS_SUCCESS) { globus_libc_fprintf(stderr, "failure activating GLOBUS_GRAM_CLIENT_MODULE: %s\n", globus_gram_client_error_string(rc)); goto error_exit; } rsl = globus_common_create_string(format, monitor.timeout); if (rsl == NULL) { globus_libc_fprintf(stderr, "failure allocating rsl string\n"); goto deactivate_exit; } globus_mutex_init(&monitor.mutex, NULL); globus_cond_init(&monitor.cond, NULL); monitor.job_contact = NULL; monitor.callback_contact = NULL; rc = globus_gram_client_callback_allow( globus_l_state_callback, &monitor, &monitor.callback_contact); if (rc != GLOBUS_SUCCESS || monitor.callback_contact == NULL) { globus_libc_fprintf(stderr, "failure allowing callbacks\n"); rc = -1; goto destroy_monitor_exit; } globus_mutex_lock(&monitor.mutex); rc = globus_gram_client_job_request( argv[1], rsl, GLOBUS_GRAM_PROTOCOL_JOB_STATE_ALL, monitor.callback_contact, &monitor.job_contact); if (monitor.job_contact != NULL) { globus_libc_printf("%s\n", monitor.job_contact); } if (rc != GLOBUS_GRAM_PROTOCOL_ERROR_WAITING_FOR_COMMIT) { if (rc == GLOBUS_SUCCESS) { globus_libc_fprintf(stderr, "job manager did not return " "GLOBUS_GRAM_PROTOCOL_ERROR_COMMIT_TIMED_OUT\n"); rc = -1; } else { globus_libc_fprintf(stderr, "failure submitting job request [%d]: %s\n", rc, globus_gram_client_error_string(rc)); } goto disallow_exit; } rc = 0; if (monitor.mode == no_commit) { goto disallow_exit; } rc = globus_gram_client_job_signal( monitor.job_contact, GLOBUS_GRAM_PROTOCOL_JOB_SIGNAL_COMMIT_REQUEST, NULL, &monitor.job_status, &monitor.failure_code); if (rc != GLOBUS_SUCCESS) { globus_libc_fprintf(stderr, "failure sending commit signal: %s\n", globus_gram_client_error_string(rc)); goto disallow_exit; } while (monitor.job_status != GLOBUS_GRAM_PROTOCOL_JOB_STATE_DONE && monitor.job_status != GLOBUS_GRAM_PROTOCOL_JOB_STATE_FAILED) { globus_cond_wait(&monitor.cond, &monitor.mutex); } if (monitor.mode == no_commit_end) { rc = 0; goto disallow_exit; } else if (monitor.mode == late_commit_end) { rc = 0; sleep(monitor.timeout + 1); } rc = globus_gram_client_job_signal( monitor.job_contact, GLOBUS_GRAM_PROTOCOL_JOB_SIGNAL_COMMIT_END, NULL, &monitor.job_status, &monitor.failure_code); if (rc != GLOBUS_SUCCESS) { globus_libc_fprintf(stderr, "failure sending commit end signal: %s\n", globus_gram_client_error_string(rc)); goto disallow_exit; } disallow_exit: if (monitor.job_contact != NULL) { globus_gram_client_job_contact_free(monitor.job_contact); } globus_mutex_unlock(&monitor.mutex); globus_gram_client_callback_disallow(monitor.callback_contact); destroy_monitor_exit: if (monitor.callback_contact != NULL) { free(monitor.callback_contact); } globus_mutex_destroy(&monitor.mutex); globus_cond_destroy(&monitor.cond); free(rsl); deactivate_exit: globus_module_deactivate_all(); error_exit: return rc; }
int close_barrier2_main( int argc, char ** argv) { int rc; globus_xio_stack_t stack; globus_xio_handle_t handle; globus_result_t res; globus_abstime_t end_time; globus_xio_attr_t attr; globus_l_close_called = GLOBUS_FALSE; globus_l_closed = GLOBUS_FALSE; rc = globus_module_activate(GLOBUS_XIO_MODULE); globus_assert(rc == 0); res = globus_xio_attr_init(&attr); test_res(GLOBUS_XIO_TEST_FAIL_NONE, res, __LINE__, __FILE__); res = globus_xio_stack_init(&stack, NULL); test_res(GLOBUS_XIO_TEST_FAIL_NONE, res, __LINE__, __FILE__); parse_parameters(argc, argv, stack, attr); globus_mutex_init(&globus_l_mutex, NULL); globus_cond_init(&globus_l_cond, NULL); res = globus_xio_handle_create(&handle, stack); test_res(GLOBUS_XIO_TEST_FAIL_NONE, res, __LINE__, __FILE__); res = globus_xio_register_open( handle, "whatever", attr, open_cb, NULL); test_res(GLOBUS_XIO_TEST_FAIL_NONE, res, __LINE__, __FILE__); globus_mutex_lock(&globus_l_mutex); { while(!globus_l_closed) { globus_cond_wait(&globus_l_cond, &globus_l_mutex); } } globus_mutex_unlock(&globus_l_mutex); res = globus_xio_attr_destroy(attr); test_res(GLOBUS_XIO_TEST_FAIL_NONE, res, __LINE__, __FILE__); res = globus_xio_stack_destroy(stack); test_res(GLOBUS_XIO_TEST_FAIL_NONE, res, __LINE__, __FILE__); test_common_end(); globus_mutex_destroy(&globus_l_mutex); globus_cond_destroy(&globus_l_cond); rc = globus_module_deactivate(GLOBUS_XIO_MODULE); globus_assert(rc == 0); fprintf(stdout, "Success.\n"); return 0; }
int main(int argc, char *argv[]) { globus_ftp_client_handle_t handle; globus_ftp_client_operationattr_t attr; globus_byte_t buffer[SIZE]; globus_size_t buffer_length = sizeof(buffer); globus_result_t result; char * src; char * dst; globus_ftp_client_handleattr_t handle_attr; int i; char * subject = GLOBUS_NULL; globus_module_activate(GLOBUS_FTP_CLIENT_MODULE); globus_ftp_client_handleattr_init(&handle_attr); globus_mutex_init(&lock, GLOBUS_NULL); globus_cond_init(&cond, GLOBUS_NULL); globus_ftp_client_operationattr_init(&attr); /* Parse local arguments */ for(i = 1; i < argc; i++) { if(strcmp(argv[i], "-A") == 0 && i + 1 < argc) { subject = argv[i+1]; test_remove_arg(&argc, argv, &i, 1); } } test_parse_args(argc, argv, &handle_attr, &attr, &src, &dst); globus_ftp_client_operationattr_set_authorization(&attr, GSS_C_NO_CREDENTIAL, ":globus-mapping:", "", 0, subject); globus_ftp_client_handle_init(&handle, &handle_attr); done = GLOBUS_FALSE; result = globus_ftp_client_get(&handle, src, &attr, GLOBUS_NULL, done_cb, 0); if(result != GLOBUS_SUCCESS) { error = GLOBUS_TRUE; done = GLOBUS_TRUE; } else { globus_ftp_client_register_read( &handle, buffer, buffer_length, data_cb, 0); } globus_mutex_lock(&lock); while(!done) { globus_cond_wait(&cond, &lock); } globus_mutex_unlock(&lock); globus_ftp_client_handle_destroy(&handle); globus_module_deactivate_all(); if(test_abort_count && error) { return 0; } return error; }
int main(int argc, char *argv[]) { int rc; globus_gram_client_attr_t attr; struct monitor_t monitor; if (argc < 3) { fprintf(stderr, "Usage: %s RESOURCE-MANAGER-CONTACT RSL-SPEC...\n", argv[0]); rc = 1; goto out; } printf("Submiting job to %s with full proxy\n", argv[1]); /* * Always activate the GLOBUS_GRAM_CLIENT_MODULE prior to using any * functions from the GRAM Client API or behavior is undefined. */ rc = globus_module_activate(GLOBUS_GRAM_CLIENT_MODULE); if (rc != GLOBUS_SUCCESS) { fprintf(stderr, "Error activating %s because %s (Error %d)\n", GLOBUS_GRAM_CLIENT_MODULE->module_name, globus_gram_client_error_string(rc), rc); goto out; } rc = globus_mutex_init(&monitor.mutex, NULL); if (rc != GLOBUS_SUCCESS) { fprintf(stderr, "Error initializing mutex %d\n", rc); goto deactivate; } rc = globus_cond_init(&monitor.cond, NULL); if (rc != GLOBUS_SUCCESS) { fprintf(stderr, "Error initializing condition variable %d\n", rc); goto destroy_mutex; } monitor.done = GLOBUS_FALSE; /* Initialize attribute so that we can set the delegation attribute */ rc = globus_gram_client_attr_init(&attr); /* Set the proxy attribute */ rc = globus_gram_client_attr_set_delegation_mode( attr, GLOBUS_IO_SECURE_DELEGATION_MODE_FULL_PROXY); /* Submit the job rsl from argv[2] */ globus_mutex_lock(&monitor.mutex); /* When the job has been submitted, the example_submit_callback * will be called, either from another thread or from a * globus_cond_wait in a nonthreaded build */ rc = globus_gram_client_register_job_request( argv[1], argv[2], 0, NULL, attr, example_submit_callback, &monitor); if (rc != GLOBUS_SUCCESS) { fprintf(stderr, "Unable to submit job %s because %s (Error %d)\n", argv[2], globus_gram_client_error_string(rc), rc); } /* Wait until the example_submit_callback function has been called for * the job submission */ while (!monitor.done) { globus_cond_wait(&monitor.cond, &monitor.mutex); } globus_mutex_unlock(&monitor.mutex); globus_cond_destroy(&monitor.cond); destroy_mutex: globus_mutex_destroy(&monitor.mutex); deactivate: /* * Deactivating the module allows it to free memory and close network * connections. */ rc = globus_module_deactivate(GLOBUS_GRAM_CLIENT_MODULE); out: return rc; }
/** * 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; }
int main(int argc, char *argv[]) { globus_ftp_client_handle_t handle; globus_ftp_client_operationattr_t attr; globus_ftp_client_handleattr_t handle_attr; globus_byte_t buffer[SIZE]; globus_size_t buffer_length = sizeof(buffer); globus_result_t result; globus_abstime_t modification_time; time_t t; struct tm * tm; char * src; char * dst; LTDL_SET_PRELOADED_SYMBOLS(); globus_module_activate(GLOBUS_FTP_CLIENT_MODULE); globus_ftp_client_handleattr_init(&handle_attr); globus_ftp_client_operationattr_init(&attr); test_parse_args(argc, argv, &handle_attr, &attr, &src, &dst); globus_mutex_init(&lock, GLOBUS_NULL); globus_cond_init(&cond, GLOBUS_NULL); globus_ftp_client_handle_init(&handle, &handle_attr); done = GLOBUS_FALSE; result = globus_ftp_client_modification_time(&handle, src, &attr, &modification_time, done_cb, 0); if(result != GLOBUS_SUCCESS) { fprintf(stderr, "%s", globus_object_printable_to_string(globus_error_get(result))); error = GLOBUS_TRUE; done = GLOBUS_TRUE; } globus_mutex_lock(&lock); while(!done) { globus_cond_wait(&cond, &lock); } globus_mutex_unlock(&lock); globus_ftp_client_handle_destroy(&handle); globus_module_deactivate_all(); if(test_abort_count && error) { return 0; } if(error == GLOBUS_SUCCESS) { t = (time_t) modification_time.tv_sec; printf("Last modified %s", ctime(&t)); } return error; }
int timeout_main( int argc, char ** argv) { int rc; globus_xio_stack_t stack; globus_xio_handle_t handle; globus_result_t res; globus_xio_attr_t attr; int secs; int usecs; globus_reltime_t delay; int div = 5; globus_l_closed = GLOBUS_FALSE; globus_l_timeout = GLOBUS_TRUE; rc = globus_module_activate(GLOBUS_XIO_MODULE); globus_assert(rc == 0); res = globus_xio_attr_init(&attr); test_res(GLOBUS_XIO_TEST_FAIL_NONE, res, __LINE__, __FILE__); res = globus_xio_stack_init(&stack, NULL); test_res(GLOBUS_XIO_TEST_FAIL_NONE, res, __LINE__, __FILE__); parse_parameters(argc, argv, stack, attr); GlobusTimeReltimeGet(globus_l_test_info.delay, secs, usecs); if(secs == 0 && usecs < USEC_THRESHHOLD) { fprintf(stderr, "ERROR: delay time must be at least %d usecs.\n", USEC_THRESHHOLD); return 1; } GlobusTimeReltimeSet(delay, secs/div, usecs/div); /* set up timeouts */ if(strcmp(argv[argc-1], "O") == 0) { res = globus_xio_attr_cntl(attr, NULL, GLOBUS_XIO_ATTR_SET_TIMEOUT_OPEN, timeout_cb, &delay, NULL); } else if(strcmp(argv[argc-1], "D") == 0) { res = globus_xio_attr_cntl(attr, NULL, GLOBUS_XIO_ATTR_SET_TIMEOUT_READ, timeout_cb, &delay, NULL); res = globus_xio_attr_cntl(attr, NULL, GLOBUS_XIO_ATTR_SET_TIMEOUT_WRITE, timeout_cb, &delay, NULL); } else if(strcmp(argv[argc-1], "C") == 0) { res = globus_xio_attr_cntl(attr, NULL, GLOBUS_XIO_ATTR_SET_TIMEOUT_CLOSE, timeout_cb, &delay, NULL); } else { fprintf(stderr, "ERROR: No timeout registered.\n"); return 1; } test_res(GLOBUS_XIO_TEST_FAIL_NONE, res, __LINE__, __FILE__); globus_mutex_init(&globus_l_mutex, NULL); globus_cond_init(&globus_l_cond, NULL); res = globus_xio_handle_create(&handle, stack); test_res(GLOBUS_XIO_TEST_FAIL_NONE, res, __LINE__, __FILE__); res = globus_xio_register_open( handle, "whatever", attr, open_cb, argv[argc-1]); test_res(GLOBUS_XIO_TEST_FAIL_NONE, res, __LINE__, __FILE__); globus_mutex_lock(&globus_l_mutex); { while(!globus_l_closed) { globus_cond_wait(&globus_l_cond, &globus_l_mutex); } } globus_mutex_unlock(&globus_l_mutex); /* run again with an ignored time out */ globus_l_closed = GLOBUS_FALSE; globus_l_timeout = GLOBUS_FALSE; res = globus_xio_handle_create(&handle, stack); test_res(GLOBUS_XIO_TEST_FAIL_NONE, res, __LINE__, __FILE__); res = globus_xio_register_open( handle, "whatever", attr, open_cb, argv[argc-1]); test_res(GLOBUS_XIO_TEST_FAIL_NONE, res, __LINE__, __FILE__); globus_mutex_lock(&globus_l_mutex); { while(!globus_l_closed) { globus_cond_wait(&globus_l_cond, &globus_l_mutex); } } globus_mutex_unlock(&globus_l_mutex); /* shut it down */ globus_xio_attr_destroy(attr); globus_xio_stack_destroy(stack); test_common_end(); rc = globus_module_deactivate(GLOBUS_XIO_MODULE); globus_assert(rc == 0); fprintf(stdout, "Success.\n"); return 0; }
int main( int argc, char * argv[]) { int rc; char * server_callback_contact; globus_byte_t * msg; globus_size_t msgsize; monitor_t monitor; rc = globus_module_activate(GLOBUS_GRAM_PROTOCOL_MODULE); if(rc != GLOBUS_SUCCESS) { return rc; } globus_mutex_init(&monitor.mutex, GLOBUS_NULL); globus_mutex_lock(&monitor.mutex); globus_cond_init(&monitor.cond, GLOBUS_NULL); monitor.done = GLOBUS_FALSE; monitor.status_request[0] = "status"; monitor.status_request[1] = NULL; monitor.job_status[1] = GLOBUS_GRAM_PROTOCOL_JOB_STATE_ACTIVE; monitor.failure_code[1] = 0; monitor.job_failure_code[1] = 0; monitor.error = 0; rc = globus_gram_protocol_allow_attach( &server_callback_contact, server_callback, &monitor); if(rc != GLOBUS_SUCCESS) { goto unlock_error; } rc = globus_gram_protocol_pack_status_request( monitor.status_request[0], &msg, &msgsize); if(rc != GLOBUS_SUCCESS) { goto disallow_error; } if (argc > 1 && !strcmp(argv[1], "invalid_host")) { globus_free(server_callback_contact); server_callback_contact = globus_libc_strdup( "https://bogushost.globus.org:7777/7777"); } rc = globus_gram_protocol_post(server_callback_contact, GLOBUS_NULL, GLOBUS_NULL, msg, msgsize, client_callback, &monitor); if(rc != GLOBUS_SUCCESS) { goto free_msg_error; } while(!monitor.done) { globus_cond_wait(&monitor.cond, &monitor.mutex); } globus_libc_free(msg); globus_mutex_unlock(&monitor.mutex); globus_mutex_destroy(&monitor.mutex); globus_cond_destroy(&monitor.cond); if(monitor.job_status[0] != monitor.job_status[1] || monitor.failure_code[0] != monitor.failure_code[1] || monitor.job_failure_code[0] != monitor.job_failure_code[1] || strcmp(monitor.status_request[0], monitor.status_request[1]) != 0) { fprintf(stderr, "transmission error.\n"); monitor.error++; } globus_libc_free(monitor.status_request[1]); globus_gram_protocol_callback_disallow(server_callback_contact); globus_module_deactivate(GLOBUS_GRAM_PROTOCOL_MODULE); return monitor.error; free_msg_error: globus_libc_free(msg); disallow_error: globus_gram_protocol_callback_disallow(server_callback_contact); unlock_error: globus_mutex_unlock(&monitor.mutex); globus_mutex_destroy(&monitor.mutex); globus_cond_destroy(&monitor.cond); globus_module_deactivate(GLOBUS_GRAM_PROTOCOL_MODULE); return rc; }
int cancel_main( int argc, char ** argv) { int rc; globus_xio_stack_t stack; globus_xio_handle_t handle; globus_result_t res; globus_xio_attr_t attr; int opt_offset; int secs; int usecs; globus_l_closed = GLOBUS_FALSE; rc = globus_module_activate(GLOBUS_XIO_MODULE); globus_assert(rc == 0); res = globus_xio_attr_init(&attr); test_res(GLOBUS_XIO_TEST_FAIL_NONE, res, __LINE__, __FILE__); res = globus_xio_stack_init(&stack, NULL); test_res(GLOBUS_XIO_TEST_FAIL_NONE, res, __LINE__, __FILE__); parse_parameters(argc, argv, stack, attr); GlobusTimeReltimeGet(globus_l_test_info.delay, secs, usecs); if(secs == 0 && usecs < USEC_THRESHHOLD) { fprintf(stderr, "ERROR: delay time must be at least %d usecs.\n", USEC_THRESHHOLD); return 1; } globus_mutex_init(&globus_l_mutex, NULL); globus_cond_init(&globus_l_cond, NULL); res = globus_xio_handle_create(&handle, stack); test_res(GLOBUS_XIO_TEST_FAIL_NONE, res, __LINE__, __FILE__); res = globus_xio_register_open( handle, "whatever", attr, open_cb, argv[argc-1]); test_res(GLOBUS_XIO_TEST_FAIL_NONE, res, __LINE__, __FILE__); if(strcmp(argv[argc-1], "O") == 0) { res = globus_xio_handle_cancel_operations( handle, GLOBUS_XIO_CANCEL_OPEN); } globus_mutex_lock(&globus_l_mutex); { while(!globus_l_closed) { globus_cond_wait(&globus_l_cond, &globus_l_mutex); } } globus_mutex_unlock(&globus_l_mutex); globus_xio_attr_destroy(attr); globus_xio_stack_destroy(stack); test_common_end(); rc = globus_module_deactivate(GLOBUS_XIO_MODULE); globus_assert(rc == 0); fprintf(stdout, "Success.\n"); return 0; }
/* submit a job without a callback contact, register a callback * contact, wait for job to terminate */ int test1() { char * callback_contact; char * job_contact; int rc; monitor_t monitor; rc = globus_module_activate(GLOBUS_GRAM_CLIENT_MODULE); if(rc) { goto out; } globus_mutex_init(&monitor.mutex ,GLOBUS_NULL); globus_cond_init(&monitor.cond, GLOBUS_NULL); monitor.state = GLOBUS_GRAM_PROTOCOL_JOB_STATE_PENDING; rc = globus_gram_client_callback_allow(gram_state_callback, &monitor, &callback_contact); if(rc != GLOBUS_SUCCESS) { fprintf(stderr, "Error creating callback contact %s.\n", globus_gram_client_error_string(rc)); goto error_exit; } globus_mutex_lock(&monitor.mutex); rc = globus_gram_client_job_request( resource_manager_contact, "&(executable=/bin/sleep)(arguments=10)", GLOBUS_GRAM_PROTOCOL_JOB_STATE_ALL, GLOBUS_NULL, &job_contact); if(rc != GLOBUS_SUCCESS) { fprintf(stderr, "Failed submitting job request because %s.\n", globus_gram_client_error_string(rc)); goto destroy_callback_contact; } rc = globus_gram_client_job_callback_register( job_contact, GLOBUS_GRAM_PROTOCOL_JOB_STATE_FAILED| GLOBUS_GRAM_PROTOCOL_JOB_STATE_DONE, callback_contact, &monitor.state, &monitor.errorcode); if(rc != GLOBUS_SUCCESS) { fprintf(stderr, "Error registering callback contact because %s.\n", globus_gram_client_error_string(rc)); goto destroy_callback_contact; } while(monitor.state != GLOBUS_GRAM_PROTOCOL_JOB_STATE_FAILED && monitor.state != GLOBUS_GRAM_PROTOCOL_JOB_STATE_DONE) { globus_cond_wait(&monitor.cond, &monitor.mutex); } rc = monitor.errorcode; destroy_callback_contact: globus_gram_client_callback_disallow(callback_contact); globus_libc_free(callback_contact); globus_libc_free(job_contact); globus_mutex_unlock(&monitor.mutex); error_exit: globus_mutex_destroy(&monitor.mutex); globus_cond_destroy(&monitor.cond); globus_module_deactivate(GLOBUS_GRAM_CLIENT_MODULE); out: return rc; }
int globus_i_xio_win32_complete_deactivate(void) { globus_result_t result; globus_l_shutdown_info_t info; GlobusXIOName(globus_i_xio_win32_complete_deactivate); GlobusXIOSystemDebugEnter(); if (!globus_i_am_only_thread()) { goto skip_deactivate; } globus_mutex_init(&info.mutex, NULL); globus_cond_init(&info.cond, NULL); globus_mutex_lock(&info.mutex); { result = globus_callback_unregister( globus_l_xio_win32_poll_handle, globus_l_xio_win32_unregister_poll_cb, &info, 0); if(result == GLOBUS_SUCCESS) { /* unregister callback destroys this event object */ while(globus_l_xio_win32_poll_event != 0) { globus_cond_wait(&info.cond, &info.mutex); } } else { globus_mutex_unlock(&info.mutex); globus_l_xio_win32_unregister_poll_cb(&info); globus_mutex_lock(&info.mutex); } } globus_mutex_unlock(&info.mutex); globus_cond_destroy(&info.cond); globus_mutex_destroy(&info.mutex); win32_mutex_destroy(&globus_l_xio_win32_poll_lock); while(globus_l_xio_win32_poll_free) { globus_l_xio_win32_poll_entry_t * next = globus_l_xio_win32_poll_free->next; globus_free(globus_l_xio_win32_poll_free); globus_l_xio_win32_poll_free = next; } skip_deactivate: GlobusXIOSystemDebugExit(); return GLOBUS_SUCCESS; }
int main(int argc, char *argv[]) { globus_ftp_client_handle_t handle; globus_ftp_client_operationattr_t attr; globus_byte_t buffer[SIZE]; globus_size_t buffer_length = sizeof(buffer); globus_result_t result; char * src; char * dst; globus_ftp_client_handleattr_t handle_attr; globus_ftp_control_layout_t layout; globus_ftp_control_parallelism_t parallelism; int i; globus_ftp_client_restart_marker_t restart; LTDL_SET_PRELOADED_SYMBOLS(); globus_module_activate(GLOBUS_FTP_CLIENT_MODULE); globus_ftp_client_handleattr_init(&handle_attr); globus_ftp_client_operationattr_init(&attr); layout.mode = GLOBUS_FTP_CONTROL_STRIPING_NONE; parallelism.mode = GLOBUS_FTP_CONTROL_PARALLELISM_NONE; globus_ftp_client_restart_marker_init(&restart); /* Parse local arguments */ for(i = 1; i < argc; i++) { if(strcmp(argv[i], "-S") == 0 && i < argc) { layout.mode = GLOBUS_FTP_CONTROL_STRIPING_BLOCKED_ROUND_ROBIN; layout.round_robin.block_size = 15; test_remove_arg(&argc, argv, &i, 0); } else if(strcmp(argv[i], "-P") == 0 && i + 1 < argc) { parallelism.mode = GLOBUS_FTP_CONTROL_PARALLELISM_FIXED; parallelism.fixed.size = atoi(argv[i+1]); test_remove_arg(&argc, argv, &i, 1); } else if(strcmp(argv[i], "-R") == 0 && i+1 < argc) { char * p; globus_off_t offset, end; int bytes; p = argv[i+1]; while((*p) && (sscanf(p, "%"GLOBUS_OFF_T_FORMAT "-%"GLOBUS_OFF_T_FORMAT"%n", &offset, &end, &bytes) >= 2)) { globus_ftp_client_restart_marker_insert_range( &restart, offset, end); p += bytes; if(*p && *p == ',') p++; } test_remove_arg(&argc, argv, &i, 1); } } test_parse_args(argc, argv, &handle_attr, &attr, &src, &dst); globus_mutex_init(&lock, GLOBUS_NULL); globus_cond_init(&cond, GLOBUS_NULL); globus_ftp_client_operationattr_set_mode( &attr, GLOBUS_FTP_CONTROL_MODE_EXTENDED_BLOCK); globus_ftp_client_operationattr_set_layout(&attr, &layout); globus_ftp_client_operationattr_set_parallelism(&attr, ¶llelism); globus_ftp_client_handle_init(&handle, &handle_attr); done = GLOBUS_FALSE; result = globus_ftp_client_get(&handle, src, &attr, &restart, done_cb, 0); if(result != GLOBUS_SUCCESS) { fprintf(stderr, "%s", globus_object_printable_to_string(globus_error_get(result))); done = GLOBUS_TRUE; error = GLOBUS_TRUE; } else { globus_ftp_client_register_read( &handle, buffer, buffer_length, data_cb, 0); } globus_mutex_lock(&lock); while(!done) { globus_cond_wait(&cond, &lock); } globus_mutex_unlock(&lock); globus_ftp_client_handle_destroy(&handle); globus_module_deactivate_all(); if(test_abort_count && error) { return 0; } return error; }
void ADIOI_GRIDFTP_ReadContig(ADIO_File fd, void *buf, int count, MPI_Datatype datatype, int file_ptr_type, ADIO_Offset offset, ADIO_Status *status, int *error_code) { static char myname[]="ADIOI_GRIDFTP_ReadContig"; int myrank, nprocs, datatype_size; globus_size_t len,bytes_read=0; globus_off_t goff; globus_result_t result; if ( fd->access_mode&MPI_MODE_WRONLY ) { *error_code=MPIR_ERR_MODE_WRONLY; return; } *error_code = MPI_SUCCESS; MPI_Comm_size(fd->comm, &nprocs); MPI_Comm_rank(fd->comm, &myrank); MPI_Type_size(datatype, &datatype_size); if (file_ptr_type != ADIO_EXPLICIT_OFFSET) { offset = fd->fp_ind; } /* Do the gridftp I/O transfer */ goff = (globus_off_t)offset; len = ((globus_size_t)datatype_size)*((globus_size_t)count); globus_mutex_init(&readcontig_ctl_lock, GLOBUS_NULL); globus_cond_init(&readcontig_ctl_cond, GLOBUS_NULL); readcontig_ctl_done=GLOBUS_FALSE; if ( (result=globus_ftp_client_partial_get(&(gridftp_fh[fd->fd_sys]), fd->filename, &(oattr[fd->fd_sys]), GLOBUS_NULL, goff, goff+(globus_off_t)len, readcontig_ctl_cb, GLOBUS_NULL))!=GLOBUS_SUCCESS ) { globus_err_handler("globus_ftp_client_partial_get",myname,result); *error_code=MPI_ERR_IO; ADIOI_Error(fd,*error_code,myname); return; } result=globus_ftp_client_register_read(&(gridftp_fh[fd->fd_sys]), (globus_byte_t *)buf, len, readcontig_data_cb, (void *)(&bytes_read)); if ( result != GLOBUS_SUCCESS ) { globus_err_handler("globus_ftp_client_register_read",myname,result); *error_code = MPIO_Err_create_code(MPI_SUCCESS, MPIR_ERR_RECOVERABLE, myname, __LINE__, MPI_ERR_IO, "**io", "**io %s", globus_object_printable_to_string(result)); return; } /* The ctl callback won't start till the data callbacks complete, so it's safe to wait on just the ctl callback */ globus_mutex_lock(&readcontig_ctl_lock); while ( readcontig_ctl_done!=GLOBUS_TRUE ) globus_cond_wait(&readcontig_ctl_cond,&readcontig_ctl_lock); globus_mutex_unlock(&readcontig_ctl_lock); globus_mutex_destroy(&readcontig_ctl_lock); globus_cond_destroy(&readcontig_ctl_cond); #ifdef HAVE_STATUS_SET_BYTES MPIR_Status_set_bytes(status, datatype, bytes_read); #endif if (file_ptr_type != ADIO_EXPLICIT_OFFSET) { fd->fp_ind += bytes_read; fd->fp_sys_posn = fd->fp_ind; } else { fd->fp_sys_posn = offset + bytes_read; } }
int main(int argc, char **argv) { globus_ftp_client_handle_t handle; globus_ftp_client_operationattr_t attr; globus_byte_t buffer[1024]; globus_size_t buffer_length = sizeof(buffer); globus_result_t result; globus_ftp_client_handleattr_t handle_attr; char * src; char * dst; globus_module_activate(GLOBUS_FTP_CLIENT_MODULE); globus_ftp_client_handleattr_init(&handle_attr); globus_ftp_client_operationattr_init(&attr); test_parse_args(argc, argv, &handle_attr, &attr, &src, &dst); globus_mutex_init(&lock, GLOBUS_NULL); globus_cond_init(&cond, GLOBUS_NULL); globus_ftp_client_handle_init(&handle, &handle_attr); done = GLOBUS_FALSE; result = globus_ftp_client_get(&handle, src, &attr, GLOBUS_NULL, done_cb, 0); if(result != GLOBUS_SUCCESS) { done = GLOBUS_TRUE; } else { globus_ftp_client_register_read( &handle, (globus_byte_t *) 0x1, buffer_length, data_cb, 0); globus_ftp_client_register_read( &handle, (globus_byte_t *) 0x0, buffer_length, data_cb, 0); } globus_mutex_lock(&lock); globus_poll(); globus_ftp_client_register_read( &handle, (globus_byte_t *) 0x3, buffer_length, data_cb, 0); while(!done) { globus_cond_wait(&cond, &lock); } globus_mutex_unlock(&lock); globus_ftp_client_handle_destroy(&handle); globus_module_deactivate_all(); return 0; }
int main(int argc, char *argv[]) { globus_ftp_client_handle_t handle; globus_ftp_client_operationattr_t attr; globus_byte_t buffer[SIZE]; globus_size_t buffer_length = sizeof(buffer); globus_result_t result; char * src; char * dst; globus_ftp_client_handleattr_t handle_attr; globus_off_t start_offset=5; globus_off_t end_offset=15; int i; globus_ftp_control_mode_t mode; globus_module_activate(GLOBUS_FTP_CLIENT_MODULE); globus_ftp_client_handleattr_init(&handle_attr); globus_ftp_client_operationattr_init(&attr); mode = GLOBUS_FTP_CONTROL_MODE_STREAM; /* Parse local arguments */ for(i = 1; i < argc; i++) { if(strcmp(argv[i], "-R") == 0 && i + 2 < argc) { globus_libc_scan_off_t(argv[i+1], &start_offset, GLOBUS_NULL); globus_libc_scan_off_t(argv[i+2], &end_offset, GLOBUS_NULL); test_remove_arg(&argc, argv, &i, 2); } else if(strcmp(argv[i], "-E") == 0 && i < argc) { mode = GLOBUS_FTP_CONTROL_MODE_EXTENDED_BLOCK; test_remove_arg(&argc, argv, &i, 0); } } test_parse_args(argc, argv, &handle_attr, &attr, &src, &dst); if(start_offset < 0) start_offset = 0; if(end_offset < 0) end_offset = 0; globus_mutex_init(&lock, GLOBUS_NULL); globus_cond_init(&cond, GLOBUS_NULL); globus_ftp_client_handle_init(&handle, &handle_attr); globus_ftp_client_operationattr_set_mode(&attr, mode); done = GLOBUS_FALSE; result = globus_ftp_client_partial_get(&handle, src, &attr, GLOBUS_NULL, start_offset, end_offset, done_cb, 0); if(result != GLOBUS_SUCCESS) { error = GLOBUS_TRUE; done = GLOBUS_TRUE; } else { globus_ftp_client_register_read( &handle, buffer, buffer_length, data_cb, 0); } globus_mutex_lock(&lock); while(!done) { globus_cond_wait(&cond, &lock); } globus_mutex_unlock(&lock); globus_ftp_client_handle_destroy(&handle); globus_module_deactivate_all(); if(test_abort_count && error) { return 0; } return error; }