// gridFTP open is restricted by the protocol : READ or Write but not both
//
gfal_file_handle GridFTPModule::open(const char* url, int flag, mode_t mode)
{
GridFTPSessionHandler *handler = new GridFTPSessionHandler(_handle_factory, url);
GridFTPStreamState* stream = new GridFTPStreamState(handler);
GridFTPRequestState* request = new GridFTPRequestState(handler);
std::auto_ptr<GridFTPFileDesc> desc(new GridFTPFileDesc(handler, request, stream, url, flag));
gfal_log(GFAL_VERBOSE_TRACE, " -> [GridFTPModule::open] ");
globus_result_t res;
// check ENOENT condition for R_ONLY
if (is_read_only(desc->open_flags) && this->exists(url) == false) {
char err_buff[2048];
snprintf(err_buff, 2048, " gridftp open error : %s on url %s", strerror(ENOENT), url);
throw Gfal::CoreException(GFAL_GRIDFTP_SCOPE_OPEN, err_buff, ENOENT);
}
if (is_read_only(desc->open_flags)) {
gfal_log(GFAL_VERBOSE_TRACE, " -> initialize FTP GET global operations... ");
res = globus_ftp_client_get(
desc->stream->handler->get_ftp_client_handle(), url,
desc->stream->handler->get_ftp_client_operationattr(),
NULL, globus_ftp_client_done_callback, desc->request);
gfal_globus_check_result(GFAL_GRIDFTP_SCOPE_OPEN, res);
}
else if (is_write_only(desc->open_flags)) {
gfal_log(GFAL_VERBOSE_TRACE,
" -> initialize FTP PUT global operations ... ");
res = globus_ftp_client_put(
desc->stream->handler->get_ftp_client_handle(), url,
desc->stream->handler->get_ftp_client_operationattr(),
NULL, globus_ftp_client_done_callback, desc->request);
gfal_globus_check_result(GFAL_GRIDFTP_SCOPE_OPEN, res);
}
else {
gfal_log(GFAL_VERBOSE_TRACE,
" -> no operation initialization, switch to partial read/write mode...");
desc->reset();
}
gfal_log(GFAL_VERBOSE_TRACE, " <- [GridFTPModule::open] ");
return gfal_file_handle_new2(gridftp_plugin_name(), (gpointer) desc.release(), NULL, url);
}
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_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_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;
}
int gsiftp_get(char *filename, FILE **gsiftpfile, int num_streams)
{
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[MAX_BUFFER_SIZE_R];
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_get)");
return (FILE_NOT_OPENED);
}
strcat(gsiurl,filename);
*gsiftpfile = fopen(gsiftp_tmpfile,"w+");
if (!*gsiftpfile) {
ffpmsg("Unable to open temporary file!");
return (FILE_NOT_OPENED);
}
result = globus_ftp_client_get(&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 {
globus_ftp_client_register_read(&handle,
buffer,
buffer_length,
data_cb_read,
(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[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;
}
