← Back to branch summary

~ubuntu-branches/ubuntu/vivid/cctools/vivid

« back to all changes in this revision

Viewing changes to parrot/src/pfs_service_gfal.cc

  • Committer: Bazaar Package Importer
  • Author(s): Michael Hanke
  • Date: 2011-05-07 09:05:00 UTC
  • Revision ID: james.westby@ubuntu.com-20110507090500-lqpmdtwndor6e7os
Tags: upstream-3.3.2
Import upstream version 3.3.2

Show diffs side-by-side

added added

removed removed

Lines of Context:
parrot/src/pfs_service_gfal.cc
 
1
/*
 
2
Copyright (C) 2003-2004 Douglas Thain and the University of Wisconsin
 
3
Copyright (C) 2005- The University of Notre Dame
 
4
This software is distributed under the GNU General Public License.
 
5
See the file COPYING for details.
 
6
*/
 
7
 
 
8
/*
 
9
Note that this module supports a variety of URLs,
 
10
all implemented by the EGEE GFAL library.
 
11
*/
 
12
 
 
13
#ifdef HAS_EGEE
 
14
 
 
15
#include "pfs_table.h"
 
16
#include "pfs_service.h"
 
17
 
 
18
extern "C" {
 
19
#include "gfal_api.h"
 
20
#include "stringtools.h"
 
21
#include "debug.h"
 
22
#include "xmalloc.h"
 
23
#include "macros.h"
 
24
}
 
25
 
 
26
#include <string.h>
 
27
#include <unistd.h>
 
28
#include <stdio.h>
 
29
#include <stdlib.h>
 
30
#include <fcntl.h>
 
31
#include <errno.h>
 
32
#include <utime.h>
 
33
#include <sys/statfs.h>
 
34
 
 
35
void format_name( pfs_name *name, char *path )
 
36
{
 
37
        if(!strcmp(name->service_name,"lfn")) {
 
38
                sprintf(path,"lfn:/%s%s",name->host,name->rest);
 
39
        } else if(!strcmp(name->service_name,"guid")) {
 
40
                sprintf(path,"guid:%s",name->host);
 
41
        } else if(!strcmp(name->service_name,"gfal")) {
 
42
                sprintf(path,"%s",name->path+6);
 
43
        } else {
 
44
                /* note double slashes needed for srm, dcap, and rfio */
 
45
                /* name->rest always begins with a slash */
 
46
                sprintf(path,"%s://%s/%s",
 
47
                        name->service_name,
 
48
                        name->port==0 ? name->host : name->hostport,
 
49
                        name->rest);
 
50
        }
 
51
}
 
52
 
 
53
 
 
54
class pfs_file_gfal : public pfs_file
 
55
{
 
56
private:
 
57
        int gfd;
 
58
        char *buffer;
 
59
        pfs_off_t current_offset;
 
60
 
 
61
public:
 
62
        pfs_file_gfal( pfs_name *name, int f ) : pfs_file(name) {
 
63
                gfd = f;
 
64
                buffer = 0;
 
65
                current_offset = 0;
 
66
        }
 
67
 
 
68
        virtual int close() {
 
69
                int result;
 
70
                debug(D_GFAL,"close %d",gfd);
 
71
                result = gfal_close(gfd);
 
72
                debug(D_GFAL,"= %d",result);
 
73
                return result;
 
74
        }
 
75
 
 
76
        virtual pfs_ssize_t read( void *data, pfs_size_t length, pfs_off_t offset ) {
 
77
                pfs_ssize_t result;
 
78
                debug(D_GFAL,"read %d %x %d %d",gfd,data,length,offset);
 
79
                if(offset!=current_offset) gfal_lseek(gfd,offset,SEEK_SET);
 
80
                result = gfal_read(gfd,data,length);
 
81
                if(result>0) current_offset+=result;
 
82
                debug(D_GFAL,"= %d",result);
 
83
                return result;
 
84
        }
 
85
 
 
86
        virtual pfs_ssize_t write( const void *data, pfs_size_t length, pfs_off_t offset ) {
 
87
                pfs_ssize_t result;
 
88
                debug(D_GFAL,"write %d %x %d %d",gfd,data,length,offset);
 
89
                if(offset!=current_offset) gfal_lseek(gfd,offset,SEEK_SET);
 
90
                result = gfal_write(gfd,data,length);
 
91
                if(result>0) current_offset+=result;
 
92
                debug(D_GFAL,"= %d",result);
 
93
                return result;
 
94
        }
 
95
 
 
96
        virtual int fstat( struct pfs_stat *buf ) {
 
97
                pfs_service_emulate_stat(&name,buf);
 
98
                buf->st_size = this->get_size();
 
99
                return 0;
 
100
        }
 
101
 
 
102
        virtual pfs_ssize_t get_size() {
 
103
                current_offset = gfal_lseek(gfd,0,SEEK_END);
 
104
                return current_offset;
 
105
        }
 
106
};
 
107
 
 
108
class pfs_service_gfal : public pfs_service {
 
109
public:
 
110
        virtual pfs_file * open( pfs_name *name, int flags, mode_t mode ) {
 
111
                int gfd;
 
112
 
 
113
                char gfalname[PFS_PATH_MAX];
 
114
                format_name(name,gfalname);
 
115
 
 
116
                debug(D_GFAL,"open %s %d %d",gfalname,flags,mode);
 
117
                gfd = gfal_open(gfalname,flags,mode);
 
118
                debug(D_GFAL,"= %d",gfd);
 
119
                if(gfd>=0) {
 
120
                        return new pfs_file_gfal(name,gfd);
 
121
                } else {
 
122
                        return 0;
 
123
                }
 
124
        }
 
125
 
 
126
        virtual pfs_dir * getdir( pfs_name *name ) {
 
127
                DIR *gfaldir;
 
128
                struct dirent *d;
 
129
 
 
130
                char gfalname[PFS_PATH_MAX];
 
131
                format_name(name,gfalname);
 
132
 
 
133
                debug(D_GFAL,"getdir %s",gfalname);
 
134
 
 
135
                gfaldir = gfal_opendir(gfalname);
 
136
                if(gfaldir) {
 
137
                        pfs_dir *dir = new pfs_dir(name);
 
138
                        while(((d=gfal_readdir(gfaldir)))) {
 
139
                                dir->append(d->d_name);
 
140
                        }
 
141
                        return dir;
 
142
                } else {
 
143
                        return 0;
 
144
                }
 
145
        }
 
146
 
 
147
        virtual int stat( pfs_name *name, struct pfs_stat *buf ) {
 
148
                int result;
 
149
                struct stat gbuf;
 
150
                char gfalname[PFS_PATH_MAX];
 
151
                format_name(name,gfalname);
 
152
 
 
153
                debug(D_GFAL,"stat %s",gfalname);
 
154
                result = gfal_stat(gfalname,&gbuf);
 
155
                if(result==0) COPY_STAT(gbuf,*buf);
 
156
                debug(D_GFAL,"= %d",result);
 
157
                return result;
 
158
        }
 
159
 
 
160
        virtual int lstat( pfs_name *name, struct pfs_stat *buf ) {
 
161
                int result;
 
162
                struct stat gbuf;
 
163
                char gfalname[PFS_PATH_MAX];
 
164
                format_name(name,gfalname);
 
165
 
 
166
                debug(D_GFAL,"lstat %s",gfalname);
 
167
                result = gfal_lstat(gfalname,&gbuf);
 
168
                if(result==0) COPY_STAT(gbuf,*buf);
 
169
                debug(D_GFAL,"= %d",result);
 
170
                return result;
 
171
        }
 
172
 
 
173
        virtual int unlink( pfs_name *name ) {
 
174
                int result;
 
175
                char gfalname[PFS_PATH_MAX];
 
176
                format_name(name,gfalname);
 
177
 
 
178
                debug(D_GFAL,"unlink %s",gfalname);
 
179
                result = gfal_unlink(gfalname);
 
180
                debug(D_GFAL,"= %d",result);
 
181
                return result;
 
182
        }
 
183
 
 
184
        virtual int access( pfs_name *name, mode_t mode ) {
 
185
                int result;
 
186
                char gfalname[PFS_PATH_MAX];
 
187
                format_name(name,gfalname);
 
188
 
 
189
                debug(D_GFAL,"access %s %d",gfalname,mode);
 
190
                result = gfal_access(gfalname,mode);
 
191
                debug(D_GFAL,"= %d",result);
 
192
                return result;
 
193
        }
 
194
 
 
195
        virtual int chmod( pfs_name *name, mode_t mode ) {
 
196
                int result;
 
197
                char gfalname[PFS_PATH_MAX];
 
198
                format_name(name,gfalname);
 
199
 
 
200
                debug(D_GFAL,"chmod %s %d",gfalname,mode);
 
201
                result = gfal_chmod(gfalname,mode);
 
202
                debug(D_GFAL,"= %d",result);
 
203
                return result;
 
204
        }
 
205
 
 
206
        virtual int rename( pfs_name *name, pfs_name *newname ) {
 
207
                int result;
 
208
                char gfalname[PFS_PATH_MAX];
 
209
                char newgfalname[PFS_PATH_MAX];
 
210
                format_name(name,gfalname);
 
211
                format_name(newname,newgfalname);
 
212
 
 
213
                debug(D_GFAL,"rename %s %s",gfalname,newgfalname);
 
214
                result = gfal_rename(gfalname,newgfalname);
 
215
                debug(D_GFAL,"= %d",result);
 
216
                return result;
 
217
        }
 
218
 
 
219
        virtual int chdir( pfs_name *name, char *newname ) {
 
220
 
 
221
                struct pfs_stat buf;
 
222
                int result;
 
223
                char gfalname[PFS_PATH_MAX];
 
224
                format_name(name,gfalname);
 
225
 
 
226
                result = this->stat(name,&buf);
 
227
                if(result<0) return result;
 
228
 
 
229
                if(S_ISDIR(buf.st_mode)) {
 
230
                        strcpy(newname,name->path);
 
231
                        return 0;
 
232
                } else {
 
233
                        errno = ENOTDIR;
 
234
                        return -1;
 
235
                }
 
236
        }
 
237
 
 
238
        virtual int mkdir( pfs_name *name, mode_t mode ) {
 
239
                int result;
 
240
                char gfalname[PFS_PATH_MAX];
 
241
                format_name(name,gfalname);
 
242
 
 
243
                debug(D_GFAL,"mkdir %s %d",gfalname,mode);
 
244
                result = gfal_mkdir(gfalname,mode);
 
245
                debug(D_GFAL,"= %d",result);
 
246
                return result;
 
247
        }
 
248
 
 
249
        virtual int rmdir( pfs_name *name ) {
 
250
                int result;
 
251
                char gfalname[PFS_PATH_MAX];
 
252
                format_name(name,gfalname);
 
253
 
 
254
                debug(D_GFAL,"rmdir %s",gfalname);
 
255
                result = gfal_rmdir(gfalname);
 
256
                debug(D_GFAL,"= %d",result);
 
257
                return result;
 
258
        }
 
259
 
 
260
        virtual int is_local() {
 
261
                return 0;
 
262
        }
 
263
 
 
264
        virtual int is_seekable() {
 
265
                return 1;
 
266
        }
 
267
 
 
268
};
 
269
 
 
270
static pfs_service_gfal pfs_service_gfal_instance;
 
271
pfs_service *pfs_service_gfal = &pfs_service_gfal_instance;
 
272
 
 
273
#endif