int irods_file_open_( char *filename, char *mode ) { int i; int status; dataObjInp_t dataObjInp; char **outPath; char *cp1, *cp2; int nameLen; if ( debug ) { printf( "irods_file_open filename input:%s:\n", filename ); } /* Remove trailing blanks from the filename */ cp1 = filename; cp2 = cp1 + strlen( filename ) - 1; for ( ; *cp2 == ' ' && cp2 > cp1; cp2-- ) { } cp2++; if ( cp2 > cp1 ) { *cp2 = '\0'; } if ( debug ) printf( "irods_file_open filename w/o trailing blanks:%s:\n", filename ); if ( setupFlag == 0 ) { status = irods_connect_(); if ( status ) { return -1; } } memset( &dataObjInp, 0, sizeof( dataObjInp ) ); status = parseRodsPathStr( filename , &myRodsEnv, dataObjInp.objPath ); if ( status < 0 ) { rodsLogError( LOG_ERROR, status, "irods_file_open" ); return -1; } /* Set the openFlags based on the input mode (incomplete * currently) // */ dataObjInp.openFlags = O_RDONLY; if ( strstr( mode, "WRITE" ) != NULL ) { dataObjInp.openFlags = O_RDWR; } /* may want a O_WRONLY mode too sometime */ status = rcDataObjOpen( Comm, &dataObjInp ); if ( status == CAT_NO_ROWS_FOUND && dataObjInp.openFlags == O_WRONLY ) { status = rcDataObjCreate( Comm, &dataObjInp ); } if ( status < 0 ) { rodsLogError( LOG_ERROR, status, "irods_file_open" ); return -1; } return status; }
int irodsTruncate (const char *path, off_t size) { dataObjInp_t dataObjInp; int status; pathCache_t *tmpPathCache; iFuseConn_t *iFuseConn = NULL; rodsLog (LOG_DEBUG, "irodsTruncate: %s", path); if (matchAndLockPathCache ((char *) path, &tmpPathCache) == 1) { if(tmpPathCache->fileCache != NULL) { LOCK_STRUCT(*tmpPathCache->fileCache); if(tmpPathCache->fileCache->state == HAVE_NEWLY_CREATED_CACHE) { status = truncate (tmpPathCache->fileCache->fileCachePath, size); if (status >= 0) { updatePathCacheStatFromFileCache (tmpPathCache); UNLOCK_STRUCT(*(tmpPathCache->fileCache)); UNLOCK_STRUCT(*tmpPathCache); return (0); } } UNLOCK_STRUCT(*(tmpPathCache->fileCache)); } } UNLOCK_STRUCT(*tmpPathCache); memset (&dataObjInp, 0, sizeof (dataObjInp)); status = parseRodsPathStr ((char *) (path + 1) , &MyRodsEnv, dataObjInp.objPath); if (status < 0) { rodsLogError (LOG_ERROR, status, "irodsTruncate: parseRodsPathStr of %s error", path); /* use ENOTDIR for this type of error */ return -ENOTDIR; } dataObjInp.dataSize = size; getAndUseIFuseConn (&iFuseConn, &MyRodsEnv); RECONNECT_IF_NECESSARY(status, iFuseConn, rcDataObjTruncate (iFuseConn->conn, &dataObjInp)); if (status >= 0) { pathCache_t *tmpPathCache; if (matchAndLockPathCache ((char *) path, &tmpPathCache) == 1) { tmpPathCache->stbuf.st_size = size; } UNLOCK_STRUCT(*tmpPathCache); status = 0; } else { rodsLogError (LOG_ERROR, status, "irodsTruncate: rcDataObjTruncate of %s error", path); status = -ENOENT; } unuseIFuseConn (iFuseConn); return (status); }
int irods_file_create_( char *filename ) { int i; int status; dataObjInp_t dataObjInp; char **outPath; char *cp1, *cp2; int nameLen; if ( debug ) { printf( "irods_file_create filename input:%s:\n", filename ); } /* Remove trailing blanks from the filename */ cp1 = filename; cp2 = cp1 + strlen( filename ) - 1; for ( ; *cp2 == ' ' && cp2 > cp1; cp2-- ) { } cp2++; if ( cp2 > cp1 ) { *cp2 = '\0'; } if ( debug ) printf( "irods_file_create filename w/o trailing blanks:%s:\n", filename ); if ( setupFlag == 0 ) { status = irods_connect_(); if ( status ) { return -1; } } memset( &dataObjInp, 0, sizeof( dataObjInp ) ); status = parseRodsPathStr( filename , &myRodsEnv, dataObjInp.objPath ); if ( status < 0 ) { rodsLogError( LOG_ERROR, status, "irods_file_create" ); return -1; } dataObjInp.openFlags = O_RDWR; /* may want a O_WRONLY mode too sometime */ status = rcDataObjCreate( Comm, &dataObjInp ); if ( status < 0 ) { rodsLogError( LOG_ERROR, status, "irods_file_open" ); return -1; } return status; }
int irodsMkdir (const char *path, mode_t mode) { collInp_t collCreateInp; int status; iFuseConn_t *iFuseConn = NULL; rodsLog (LOG_DEBUG, "irodsMkdir: %s", path); memset (&collCreateInp, 0, sizeof (collCreateInp)); status = parseRodsPathStr ((char *) (path + 1) , &MyRodsEnv, collCreateInp.collName); if (status < 0) { rodsLogError (LOG_ERROR, status, "irodsMkdir: parseRodsPathStr of %s error", path); /* use ENOTDIR for this type of error */ return -ENOTDIR; } getAndUseIFuseConn (&iFuseConn, &MyRodsEnv); status = rcCollCreate (iFuseConn->conn, &collCreateInp); if (status < 0) { if (isReadMsgError (status)) { ifuseReconnect (iFuseConn); status = rcCollCreate (iFuseConn->conn, &collCreateInp); } unuseIFuseConn (iFuseConn); if (status < 0) { rodsLogError (LOG_ERROR, status, "irodsMkdir: rcCollCreate of %s error", path); return -ENOENT; } #ifdef CACHE_FUSE_PATH } else { struct stat stbuf; uint mytime = time (0); bzero (&stbuf, sizeof (struct stat)); fillDirStat (&stbuf, mytime, mytime, mytime); pathExist ((char *) path, NULL, &stbuf, NULL); #endif unuseIFuseConn (iFuseConn); } return (0); }
int irodsUnlink (const char *path) { dataObjInp_t dataObjInp; int status; iFuseConn_t *iFuseConn = NULL; rodsLog (LOG_DEBUG, "irodsUnlink: %s", path); memset (&dataObjInp, 0, sizeof (dataObjInp)); status = parseRodsPathStr ((char *) (path + 1) , &MyRodsEnv, dataObjInp.objPath); if (status < 0) { rodsLogError (LOG_ERROR, status, "irodsUnlink: parseRodsPathStr of %s error", path); /* use ENOTDIR for this type of error */ return -ENOTDIR; } addKeyVal (&dataObjInp.condInput, FORCE_FLAG_KW, ""); getAndUseIFuseConn (&iFuseConn, &MyRodsEnv); status = rcDataObjUnlink (iFuseConn->conn, &dataObjInp); if (status >= 0) { #ifdef CACHE_FUSE_PATH pathNotExist ((char *) path); #endif status = 0; } else { if (isReadMsgError (status)) { ifuseReconnect (iFuseConn); status = rcDataObjUnlink (iFuseConn->conn, &dataObjInp); } if (status < 0) { rodsLogError (LOG_ERROR, status, "irodsUnlink: rcDataObjUnlink of %s error", path); status = -ENOENT; } } unuseIFuseConn (iFuseConn); clearKeyVal (&dataObjInp.condInput); return (status); }
int RodsConnection::readColl(const std::string &collPath, std::vector<RodsObjEntryPtr> *collObjs) { collHandle_t rodsColl; collEnt_t rodsCollEntry; char collPathIn[MAX_NAME_LEN], collPathOut[MAX_NAME_LEN]; int status = 0; // sanity checks for arguments if (!collObjs || collPath.empty()) return (-1); // take a temp copy of the coll path string strcpy(collPathIn, collPath.c_str()); this->mutexLock(); // first the path string must be parsed by iRODS if ((status = parseRodsPathStr(collPathIn, &this->rodsUserEnv, collPathOut) < 0)) return (status); // try to open collection from iRODS if ((status = rclOpenCollection(this->rodsCommPtr, collPathOut, 0, &rodsColl)) < 0) return (status); // read collection while there are objects to loop over do { status = rclReadCollection(this->rodsCommPtr, &rodsColl, &rodsCollEntry); if (status >= 0) { Kanki::RodsObjEntryPtr newEntry(new Kanki::RodsObjEntry(rodsCollEntry.objType == DATA_OBJ_T ? rodsCollEntry.dataName : rodsCollEntry.collName, rodsCollEntry.collName, rodsCollEntry.createTime, rodsCollEntry.modifyTime, rodsCollEntry.objType, rodsCollEntry.replNum, rodsCollEntry.replStatus, rodsCollEntry.dataSize)); collObjs->push_back(newEntry); } } while (status >= 0); // close the collection handle status = rclCloseCollection(&rodsColl); this->mutexUnlock(); return (status); }
int irodsRmdir (const char *path) { collInp_t collInp; int status; iFuseConn_t *iFuseConn = NULL; rodsLog (LOG_DEBUG, "irodsRmdir: %s", path); memset (&collInp, 0, sizeof (collInp)); status = parseRodsPathStr ((char *) (path + 1) , &MyRodsEnv, collInp.collName); if (status < 0) { rodsLogError (LOG_ERROR, status, "irodsRmdir: parseRodsPathStr of %s error", path); /* use ENOTDIR for this type of error */ return -ENOTDIR; } addKeyVal (&collInp.condInput, FORCE_FLAG_KW, ""); getAndUseIFuseConn (&iFuseConn, &MyRodsEnv); RECONNECT_IF_NECESSARY(status, iFuseConn, rcRmColl (iFuseConn->conn, &collInp, 0)); if (status >= 0) { #ifdef CACHE_FUSE_PATH pathNotExist ((char *) path); #endif status = 0; } else { rodsLogError (LOG_ERROR, status, "irodsRmdir: rcRmColl of %s error", path); status = -ENOENT; } unuseIFuseConn (iFuseConn); clearKeyVal (&collInp.condInput); return (status); }
int irodsOpen (const char *path, struct fuse_file_info *fi) { dataObjInp_t dataObjInp; int status; int fd; iFuseConn_t *iFuseConn = NULL; iFuseDesc_t *desc = NULL; pathCache_t *tmpPathCache = NULL; struct stat stbuf; char cachePath[MAX_NAME_LEN]; char objPath[MAX_NAME_LEN]; int flags = fi->flags; rodsLog (LOG_DEBUG, "irodsOpen: %s, flags = %d", path, fi->flags); matchAndLockPathCache((char *) path, &tmpPathCache); if(tmpPathCache!= NULL) { if(tmpPathCache->fileCache != NULL) { LOCK_STRUCT(*(tmpPathCache->fileCache)); if (tmpPathCache->fileCache->state != NO_FILE_CACHE) { rodsLog (LOG_DEBUG, "irodsOpen: a match for %s", path); desc = newIFuseDesc(tmpPathCache->fileCache->objPath, (char *) path, tmpPathCache->fileCache, &status); if (status < 0) { UNLOCK_STRUCT(*(tmpPathCache->fileCache)); UNLOCK_STRUCT(*tmpPathCache); rodsLogError (LOG_ERROR, status, "irodsOpen: create descriptor of %s error", dataObjInp.objPath); return status; } fi->fh = desc->index; if(tmpPathCache->fileCache->iFd == 0) { tmpPathCache->fileCache->iFd = open(tmpPathCache->fileCache->fileCachePath, O_RDWR); } UNLOCK_STRUCT(*(tmpPathCache->fileCache)); UNLOCK_STRUCT(*tmpPathCache); return (0); } UNLOCK_STRUCT(*(tmpPathCache->fileCache)); } UNLOCK_STRUCT(*tmpPathCache); } memset (&dataObjInp, 0, sizeof (dataObjInp)); dataObjInp.openFlags = flags; status = parseRodsPathStr ((char *) (path + 1) , &MyRodsEnv, objPath); rstrcpy(dataObjInp.objPath, objPath, MAX_NAME_LEN); if (status < 0) { rodsLogError (LOG_ERROR, status, "irodsOpen: parseRodsPathStr of %s error", path); /* use ENOTDIR for this type of error */ return -ENOTDIR; } iFuseConn = getAndUseConnByPath((char *) path, &MyRodsEnv, &status); /* status = getAndUseIFuseConn(&iFuseConn, &MyRodsEnv); */ if(status < 0) { rodsLogError (LOG_ERROR, status, "irodsOpen: cannot get connection for %s error", path); /* use ENOTDIR for this type of error */ return -ENOTDIR; } /* do only O_RDONLY (0) */ status = _irodsGetattr (iFuseConn, path, &stbuf); if ((flags & (O_WRONLY | O_RDWR)) != 0 || status < 0 || stbuf.st_size > MAX_READ_CACHE_SIZE) { fd = rcDataObjOpen (iFuseConn->conn, &dataObjInp); unuseIFuseConn (iFuseConn); if (fd < 0) { rodsLogError (LOG_ERROR, status, "irodsOpen: rcDataObjOpen of %s error, status = %d", path, fd); return -ENOENT; } fileCache_t *fileCache = addFileCache(fd, objPath, (char *) path, NULL, stbuf.st_mode, stbuf.st_size, NO_FILE_CACHE); matchAndLockPathCache((char *) path, &tmpPathCache); if(tmpPathCache == NULL) { pathExist((char *) path, fileCache, &stbuf, NULL); } else { _addFileCacheForPath(tmpPathCache, fileCache); UNLOCK_STRUCT(*tmpPathCache); } desc = newIFuseDesc (objPath, (char *) path, fileCache, &status); if (desc == NULL) { rodsLogError (LOG_ERROR, status, "irodsOpen: allocIFuseDesc of %s error", path); return -ENOENT; } } else { rodsLog (LOG_DEBUG, "irodsOpenWithReadCache: caching %s", path); if ((status = getFileCachePath (path, cachePath)) < 0) { unuseIFuseConn(iFuseConn); return status; } /* get the file to local cache */ dataObjInp.dataSize = stbuf.st_size; status = rcDataObjGet (iFuseConn->conn, &dataObjInp, cachePath); unuseIFuseConn(iFuseConn); if (status < 0) { rodsLogError (LOG_ERROR, status, "irodsOpenWithReadCache: rcDataObjGet of %s error", dataObjInp.objPath); return status; } int fd = open(cachePath, O_RDWR); fileCache_t *fileCache = addFileCache(fd, objPath, (char *) path, cachePath, stbuf.st_mode, stbuf.st_size, HAVE_READ_CACHE); matchAndLockPathCache((char *) path, &tmpPathCache); if(tmpPathCache == NULL) { pathExist((char *) path, fileCache, &stbuf, NULL); } else { _addFileCacheForPath(tmpPathCache, fileCache); UNLOCK_STRUCT(*tmpPathCache); } desc = newIFuseDesc(objPath, (char *) path,fileCache, &status); if (status < 0) { rodsLogError (LOG_ERROR, status, "irodsOpen: create descriptor of %s error", dataObjInp.objPath); return status; } } fi->fh = desc->index; return (0); }
int irodsChmod (const char *path, mode_t mode) { int status; modDataObjMeta_t modDataObjMetaInp; keyValPair_t regParam; dataObjInfo_t dataObjInfo; char dataMode[SHORT_STR_LEN]; pathCache_t *tmpPathCache; iFuseConn_t *iFuseConn = NULL; rodsLog (LOG_DEBUG, "irodsChmod: %s", path); matchAndLockPathCache((char *) path, &tmpPathCache); if (tmpPathCache->fileCache != NULL) { LOCK_STRUCT(*tmpPathCache->fileCache); if(tmpPathCache->fileCache->state == HAVE_NEWLY_CREATED_CACHE) { /* has not actually been created yet */ tmpPathCache->fileCache->mode = mode; UNLOCK_STRUCT(*tmpPathCache->fileCache); UNLOCK_STRUCT(*tmpPathCache); return (0); } UNLOCK_STRUCT(*tmpPathCache->fileCache); } UNLOCK_STRUCT(*tmpPathCache); if(tmpPathCache->stbuf.st_nlink != 1) { rodsLog (LOG_NOTICE, "irodsChmod: modification of the mode of non file object is currently not supported", path); return 0; } memset (®Param, 0, sizeof (regParam)); snprintf (dataMode, SHORT_STR_LEN, "%d", mode); addKeyVal (®Param, DATA_MODE_KW, dataMode); addKeyVal (®Param, ALL_KW, ""); memset(&dataObjInfo, 0, sizeof(dataObjInfo)); status = parseRodsPathStr ((char *) (path + 1) , &MyRodsEnv, dataObjInfo.objPath); if (status < 0) { rodsLogError (LOG_ERROR, status, "irodsChmod: parseRodsPathStr of %s error", path); /* use ENOTDIR for this type of error */ return -ENOTDIR; } modDataObjMetaInp.regParam = ®Param; modDataObjMetaInp.dataObjInfo = &dataObjInfo; getAndUseIFuseConn (&iFuseConn, &MyRodsEnv); RECONNECT_IF_NECESSARY(status, iFuseConn, rcModDataObjMeta(iFuseConn->conn, &modDataObjMetaInp)); if (status >= 0) { #ifdef CACHE_FUSE_PATH pathCache_t *tmpPathCache; if (matchAndLockPathCache ((char *) path, &tmpPathCache) == 1) { tmpPathCache->stbuf.st_mode &= 0xfffffe00; tmpPathCache->stbuf.st_mode |= (mode & 0777); UNLOCK_STRUCT(*tmpPathCache); } #endif status = 0; } else { rodsLogError(LOG_ERROR, status, "irodsChmod: rcModDataObjMeta failure"); status = -ENOENT; } unuseIFuseConn (iFuseConn); clearKeyVal (®Param); return(status); }
int irodsRename (const char *from, const char *to) { dataObjCopyInp_t dataObjRenameInp; int status; iFuseConn_t *iFuseConn = NULL; rodsLog (LOG_DEBUG, "irodsRename: %s to %s", from, to); /* test rcDataObjRename */ memset (&dataObjRenameInp, 0, sizeof (dataObjRenameInp)); status = parseRodsPathStr ((char *) (from + 1) , &MyRodsEnv, dataObjRenameInp.srcDataObjInp.objPath); if (status < 0) { rodsLogError (LOG_ERROR, status, "irodsRename: parseRodsPathStr of %s error", from); /* use ENOTDIR for this type of error */ return -ENOTDIR; } status = parseRodsPathStr ((char *) (to + 1) , &MyRodsEnv, dataObjRenameInp.destDataObjInp.objPath); if (status < 0) { rodsLogError (LOG_ERROR, status, "irodsRename: parseRodsPathStr of %s error", to); /* use ENOTDIR for this type of error */ return -ENOTDIR; } char *toIrodsPath = strdup(dataObjRenameInp.destDataObjInp.objPath); addKeyVal (&dataObjRenameInp.destDataObjInp.condInput, FORCE_FLAG_KW, ""); dataObjRenameInp.srcDataObjInp.oprType = dataObjRenameInp.destDataObjInp.oprType = RENAME_UNKNOWN_TYPE; getAndUseIFuseConn (&iFuseConn, &MyRodsEnv); /* rodsLog (LOG_ERROR, "irodsRenme: %s -> %s conn: %p", from, to, iFuseConn);*/ status = rcDataObjRename (iFuseConn->conn, &dataObjRenameInp); if (status == CAT_NAME_EXISTS_AS_DATAOBJ || status == SYS_DEST_SPEC_COLL_SUB_EXIST) { rcDataObjUnlink (iFuseConn->conn, &dataObjRenameInp.destDataObjInp); status = rcDataObjRename (iFuseConn->conn, &dataObjRenameInp); } if (status >= 0) { #ifdef CACHE_FUSE_PATH status = renmeLocalPath ((char *) from, (char *) to, (char *) toIrodsPath); #endif } else { if (isReadMsgError (status)) { ifuseReconnect (iFuseConn); status = rcDataObjRename (iFuseConn->conn, &dataObjRenameInp); } if (status < 0) { rodsLogError (LOG_ERROR, status, "irodsRename: rcDataObjRename of %s to %s error", from, to); status = -ENOENT; } } unuseIFuseConn (iFuseConn); free(toIrodsPath); return (status); }
int irodsReadlink (const char *path, char *buf, size_t size) { int status; iFuseConn_t *iFuseConn = NULL; int l1descInx; dataObjInp_t dataObjOpenInp; openedDataObjInp_t dataObjReadInp; bytesBuf_t dataObjReadOutBBuf; char collPath[MAX_NAME_LEN]; rodsLog (LOG_DEBUG, "irodsReadlink: %s", path); status = parseRodsPathStr ((char *) (path + 1), &MyRodsEnv, collPath); if (status < 0) { rodsLogError (LOG_ERROR, status, "irodsReaddir: parseRodsPathStr of %s error", path); /* use ENOTDIR for this type of error */ return -ENOTDIR; } iFuseConn = getAndUseConnByPath ((char *) path, &MyRodsEnv, &status); memset (&dataObjOpenInp, 0, sizeof (dataObjOpenInp)); rstrcpy (dataObjOpenInp.objPath, collPath, MAX_NAME_LEN); dataObjOpenInp.openFlags = O_RDONLY; status = rcDataObjOpen (iFuseConn->conn, &dataObjOpenInp); if (status < 0) { if (isReadMsgError (status)) { ifuseReconnect (iFuseConn); status = rcDataObjOpen (iFuseConn->conn, &dataObjOpenInp); } if (status < 0) { rodsLog (LOG_ERROR, "irodsReadlink: rcDataObjOpen of %s error. status = %d", collPath, status); unuseIFuseConn (iFuseConn); return -ENOENT; } } l1descInx = status; memset(&dataObjReadInp, 0, sizeof (dataObjReadInp)); memset(&dataObjReadOutBBuf, 0, sizeof (bytesBuf_t)); dataObjReadInp.l1descInx = l1descInx; dataObjReadInp.len = size - 1; status = rcDataObjRead(iFuseConn->conn, &dataObjReadInp, &dataObjReadOutBBuf); if (status < 0) { rodsLog (LOG_ERROR, "irodsReadlink: rcDataObjRead of %s error. status = %d", collPath, status); unuseIFuseConn (iFuseConn); return -ENOENT; } memcpy(buf, dataObjReadOutBBuf.buf, status); buf[status] = '\0'; rcDataObjClose(iFuseConn->conn, &dataObjReadInp); unuseIFuseConn (iFuseConn); return (0); }
int irodsMknod (const char *path, mode_t mode, dev_t rdev) { pathCache_t *tmpPathCache = NULL; struct stat stbuf; int status = -1; char cachePath[MAX_NAME_LEN]; char objPath[MAX_NAME_LEN]; iFuseConn_t *iFuseConn = NULL; fileCache_t *fileCache = NULL; /* iFuseDesc_t *desc = NULL; */ int localFd; rodsLog (LOG_DEBUG, "irodsMknod: %s", path); if (irodsGetattr (path, &stbuf) >= 0) return -EEXIST; status = irodsMknodWithCache ((char *)path, mode, cachePath); localFd = status; status = parseRodsPathStr ((char *) (path + 1) , &MyRodsEnv, objPath); if (status < 0) { rodsLogError (LOG_ERROR, status, "dataObjCreateByFusePath: parseRodsPathStr of %s error", path); /* use ENOTDIR for this type of error */ return -ENOTDIR; } getAndUseIFuseConn (&iFuseConn, &MyRodsEnv); if (status < 0) { status = dataObjCreateByFusePath (iFuseConn->conn, (char *) path, mode, objPath); if (status < 0) { if (isReadMsgError (status)) { ifuseReconnect (iFuseConn); status = dataObjCreateByFusePath (iFuseConn->conn, (char *) path, mode, objPath); } if (status < 0) { rodsLogError (LOG_ERROR, status, "irodsMknod: rcDataObjCreate of %s error", path); unuseIFuseConn (iFuseConn); return -ENOENT; } } } fileCache = addFileCache(localFd, objPath, (char *) path, cachePath, mode, 0, HAVE_NEWLY_CREATED_CACHE); stbuf.st_mode = mode; pathExist ((char *) path, fileCache, &stbuf, &tmpPathCache); /* desc = newIFuseDesc (objPath, (char *) path, fileCache, &status); */ if (status < 0) { rodsLogError (LOG_ERROR, status, "irodsMknod: allocIFuseDesc of %s error", path); closeIrodsFd (iFuseConn->conn, status); unuseIFuseConn (iFuseConn); return 0; } /* rodsLog (LOG_ERROR, "irodsMknod: %s conn: %p", path, iFuseConn);*/ unuseIFuseConn (iFuseConn); return (0); }
int _irodsGetattr (iFuseConn_t *iFuseConn, const char *path, struct stat *stbuf) { int status; dataObjInp_t dataObjInp; rodsObjStat_t *rodsObjStatOut = NULL; #ifdef CACHE_FUSE_PATH pathCache_t *tmpPathCache; #endif rodsLog (LOG_DEBUG, "_irodsGetattr: %s", path); #ifdef CACHE_FUSE_PATH /*if (lookupPathNotExist( (char *) path) == 1) { rodsLog (LOG_DEBUG, "irodsGetattr: a match for non existing path %s", path); return -ENOENT; }*/ if (matchAndLockPathCache ((char *) path, &tmpPathCache) == 1) { rodsLog (LOG_DEBUG, "irodsGetattr: a match for path %s", path); if (tmpPathCache->fileCache != NULL) { LOCK_STRUCT(*(tmpPathCache->fileCache)); if(tmpPathCache->fileCache->state == HAVE_NEWLY_CREATED_CACHE) { status = _updatePathCacheStatFromFileCache (tmpPathCache); UNLOCK_STRUCT(*(tmpPathCache->fileCache)); UNLOCK_STRUCT(*tmpPathCache); if (status < 0) { clearPathFromCache ((char *) path); } else { *stbuf = tmpPathCache->stbuf; return (0); } } else { UNLOCK_STRUCT(*(tmpPathCache->fileCache)); UNLOCK_STRUCT(*tmpPathCache); } } else { UNLOCK_STRUCT(*tmpPathCache); } } #endif memset (stbuf, 0, sizeof (struct stat)); memset (&dataObjInp, 0, sizeof (dataObjInp)); status = parseRodsPathStr ((char *) (path + 1) , &MyRodsEnv, dataObjInp.objPath); if (status < 0) { rodsLogError (LOG_ERROR, status, "irodsGetattr: parseRodsPathStr of %s error", path); /* use ENOTDIR for this type of error */ return -ENOTDIR; } status = rcObjStat (iFuseConn->conn, &dataObjInp, &rodsObjStatOut); if (status < 0) { if (isReadMsgError (status)) { ifuseReconnect (iFuseConn); status = rcObjStat (iFuseConn->conn, &dataObjInp, &rodsObjStatOut); } if (status < 0) { if (status != USER_FILE_DOES_NOT_EXIST) { rodsLogError (LOG_ERROR, status, "irodsGetattr: rcObjStat of %s error", path); } #ifdef CACHE_FUSE_PATH pathNotExist ((char *) path); #endif return -ENOENT; } } if (rodsObjStatOut->objType == COLL_OBJ_T) { fillDirStat (stbuf, atoi (rodsObjStatOut->createTime), atoi (rodsObjStatOut->modifyTime), atoi (rodsObjStatOut->modifyTime)); } else if (rodsObjStatOut->objType == UNKNOWN_OBJ_T) { pathNotExist ((char *) path); if (rodsObjStatOut != NULL) freeRodsObjStat (rodsObjStatOut); return -ENOENT; } else { fillFileStat (stbuf, rodsObjStatOut->dataMode, rodsObjStatOut->objSize, atoi (rodsObjStatOut->createTime), atoi (rodsObjStatOut->modifyTime), atoi (rodsObjStatOut->modifyTime)); } if (rodsObjStatOut != NULL) freeRodsObjStat (rodsObjStatOut); /* don't set file cache */ pathExist ((char *) path, NULL, stbuf, &tmpPathCache); return 0; }
int irodsReaddir (const char *path, void *buf, fuse_fill_dir_t filler, off_t offset, struct fuse_file_info *fi) { char collPath[MAX_NAME_LEN]; collHandle_t collHandle; collEnt_t collEnt; int status; #ifdef CACHE_FUSE_PATH struct stat stbuf; pathCache_t *tmpPathCache; #endif /* don't know why we need this. the example have them */ (void) offset; (void) fi; iFuseConn_t *iFuseConn = NULL; rodsLog (LOG_DEBUG, "irodsReaddir: %s", path); filler(buf, ".", NULL, 0); filler(buf, "..", NULL, 0); status = parseRodsPathStr ((char *) (path + 1), &MyRodsEnv, collPath); if (status < 0) { rodsLogError (LOG_ERROR, status, "irodsReaddir: parseRodsPathStr of %s error", path); /* use ENOTDIR for this type of error */ return -ENOTDIR; } iFuseConn = getAndUseConnByPath ((char *) path, &MyRodsEnv, &status); status = rclOpenCollection (iFuseConn->conn, collPath, 0, &collHandle); if (status < 0) { if (isReadMsgError (status)) { ifuseReconnect (iFuseConn); status = rclOpenCollection (iFuseConn->conn, collPath, 0, &collHandle); } if (status < 0) { rodsLog (LOG_ERROR, "irodsReaddir: rclOpenCollection of %s error. status = %d", collPath, status); unuseIFuseConn (iFuseConn); return -ENOENT; } } while ((status = rclReadCollection (iFuseConn->conn, &collHandle, &collEnt)) >= 0) { char myDir[MAX_NAME_LEN], mySubDir[MAX_NAME_LEN]; #ifdef CACHE_FUSE_PATH char childPath[MAX_NAME_LEN]; bzero (&stbuf, sizeof (struct stat)); #endif if (collEnt.objType == DATA_OBJ_T) { filler (buf, collEnt.dataName, NULL, 0); #ifdef CACHE_FUSE_PATH if (strcmp (path, "/") == 0) { snprintf (childPath, MAX_NAME_LEN, "/%s", collEnt.dataName); } else { snprintf (childPath, MAX_NAME_LEN, "%s/%s", path, collEnt.dataName); } if (lookupPathExist ((char *) childPath, &tmpPathCache) != 1) { fillFileStat (&stbuf, collEnt.dataMode, collEnt.dataSize, atoi (collEnt.createTime), atoi (collEnt.modifyTime), atoi (collEnt.modifyTime)); pathExist (childPath, NULL, &stbuf, &tmpPathCache); } #endif } else if (collEnt.objType == COLL_OBJ_T) { splitPathByKey (collEnt.collName, myDir, mySubDir, '/'); if(mySubDir[0] != '\0') { filler (buf, mySubDir, NULL, 0); #ifdef CACHE_FUSE_PATH if (strcmp (path, "/") == 0) { snprintf (childPath, MAX_NAME_LEN, "/%s", mySubDir); } else { snprintf (childPath, MAX_NAME_LEN, "%s/%s", path, mySubDir); } if (lookupPathExist ((char *) childPath, &tmpPathCache) != 1) { fillDirStat (&stbuf, atoi (collEnt.createTime), atoi (collEnt.modifyTime), atoi (collEnt.modifyTime)); pathExist (childPath, NULL, &stbuf, &tmpPathCache); } #endif } } } rclCloseCollection (&collHandle); unuseIFuseConn (iFuseConn); return (0); }
int irodsSymlink (const char *to, const char *from) { int status; iFuseConn_t *iFuseConn = NULL; int l1descInx; dataObjInp_t dataObjOpenInp; openedDataObjInp_t dataObjWriteInp; bytesBuf_t dataObjWriteOutBBuf; char collPath[MAX_NAME_LEN]; struct stat stbuf; rodsLog (LOG_DEBUG, "irodsSymlink: %s to %s", from, to); status = parseRodsPathStr ((char *) (from + 1), &MyRodsEnv, collPath); if (status < 0) { rodsLogError (LOG_ERROR, status, "irodsReaddir: parseRodsPathStr of %s error", from); /* use ENOTDIR for this type of error */ return -ENOTDIR; } iFuseConn = getAndUseConnByPath ((char *) from, &MyRodsEnv, &status); status = _irodsGetattr(iFuseConn, (char *) from, &stbuf); memset (&dataObjOpenInp, 0, sizeof (dataObjOpenInp)); rstrcpy (dataObjOpenInp.objPath, collPath, MAX_NAME_LEN); if(status != -ENOENT) { if (status < 0) { return status; } dataObjOpenInp.dataSize = 0; status = rcDataObjTruncate(iFuseConn->conn, &dataObjOpenInp); if (status < 0) { rodsLog (LOG_ERROR, "irodsReadlink: rcDataObjTruncate of %s error. status = %d", collPath, status); unuseIFuseConn (iFuseConn); return -ENOENT; } } memset (&dataObjOpenInp, 0, sizeof (dataObjOpenInp)); rstrcpy (dataObjOpenInp.objPath, collPath, MAX_NAME_LEN); dataObjOpenInp.openFlags = O_WRONLY | O_CREAT; dataObjOpenInp.createMode = S_IFLNK; status = rcDataObjOpen (iFuseConn->conn, &dataObjOpenInp); if (status < 0) { rodsLog (LOG_ERROR, "irodsSymlink: rcDataObjOpen of %s error. status = %d", collPath, status); unuseIFuseConn (iFuseConn); return -ENOENT; } l1descInx = status; memset(&dataObjWriteInp, 0, sizeof (dataObjWriteInp)); memset(&dataObjWriteOutBBuf, 0, sizeof (bytesBuf_t)); dataObjWriteInp.l1descInx = l1descInx; dataObjWriteInp.len = strlen(to); dataObjWriteOutBBuf.len = strlen(to); dataObjWriteOutBBuf.buf = strdup(to); status = rcDataObjWrite (iFuseConn->conn, &dataObjWriteInp, &dataObjWriteOutBBuf); free(dataObjWriteOutBBuf.buf); if (status < 0) { rodsLog (LOG_ERROR, "irodsSymlink: rcDataObjWrite of %s error. status = %d", collPath, status); unuseIFuseConn (iFuseConn); return -ENOENT; } rcDataObjClose(iFuseConn->conn, &dataObjWriteInp); unuseIFuseConn (iFuseConn); return (0); }
FILE *isioFileOpen( char *filename, char *modes ) { int i; int status; dataObjInp_t dataObjInp; char **outPath; if ( debug ) { printf( "isioFileOpen: %s\n", filename ); } if ( setupFlag == 0 ) { status = isioSetup(); if ( status ) { return NULL; } } for ( i = ISIO_MIN_OPEN_FD; i < ISIO_MAX_OPEN_FILES; i++ ) { if ( openFiles[i] == 0 ) { break; } } if ( i >= ISIO_MAX_OPEN_FILES ) { fprintf( stderr, "Too many open files in isioFileOpen\n" ); return NULL; } memset( &dataObjInp, 0, sizeof( dataObjInp ) ); status = parseRodsPathStr( filename , &myRodsEnv, dataObjInp.objPath ); if ( status < 0 ) { rodsLogError( LOG_ERROR, status, "isioFileOpen" ); return NULL; } /* Set the openFlags based on the input mode (incomplete * currently) // */ dataObjInp.openFlags = O_RDONLY; if ( strncmp( modes, "w", 1 ) == 0 ) { dataObjInp.openFlags = O_WRONLY; /* Need to handle other cases sometime */ } if ( strncmp( modes, "r+", 2 ) == 0 ) { dataObjInp.openFlags = O_RDWR; } status = rcDataObjOpen( Comm, &dataObjInp ); if ( status == CAT_NO_ROWS_FOUND && dataObjInp.openFlags == O_WRONLY ) { status = rcDataObjCreate( Comm, &dataObjInp ); } if ( status < 0 ) { rodsLogError( LOG_ERROR, status, "isioFileOpen" ); return NULL; } openFiles[i] = status; cacheInfo[i].base = ( char * )malloc( sizeof( char ) * ISIO_INITIAL_BUF_SIZE ); if ( cacheInfo[i].base == NULL ) { fprintf( stderr, "Memory Allocation error\n" ); return NULL; } cacheInfo[i].bufferSize = sizeof( char ) * ISIO_INITIAL_BUF_SIZE; cacheInfo[i].ptr = cacheInfo[i].base; cacheInfo[i].count = 0; cacheInfo[i].usingUsersBuffer = 'n'; cacheInfo[i].written = 0; return ( FILE * )i; }
/************************************************************************** * private functions **************************************************************************/ static int _commitLocalBuffer(const char *iRODSPath, struct fuse_file_info *fi, lazyUploadFileInfo_t *lazyUploadFileInfo) { int status; int desc; char bufferPath[MAX_NAME_LEN]; int descInx; status = _getBufferPath(iRODSPath, bufferPath); if(status < 0) { rodsLog (LOG_DEBUG, "_upload: failed to get Buffered lazy upload file path - %s", iRODSPath); return status; } // close local buffer file handle if(lazyUploadFileInfo->localHandle < 0) { rodsLog (LOG_DEBUG, "_commitLocalBuffer: wrong file descriptor - %s, %d", iRODSPath, lazyUploadFileInfo->localHandle); return -EBADF; } // no write but requested flush if(lazyUploadFileInfo->curOffset == 0) { return 0; } fsync(lazyUploadFileInfo->localHandle); close(lazyUploadFileInfo->localHandle); lazyUploadFileInfo->localHandle = -1; rodsLog (LOG_DEBUG, "_commitLocalBuffer: upload - %s", iRODSPath); if(lazyUploadFileInfo->commitCount == 0) { // put and reopen iRODS file dataObjInp_t dataObjInp; int fd; pathCache_t *tmpPathCache = NULL; iFuseConn_t *iFuseConn = NULL; iFuseDesc_t *desc = NULL; struct stat stbuf; char objPath[MAX_NAME_LEN]; descInx = GET_IFUSE_DESC_INDEX(fi); rodsLog (LOG_DEBUG, "_commitLocalBuffer: closing existing iRODS file handle - %s - %d", iRODSPath, descInx); status = ifuseClose (&IFuseDesc[descInx]); if (status < 0) { int myError; if ((myError = getErrno (status)) > 0) { return (-myError); } else { return -ENOENT; } } // put rodsLog (LOG_DEBUG, "_commitLocalBuffer: uploading buffered file - %s", iRODSPath); status = _upload(iRODSPath); if(status != 0) { rodsLog (LOG_DEBUG, "_commitLocalBuffer: upload error - %s, %d", iRODSPath, status); return status; } // reopen file rodsLog (LOG_DEBUG, "_commitLocalBuffer: reopening iRODS file handle - %s", iRODSPath); memset (&dataObjInp, 0, sizeof (dataObjInp)); //dataObjInp.openFlags = lazyUploadFileInfo->accmode; dataObjInp.openFlags = O_RDWR | O_APPEND; status = parseRodsPathStr ((char *) iRODSPath, LazyUploadRodsEnv, objPath); rstrcpy(dataObjInp.objPath, objPath, MAX_NAME_LEN); if (status < 0) { rodsLogError (LOG_ERROR, status, "_commitLocalBuffer: parseRodsPathStr of %s error", iRODSPath); /* use ENOTDIR for this type of error */ return -ENOTDIR; } iFuseConn = getAndUseConnByPath((char *) iRODSPath, &status); /* status = getAndUseIFuseConn(&iFuseConn); */ if(status < 0) { rodsLogError (LOG_ERROR, status, "_commitLocalBuffer: cannot get connection for %s error", iRODSPath); /* use ENOTDIR for this type of error */ return -ENOTDIR; } status = _irodsGetattr (iFuseConn, iRODSPath, &stbuf); fd = rcDataObjOpen (iFuseConn->conn, &dataObjInp); unuseIFuseConn (iFuseConn); if (fd < 0) { rodsLogError (LOG_ERROR, status, "_commitLocalBuffer: rcDataObjOpen of %s error, status = %d", iRODSPath, fd); return -ENOENT; } fileCache_t *fileCache = addFileCache(fd, objPath, (char *) iRODSPath, NULL, stbuf.st_mode, stbuf.st_size, NO_FILE_CACHE); matchAndLockPathCache(pctable, (char *) iRODSPath, &tmpPathCache); if(tmpPathCache == NULL) { pathExist(pctable, (char *) iRODSPath, fileCache, &stbuf, NULL); } else { _addFileCacheForPath(tmpPathCache, fileCache); UNLOCK_STRUCT(*tmpPathCache); } desc = newIFuseDesc (objPath, (char *) iRODSPath, fileCache, &status); if (desc == NULL) { rodsLogError (LOG_ERROR, status, "_commitLocalBuffer: allocIFuseDesc of %s error", iRODSPath); return -ENOENT; } SET_IFUSE_DESC_INDEX(fi, desc->index); rodsLog (LOG_DEBUG, "_commitLocalBuffer: created new file handle - %s - %d", iRODSPath, desc->index); } else { // append int localDesc = open (bufferPath, O_RDONLY, 0755); char *buffer = (char*)malloc(FUSE_LAZY_UPLOAD_MEM_BUFFER_SIZE); int grandTotalReadLen = 0; if(localDesc < 0) { rodsLog (LOG_DEBUG, "_commitLocalBuffer: file descriptor error - %s, %d", iRODSPath, localDesc); return -ENOENT; } descInx = GET_IFUSE_DESC_INDEX(fi); if (checkFuseDesc (descInx) < 0) { return -EBADF; } status = 0; while(grandTotalReadLen < lazyUploadFileInfo->curOffset) { int totalReadLen = 0; int totalWriteLen = 0; while(totalReadLen < FUSE_LAZY_UPLOAD_MEM_BUFFER_SIZE) { int readLen = read(localDesc, buffer + totalReadLen, FUSE_LAZY_UPLOAD_MEM_BUFFER_SIZE - totalReadLen); if(readLen > 0) { totalReadLen += readLen; } else if(readLen == 0) { // EOF break; } else if(readLen < 0) { rodsLog (LOG_DEBUG, "_commitLocalBuffer: buffered file read error - %s, %d", iRODSPath, localDesc); status = getErrno (readLen); break; } } if(status >= 0) { while(totalWriteLen < totalReadLen) { int writeLen = _ifuseWrite (&IFuseDesc[descInx], buffer + totalWriteLen, totalReadLen - totalWriteLen, lazyUploadFileInfo->curLocalOffsetStart + totalWriteLen); if(writeLen > 0) { totalWriteLen += writeLen; } else if(writeLen == 0) { // EOF break; } else if(writeLen < 0) { rodsLog (LOG_DEBUG, "_commitLocalBuffer: iRODS file write error - %s", iRODSPath); status = getErrno (writeLen); break; } } } grandTotalReadLen += totalReadLen; } unlockDesc (descInx); free(buffer); close(localDesc); } rodsLog (LOG_DEBUG, "_commitLocalBuffer: reset local buffered file - %s", iRODSPath); // reset local buffer file desc = open (bufferPath, O_RDWR|O_CREAT|O_TRUNC, 0755); lazyUploadFileInfo->localHandle = desc; lazyUploadFileInfo->commitCount++; lazyUploadFileInfo->curLocalOffsetStart += lazyUploadFileInfo->curOffset; lazyUploadFileInfo->curOffset = 0; return (0); }