int main(int argc, char * argv[]) { globus_ftp_client_handle_t handle; globus_ftp_client_operationattr_t attr; 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); globus_mutex_init(&lock, GLOBUS_NULL); globus_cond_init(&cond, GLOBUS_NULL); test_parse_args(argc, argv, &handle_attr, &attr, &src, &dst); globus_ftp_client_operationattr_set_type(&attr, GLOBUS_FTP_CONTROL_TYPE_ASCII); globus_ftp_client_handle_init(&handle, &handle_attr); done = GLOBUS_FALSE; result = globus_ftp_client_symlink(&handle, src, dst, &attr, done_cb, 0); if(result != GLOBUS_SUCCESS) { 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; } return error; }
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; char * src; char * dst; globus_ftp_client_handleattr_t handle_attr; 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_get(&handle, src, &attr, GLOBUS_NULL, done_cb, 0); globus_module_deactivate_all(); return done; }
int main(int argc, char *argv[]) { globus_ftp_client_handle_t handle; globus_ftp_client_operationattr_t attr; globus_byte_t * buffer; globus_size_t buffer_length; globus_result_t result; char * src; char * dst; globus_ftp_client_handleattr_t handle_attr; globus_ftp_control_mode_t mode; int i; globus_ftp_control_parallelism_t parallelism; globus_module_activate(GLOBUS_FTP_CLIENT_MODULE); globus_ftp_client_handleattr_init(&handle_attr); globus_ftp_client_operationattr_init(&attr); parallelism.mode = GLOBUS_FTP_CONTROL_PARALLELISM_FIXED; parallelism.fixed.size = 1; mode = GLOBUS_FTP_CONTROL_MODE_STREAM; for(i = 1; i < argc; i++) { if(strcmp(argv[i], "-P") == 0 && i + 1 < argc) { mode = GLOBUS_FTP_CONTROL_MODE_EXTENDED_BLOCK; parallelism.mode = GLOBUS_FTP_CONTROL_PARALLELISM_FIXED; parallelism.fixed.size = atoi(argv[i+1]); test_remove_arg(&argc, argv, &i, 1); } } test_parse_args(argc, argv, &handle_attr, &attr, &src, &dst); buffer = globus_libc_malloc(SIZE); buffer_length = SIZE; globus_mutex_init(&lock, GLOBUS_NULL); globus_cond_init(&cond, GLOBUS_NULL); globus_ftp_client_operationattr_set_mode(&attr, mode); globus_ftp_client_operationattr_set_parallelism(&attr, ¶llelism); globus_ftp_client_operationattr_set_read_all(&attr, GLOBUS_TRUE, intermediate_cb, 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) { fprintf(stderr, globus_object_printable_to_string(globus_error_get(result))); 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_libc_free(buffer); globus_module_deactivate_all(); if(test_abort_count && error) { return 0; } return error; }
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_off_t size; 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_size(&handle, src, &attr, &size, 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) { printf("%"GLOBUS_OFF_T_FORMAT"\n", size); } return error; }
int main(int argc, char **argv) { globus_ftp_client_handle_t handle; globus_ftp_client_operationattr_t attr; globus_result_t result; globus_ftp_client_handleattr_t handle_attr; char * src; char * dst; LTDL_SET_PRELOADED_SYMBOLS(); 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); test_parse_args(argc, argv, &handle_attr, &attr, &src, &dst); globus_ftp_client_handle_init(&handle, &handle_attr); done = GLOBUS_FALSE; result = globus_ftp_client_third_party_transfer(&handle, src, &attr, dst, &attr, GLOBUS_NULL, done_cb, 0); if(result != GLOBUS_SUCCESS) { globus_object_t * err; char * tmpstr; err = globus_error_get(result); tmpstr = globus_object_printable_to_string(err); fprintf(stderr, "Error: %s", tmpstr); globus_object_free(err); globus_libc_free(tmpstr); 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; } return error; }
int main(int argc, char **argv) { globus_ftp_client_handle_t handle; globus_ftp_client_operationattr_t attr; globus_result_t result; int i; globus_ftp_client_handleattr_t handle_attr; 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); globus_mutex_init(&lock, GLOBUS_NULL); globus_cond_init(&cond, GLOBUS_NULL); test_parse_args(argc, argv, &handle_attr, &attr, &src, &dst); globus_ftp_client_handle_init(&handle, &handle_attr); globus_ftp_client_handle_cache_url_state(&handle, src); globus_ftp_client_handle_cache_url_state(&handle, dst); for (i = 0; i < 2; i++) { done = GLOBUS_FALSE; result = globus_ftp_client_third_party_transfer(&handle, src, &attr, dst, &attr, GLOBUS_NULL, done_cb, 0); if(result != GLOBUS_SUCCESS) { 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; } return error; }
int main() { int rc = 0; int count=0; globus_ftp_client_handle_t handle; globus_ftp_client_plugin_t restart_plugin; globus_ftp_client_plugin_t debug_plugin; globus_result_t result; globus_ftp_client_handleattr_t handleattr; globus_module_activate(GLOBUS_FTP_CLIENT_MODULE); globus_module_activate(GLOBUS_FTP_CLIENT_RESTART_PLUGIN_MODULE); globus_module_activate(GLOBUS_FTP_CLIENT_DEBUG_PLUGIN_MODULE); /* Test using attributes */ result = globus_ftp_client_handleattr_init(&handleattr); globus_assert(result == GLOBUS_SUCCESS); result = globus_ftp_client_restart_plugin_init( &restart_plugin, 0, GLOBUS_NULL, GLOBUS_NULL); globus_assert(result == GLOBUS_SUCCESS); result = globus_ftp_client_debug_plugin_init( &debug_plugin, stderr, "hello"); globus_assert(result == GLOBUS_SUCCESS); /* Test 1: insert restart plugin into handle attr */ count++; result = globus_ftp_client_handleattr_add_plugin(&handleattr, &restart_plugin); if(result != GLOBUS_SUCCESS) { printf("Failed test %d\n", count); rc++; } /* Test 2: insert restart plugin into handle attr (fail) */ count++; result = globus_ftp_client_handleattr_add_plugin(&handleattr, &restart_plugin); if(result == GLOBUS_SUCCESS) { printf("Failed test %d\n", count); rc++; } /* Test 3: create/destroy handle with attr */ count++; result = globus_ftp_client_handle_init(&handle, &handleattr); if(result != GLOBUS_SUCCESS) { printf("Failed test %d\n", count); rc++; } else if(globus_ftp_client_handle_destroy(&handle) != GLOBUS_SUCCESS) { printf("Failed test %d\n", count); rc++; } /* Test 4: insert debug plugin into handle attr */ count++; result = globus_ftp_client_handleattr_add_plugin(&handleattr, &debug_plugin); if(result != GLOBUS_SUCCESS) { printf("Failed test %d\n", count); rc++; } /* Test 5: create/destroy handle with attr */ count++; result = globus_ftp_client_handle_init(&handle, &handleattr); if(result != GLOBUS_SUCCESS) { printf("Failed test %d\n", count); rc++; } else if(globus_ftp_client_handle_destroy(&handle) != GLOBUS_SUCCESS) { printf("Failed test %d\n", count); rc++; } /* Test 6: remove restart plugin from handle attr */ count++; result = globus_ftp_client_handleattr_remove_plugin(&handleattr, &restart_plugin); if(result != GLOBUS_SUCCESS) { printf("Failed test %d\n", count); rc++; } /* Test 7: remove restart plugin from handle attr (fail) */ count++; result = globus_ftp_client_handleattr_remove_plugin(&handleattr, &restart_plugin); if(result == GLOBUS_SUCCESS) { printf("Failed test %d\n", count); rc++; } /* Test 8: insert debug plugin into handle attr (fail) */ count++; result = globus_ftp_client_handleattr_add_plugin(&handleattr, &debug_plugin); if(result == GLOBUS_SUCCESS) { printf("Failed test %d\n", count); rc++; } /* Test 9: remove debug plugin from handle attr */ count++; result = globus_ftp_client_handleattr_remove_plugin(&handleattr, &debug_plugin); if(result != GLOBUS_SUCCESS) { printf("Failed test %d\n", count); rc++; } /* Test 10: remove restart plugin from handle attr (fail) */ count++; result = globus_ftp_client_handleattr_remove_plugin(&handleattr, &restart_plugin); if(result == GLOBUS_SUCCESS) { printf("Failed test %d\n", count); rc++; } /* Test 11: create/destroy handle with attr */ count++; result = globus_ftp_client_handle_init(&handle, &handleattr); if(result != GLOBUS_SUCCESS) { printf("Failed test %d\n", count); rc++; } else if(globus_ftp_client_handle_destroy(&handle) != GLOBUS_SUCCESS) { printf("Failed test %d\n", count); rc++; } /* Test without attributes */ /* Test 12: create handle without attr */ count++; result = globus_ftp_client_handle_init(&handle, GLOBUS_NULL); if(result != GLOBUS_SUCCESS) { printf("Failed test %d\n", count); rc++; } /* Test 13: add restart plugin into handle */ count++; result = globus_ftp_client_handle_add_plugin(&handle, &restart_plugin); if(result != GLOBUS_SUCCESS) { printf("Failed test %d\n", count); rc++; } /* Test 14: add restart plugin into handle (fail) */ count++; result = globus_ftp_client_handle_add_plugin(&handle, &restart_plugin); if(result == GLOBUS_SUCCESS) { printf("Failed test %d\n", count); rc++; } /* Test 15: add debug plugin into handle */ count++; result = globus_ftp_client_handle_add_plugin(&handle, &debug_plugin); if(result != GLOBUS_SUCCESS) { printf("Failed test %d\n", count); rc++; } /* Test 16: remove restart plugin from handle */ count++; result = globus_ftp_client_handle_remove_plugin(&handle, &restart_plugin); if(result != GLOBUS_SUCCESS) { printf("Failed test %d\n", count); rc++; } /* Test 17: remove restart plugin from handle (fail) */ count++; result = globus_ftp_client_handle_remove_plugin(&handle, &restart_plugin); if(result == GLOBUS_SUCCESS) { printf("Failed test %d\n", count); rc++; } /* Test 18: add debug plugin into handle (fail) */ count++; result = globus_ftp_client_handle_add_plugin(&handle, &debug_plugin); if(result == GLOBUS_SUCCESS) { printf("Failed test %d\n", count); rc++; } /* Test 19: remove debug plugin into handle */ count++; result = globus_ftp_client_handle_remove_plugin(&handle, &debug_plugin); if(result != GLOBUS_SUCCESS) { printf("Failed test %d\n", count); rc++; } /* Test 20: remove restart plugin into handle (fail) */ count++; result = globus_ftp_client_handle_remove_plugin(&handle, &restart_plugin); if(result == GLOBUS_SUCCESS) { printf("Failed test %d\n", count); rc++; } /* Test 21: destroy handle */ count++; result = globus_ftp_client_handle_destroy(&handle); if(result != GLOBUS_SUCCESS) { printf("Failed test %d\n", count); rc++; } globus_module_deactivate_all(); return rc; }
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; 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 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; }
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) { 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; }
int gw_tm_ftp_transfer_init (gw_tm_ftp_transfer_t *xfr, int jid) { globus_result_t grc; grc = globus_ftp_client_handleattr_init (&(xfr->attr)); if ( grc != GLOBUS_SUCCESS ) return -1; grc = globus_ftp_client_handleattr_set_cache_all (&(xfr->attr), GLOBUS_TRUE); if ( grc != GLOBUS_SUCCESS ) return -1; grc = globus_ftp_client_handle_init (&(xfr->handle),&(xfr->attr)); if ( grc != GLOBUS_SUCCESS ) return -1; grc = globus_ftp_client_operationattr_init (&(xfr->op_attr)); if ( grc != GLOBUS_SUCCESS ) return -1; grc = globus_gass_copy_attr_init (&(xfr->gass_attr)); if ( grc != GLOBUS_SUCCESS ) return -1; grc = globus_gass_copy_attr_init (&(xfr->src_gass_attr)); if ( grc != GLOBUS_SUCCESS ) return -1; grc = globus_ftp_client_operationattr_init (&(xfr->src_op_attr)); if ( grc != GLOBUS_SUCCESS ) return -1; grc = globus_gass_copy_attr_set_ftp (&(xfr->gass_attr), &(xfr->op_attr)); if ( grc != GLOBUS_SUCCESS ) return -1; grc = globus_gass_copy_attr_set_ftp (&(xfr->src_gass_attr), &(xfr->src_op_attr)); if ( grc != GLOBUS_SUCCESS ) return -1; grc = globus_gass_copy_handleattr_init(&(xfr->gass_handel_attr)); if ( grc != GLOBUS_SUCCESS ) return -1; grc = globus_gass_copy_handle_init (&(xfr->gass_handle), &(xfr->gass_handel_attr)); if ( grc != GLOBUS_SUCCESS ) return -1; grc = globus_gass_copy_set_no_third_party_transfers (&(xfr->gass_handle), GLOBUS_FALSE); if ( grc != GLOBUS_SUCCESS ) return -1; xfr->jid = jid; xfr->handle_in_use = GW_FALSE; xfr->base_dir = NULL; xfr->list_buffer = NULL; xfr->buffer_length = 0; xfr->read_buffer = (globus_byte_t *) malloc( GW_TM_FTP_BUFFER_LENGTH * sizeof(globus_byte_t)); xfr->current_xfr.dst_url = NULL; xfr->current_xfr.src_url = NULL; xfr->current_xfr.cp_xfr_id = 0; gw_tm_ftp_stack_init(&(xfr->file_stack)); gw_tm_ftp_queue_init(&(xfr->url_queue)); return 0; }
int main(int argc, char * argv[]) { globus_ftp_client_handle_t handle; globus_ftp_client_operationattr_t attr; globus_result_t result; globus_ftp_client_handleattr_t handle_attr; char * src = NULL; char * dst = NULL; struct tm modtime; extern char * optarg; extern int optind; int c; globus_module_activate(GLOBUS_FTP_CLIENT_MODULE); globus_ftp_client_handleattr_init(&handle_attr); globus_ftp_client_operationattr_init(&attr); globus_mutex_init(&lock, GLOBUS_NULL); globus_cond_init(&cond, GLOBUS_NULL); test_parse_args(argc, argv, &handle_attr, &attr, &src, &dst); optind = 1; while((c = getopt(argc, argv, "T:")) != -1) { switch(c) { case 'T': memset(&modtime, 0, sizeof(modtime)); if (sscanf(optarg, "%4d%2d%2d%2d%2d%2d", &modtime.tm_year, &modtime.tm_mon, &modtime.tm_mday, &modtime.tm_hour, &modtime.tm_min, &modtime.tm_sec) != 6) { printf("Invalid time format\n"); return GLOBUS_TRUE; } modtime.tm_year -= 1900; modtime.tm_mon -= 1; break; } } globus_ftp_client_operationattr_set_type(&attr, GLOBUS_FTP_CONTROL_TYPE_ASCII); globus_ftp_client_handleattr_set_cache_all(&handle_attr, GLOBUS_TRUE); globus_ftp_client_handle_init(&handle, &handle_attr); done = GLOBUS_FALSE; result = globus_ftp_client_utime(&handle, src, &modtime, &attr, done_cb, 0); if(result != GLOBUS_SUCCESS) { 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; } return error; }
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_Open(ADIO_File fd, int *error_code) { static char myname[]="ADIOI_GRIDFTP_Open"; int myrank, nprocs, keyfound; char hintval[MPI_MAX_INFO_VAL+1]; globus_ftp_client_handleattr_t hattr; globus_result_t result; MPI_Comm_size(fd->comm, &nprocs); MPI_Comm_rank(fd->comm, &myrank); /* activate Globus ftp client module -- can be called multiple times, so it's safest to call once per file/connection */ globus_module_activate(GLOBUS_FTP_CLIENT_MODULE); fd->fd_sys = num_gridftp_handles; /* No shared file pointers for now */ fd->shared_fp_fname = NULL; *error_code = MPI_SUCCESS; /* Access modes here mean something very different here than they would on a "real" filesystem... As a result, the amode and hint processing here is intermingled and a little weird because many of them have to do with the connection rather than the file itself. The thing that sucks about this is that read and write ops will have to check themselves if the file is being accessed rdonly, rdwr, or wronly. */ result=globus_ftp_client_handleattr_init(&hattr); if ( result != GLOBUS_SUCCESS ) { globus_err_handler("globus_ftp_client_handleattr_init", myname,result); fd->fd_sys = -1; *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; } result = globus_ftp_client_operationattr_init(&(oattr[fd->fd_sys])); if ( result != GLOBUS_SUCCESS ) { globus_err_handler("globus_ftp_client_operationattr_init", myname,result); fd->fd_sys = -1; *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; } /* Always use connection caching unless told otherwise */ result=globus_ftp_client_handleattr_set_cache_all(&hattr,GLOBUS_TRUE); if ( result !=GLOBUS_SUCCESS ) globus_err_handler("globus_ftp_client_handleattr_set_cache_all",myname,result); /* Assume that it's safe to cache a file if it's read-only */ if ( (fd->access_mode&ADIO_RDONLY) && (result=globus_ftp_client_handleattr_add_cached_url(&hattr,fd->filename))!=GLOBUS_SUCCESS ) globus_err_handler("globus_ftp_client_handleattr_add_cached_url",myname,result); /* Since we're (almost by definition) doing things that FTP S (stream) control mode can't handle, default to E (extended block) control mode for gsiftp:// URLs. ftp:// URLs use standard stream control mode by default. This behavior can be overridden by the ftp_control_mode hint. */ /* if ( !strncmp(fd->filename,"gsiftp:",7) && (result=globus_ftp_client_operationattr_set_mode(&(oattr[fd->fd_sys]),GLOBUS_FTP_CONTROL_MODE_EXTENDED_BLOCK))!=GLOBUS_SUCCESS ) globus_err_handler("globus_ftp_client_operationattr_set_mode",myname,result); else if ( !strncmp(fd->filename,"ftp:",4) && (result=globus_ftp_client_operationattr_set_mode(&(oattr[fd->fd_sys]),GLOBUS_FTP_CONTROL_MODE_STREAM))!=GLOBUS_SUCCESS ) globus_err_handler("globus_ftp_client_operationattr_set_mode",myname,result); */ /* Set append mode if necessary */ if ( (fd->access_mode&ADIO_APPEND) && ((result=globus_ftp_client_operationattr_set_append(&(oattr[fd->fd_sys]),GLOBUS_TRUE))!=GLOBUS_SUCCESS) ) globus_err_handler("globus_ftp_client_operationattr_set_append",myname,result); /* Other hint and amode processing that would affect hattr and/or oattr[] (eg. parallelism, striping, etc.) goes here */ if ( fd->info!=MPI_INFO_NULL ) { ADIOI_Info_get(fd->info,"ftp_control_mode",MPI_MAX_INFO_VAL,hintval,&keyfound); if ( keyfound ) { if ( ( !strcmp(hintval,"extended") || !strcmp(hintval,"extended_block") ) && (result=globus_ftp_client_operationattr_set_mode(&(oattr[fd->fd_sys]),GLOBUS_FTP_CONTROL_MODE_EXTENDED_BLOCK))!=GLOBUS_SUCCESS ) globus_err_handler("globus_ftp_client_operationattr_set_mode",myname,result); else if ( !strcmp(hintval,"block") && (result=globus_ftp_client_operationattr_set_mode(&(oattr[fd->fd_sys]),GLOBUS_FTP_CONTROL_MODE_BLOCK))!=GLOBUS_SUCCESS ) globus_err_handler("globus_ftp_client_operationattr_set_mode",myname,result); else if ( !strcmp(hintval,"compressed") && (result=globus_ftp_client_operationattr_set_mode(&(oattr[fd->fd_sys]),GLOBUS_FTP_CONTROL_MODE_COMPRESSED))!=GLOBUS_SUCCESS ) globus_err_handler("globus_ftp_client_operationattr_set_mode",myname,result); else if ( !strcmp(hintval,"stream") && (result=globus_ftp_client_operationattr_set_mode(&(oattr[fd->fd_sys]),GLOBUS_FTP_CONTROL_MODE_STREAM))!=GLOBUS_SUCCESS ) globus_err_handler("globus_ftp_client_operationattr_set_mode",myname,result); } ADIOI_Info_get(fd->info,"parallelism",MPI_MAX_INFO_VAL,hintval,&keyfound); if ( keyfound ) { int nftpthreads; if ( sscanf(hintval,"%d",&nftpthreads)==1 ) { globus_ftp_control_parallelism_t parallelism; parallelism.mode = GLOBUS_FTP_CONTROL_PARALLELISM_FIXED; parallelism.fixed.size = nftpthreads; if ( (result=globus_ftp_client_operationattr_set_parallelism(&(oattr[fd->fd_sys]), ¶llelism))!=GLOBUS_SUCCESS ) globus_err_handler("globus_ftp_client_operationattr_set_parallelism",myname,result); } } ADIOI_Info_get(fd->info,"striped_ftp",MPI_MAX_INFO_VAL,hintval,&keyfound); if ( keyfound ) { /* if set to "true" or "enable", set up round-robin block layout */ if ( !strncmp("true",hintval,4) || !strncmp("TRUE",hintval,4) || !strncmp("enable",hintval,4) || !strncmp("ENABLE",hintval,4) ) { ADIOI_Info_get(fd->info,"striping_factor",MPI_MAX_INFO_VAL,hintval,&keyfound); if ( keyfound ) { int striping_factor; if ( sscanf(hintval,"%d",&striping_factor)==1 ) { globus_ftp_control_layout_t layout; layout.mode = GLOBUS_FTP_CONTROL_STRIPING_BLOCKED_ROUND_ROBIN; layout.round_robin.block_size = striping_factor; if ( (result=globus_ftp_client_operationattr_set_layout(&(oattr[fd->fd_sys]), &layout))!=GLOBUS_SUCCESS ) globus_err_handler("globus_ftp_client_operationattr_set_layout", myname,result); } } } } ADIOI_Info_get(fd->info,"tcp_buffer",MPI_MAX_INFO_VAL,hintval,&keyfound); if ( keyfound ) { /* set tcp buffer size */ int buffer_size; if ( sscanf(hintval,"%d",&buffer_size)==1 ) { globus_ftp_control_tcpbuffer_t tcpbuf; tcpbuf.mode = GLOBUS_FTP_CONTROL_TCPBUFFER_FIXED; tcpbuf.fixed.size = buffer_size; if ( (result=globus_ftp_client_operationattr_set_tcp_buffer(&(oattr[fd->fd_sys]), &tcpbuf))!=GLOBUS_SUCCESS ) globus_err_handler("globus_ftp_client_operationattr_set_tcp_buffer",myname,result); } } ADIOI_Info_get(fd->info,"transfer_type",MPI_MAX_INFO_VAL,hintval,&keyfound); if ( keyfound ) { globus_ftp_control_type_t filetype; /* set transfer type (i.e. ASCII or binary) */ if ( !strcmp("ascii",hintval) || !strcmp("ASCII",hintval) ) { filetype=GLOBUS_FTP_CONTROL_TYPE_ASCII; } else { filetype=GLOBUS_FTP_CONTROL_TYPE_IMAGE; } if ( (result=globus_ftp_client_operationattr_set_type(&(oattr[fd->fd_sys]),filetype))!=GLOBUS_SUCCESS ) globus_err_handler("globus_ftp_client_operationattr_set_type",myname,result); } } else FPRINTF(stderr,"no MPI_Info object associated with %s\n",fd->filename); /* Create the ftp handle */ result=globus_ftp_client_handle_init(&(gridftp_fh[fd->fd_sys]),&hattr); if ( result != GLOBUS_SUCCESS ) { globus_err_handler("globus_ftp_client_handle_init",myname,result); fd->fd_sys = -1; *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; } /* Check for existence of the file */ globus_mutex_init(&lock, GLOBUS_NULL); globus_cond_init(&cond, GLOBUS_NULL); file_exists=GLOBUS_FALSE; exists_done=GLOBUS_FALSE; if ( myrank==0 ) { if ( (result=globus_ftp_client_exists(&(gridftp_fh[fd->fd_sys]), fd->filename, &(oattr[fd->fd_sys]), exists_cb, GLOBUS_NULL))!=GLOBUS_SUCCESS ) { globus_err_handler("globus_ftp_client_exists",myname,result); fd->fd_sys = -1; *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; } /* wait till the callback completes */ globus_mutex_lock(&lock); while ( exists_done!=GLOBUS_TRUE ) globus_cond_wait(&cond,&lock); globus_mutex_unlock(&lock); } MPI_Barrier(fd->comm); MPI_Bcast(&file_exists,1,MPI_INT,0,fd->comm); /* It turns out that this is handled by MPI_File_open() directly */ if ( (file_exists!=GLOBUS_TRUE) && (fd->access_mode&ADIO_CREATE) && !(fd->access_mode&ADIO_EXCL) && !(fd->access_mode&ADIO_RDONLY) ) { if ( myrank==0 ) { /* if the file doesn't exist, write a single NULL to it */ globus_byte_t touchbuf=(globus_byte_t)'\0'; touch_ctl_done=GLOBUS_FALSE; if ( (result=globus_ftp_client_put(&(gridftp_fh[fd->fd_sys]), fd->filename, &(oattr[fd->fd_sys]), GLOBUS_NULL, touch_ctl_cb, GLOBUS_NULL))!=GLOBUS_SUCCESS ) { globus_err_handler("globus_ftp_client_put",myname,result); fd->fd_sys = -1; *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; } result=globus_ftp_client_register_write(&(gridftp_fh[fd->fd_sys]), (globus_byte_t *)&touchbuf, 0, (globus_off_t)0, GLOBUS_TRUE, touch_data_cb, GLOBUS_NULL); if ( result != GLOBUS_SUCCESS ) { globus_err_handler("globus_ftp_client_register_write",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 ( touch_ctl_done!=GLOBUS_TRUE ) globus_cond_wait(&cond,&lock); globus_mutex_unlock(&lock); } MPI_Barrier(fd->comm); } else if ( (fd->access_mode&ADIO_EXCL) && (file_exists==GLOBUS_TRUE) ) { fd->fd_sys = -1; *error_code = MPIO_Err_create_code(MPI_SUCCESS, MPIR_ERR_RECOVERABLE, myname, __LINE__, MPI_ERR_IO, "**io", 0); return; } else if ( (fd->access_mode&ADIO_RDONLY) && (file_exists!=GLOBUS_TRUE) ) { if ( myrank==0 ) { FPRINTF(stderr,"WARNING: read-only file %s does not exist!\n",fd->filename); } } num_gridftp_handles++; }
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; }