int specCollSubCreate( rsComm_t *rsComm, dataObjInp_t *dataObjInp ) { int status; int l1descInx; dataObjInfo_t *dataObjInfo = NULL; status = resolvePathInSpecColl( rsComm, dataObjInp->objPath, WRITE_COLL_PERM, 0, &dataObjInfo ); if ( dataObjInfo == NULL ) { // JMC cppcheck rodsLog( LOG_ERROR, "specCollSubCreate :: dataObjInp is null" ); return status; } if ( status >= 0 ) { rodsLog( LOG_ERROR, "specCollSubCreate: phyPath %s already exist", dataObjInfo->filePath ); freeDataObjInfo( dataObjInfo ); return ( SYS_COPY_ALREADY_IN_RESC ); } else if ( status != SYS_SPEC_COLL_OBJ_NOT_EXIST ) { return ( status ); } l1descInx = allocL1desc(); if ( l1descInx < 0 ) { return l1descInx; } dataObjInfo->replStatus = NEWLY_CREATED_COPY; fillL1desc( l1descInx, dataObjInp, dataObjInfo, NEWLY_CREATED_COPY, dataObjInp->dataSize ); if ( getValByKey( &dataObjInp->condInput, NO_OPEN_FLAG_KW ) == NULL ) { status = dataCreate( rsComm, l1descInx ); if ( status < 0 ) { freeL1desc( l1descInx ); return ( status ); } } return l1descInx; }
int _rsDataObjCreateWithRescInfo( rsComm_t* rsComm, dataObjInp_t* dataObjInp, rescInfo_t* rescInfo, char* rescGroupName ) { dataObjInfo_t *dataObjInfo; int l1descInx; int status; l1descInx = allocL1desc(); if ( l1descInx < 0 ) { return l1descInx; } dataObjInfo = ( dataObjInfo_t* )malloc( sizeof( dataObjInfo_t ) ); initDataObjInfoWithInp( dataObjInfo, dataObjInp ); // =-=-=-=-=-=-=- // honor the purge flag if ( getValByKey( &dataObjInp->condInput, PURGE_CACHE_KW ) != NULL ) { // JMC - backport 4537 L1desc[l1descInx].purgeCacheFlag = 1; } dataObjInfo->rescInfo = new rescInfo_t; memcpy( dataObjInfo->rescInfo, rescInfo, sizeof( rescInfo_t ) ); rstrcpy( dataObjInfo->rescName, rescInfo->rescName, NAME_LEN ); rstrcpy( dataObjInfo->rescGroupName, rescGroupName, NAME_LEN ); char* resc_hier = getValByKey( &dataObjInp->condInput, RESC_HIER_STR_KW ); if ( resc_hier ) { rstrcpy( dataObjInfo->rescHier, resc_hier, MAX_NAME_LEN ); } else { rstrcpy( dataObjInfo->rescHier, rescInfo->rescName, MAX_NAME_LEN ); // in kw else } dataObjInfo->replStatus = NEWLY_CREATED_COPY; // JMC - backport 4754 fillL1desc( l1descInx, dataObjInp, dataObjInfo, NEWLY_CREATED_COPY, dataObjInp->dataSize ); status = getFilePathName( rsComm, dataObjInfo, L1desc[l1descInx].dataObjInp ); if ( status < 0 ) { freeL1desc( l1descInx ); return ( status ); } /* output of _rsDataObjCreate - filePath stored in * dataObjInfo struct */ if ( getValByKey( &dataObjInp->condInput, NO_OPEN_FLAG_KW ) != NULL ) { /* don't actually physically open the file */ status = 0; } else { status = dataObjCreateAndReg( rsComm, l1descInx ); } if ( status < 0 ) { freeL1desc( l1descInx ); return ( status ); } else { return ( l1descInx ); } }
int _rsDataObjOpenWithObjInfo( rsComm_t *rsComm, dataObjInp_t *dataObjInp, int phyOpenFlag, dataObjInfo_t *dataObjInfo ) { // JMC - backport 4537 int replStatus; int status; int l1descInx; l1descInx = allocL1desc(); if ( l1descInx < 0 ) { return l1descInx; } // kv pasthru copyKeyVal( &dataObjInp->condInput, &dataObjInfo->condInput ); replStatus = dataObjInfo->replStatus | OPEN_EXISTING_COPY; /* the size was set to -1 because we don't know the target size. * For copy and replicate, the calling routine should modify this * dataSize */ fillL1desc( l1descInx, dataObjInp, dataObjInfo, replStatus, -1 ); if ( getValByKey( &dataObjInp->condInput, PURGE_CACHE_KW ) != NULL ) { L1desc[l1descInx].purgeCacheFlag = 1; } if ( phyOpenFlag == DO_NOT_PHYOPEN ) { /* don't actually physically open the file */ status = 0; } else if ( phyOpenFlag == PHYOPEN_BY_SIZE ) { int single_buff_sz; try { single_buff_sz = irods::get_advanced_setting<const int>(irods::CFG_MAX_SIZE_FOR_SINGLE_BUFFER) * 1024 * 1024; } catch ( const irods::exception& e ) { irods::log(e); return e.code(); } /* open for put or get. May do "dataInclude" */ if ( getValByKey( &dataObjInp->condInput, DATA_INCLUDED_KW ) != NULL && dataObjInfo->dataSize <= single_buff_sz ) { status = 0; } else if ( dataObjInfo->dataSize != UNKNOWN_FILE_SZ && dataObjInfo->dataSize <= single_buff_sz ) { status = 0; } else { status = dataOpen( rsComm, l1descInx ); } } else { status = dataOpen( rsComm, l1descInx ); } if ( status < 0 ) { freeL1desc( l1descInx ); return status; } else { return l1descInx; } }
int rsNcCreate( rsComm_t *rsComm, ncOpenInp_t *ncCreateInp, int **ncid ) { int remoteFlag; rodsServerHost_t *rodsServerHost; specCollCache_t *specCollCache = NULL; int status; dataObjInp_t dataObjInp; int l1descInx, myncid; if ( getValByKey( &ncCreateInp->condInput, NATIVE_NETCDF_CALL_KW ) != NULL ) { /* just do nc_open with objPath as file nc file path */ /* must to be called internally */ if ( rsComm->proxyUser.authInfo.authFlag < REMOTE_PRIV_USER_AUTH ) { return( CAT_INSUFFICIENT_PRIVILEGE_LEVEL ); } status = nc_create( ncCreateInp->objPath, ncCreateInp->mode, &myncid ); if ( status == NC_NOERR ) { *ncid = ( int * ) malloc( sizeof( int ) ); *( *ncid ) = myncid; return 0; } else { rodsLog( LOG_ERROR, "rsNccreate: nc_create %s error, status = %d, %s", ncCreateInp->objPath, status, nc_strerror( status ) ); return ( NETCDF_OPEN_ERR + status ); } } bzero( &dataObjInp, sizeof( dataObjInp ) ); rstrcpy( dataObjInp.objPath, ncCreateInp->objPath, MAX_NAME_LEN ); replKeyVal( &ncCreateInp->condInput, &dataObjInp.condInput ); resolveLinkedPath( rsComm, dataObjInp.objPath, &specCollCache, &dataObjInp.condInput ); remoteFlag = getAndConnRemoteZone( rsComm, &dataObjInp, &rodsServerHost, REMOTE_OPEN ); if ( remoteFlag < 0 ) { return ( remoteFlag ); } else if ( remoteFlag == LOCAL_HOST ) { addKeyVal( &dataObjInp.condInput, NO_OPEN_FLAG_KW, "" ); l1descInx = _rsDataObjCreate( rsComm, &dataObjInp ); clearKeyVal( &dataObjInp.condInput ); if ( l1descInx < 0 ) { return l1descInx; } l1desc_t& my_desc = irods::get_l1desc( l1descInx ); remoteFlag = resoAndConnHostByDataObjInfo( rsComm, my_desc.dataObjInfo, &rodsServerHost ); if ( remoteFlag < 0 ) { return ( remoteFlag ); } else if ( remoteFlag == LOCAL_HOST ) { status = nc_create( my_desc.dataObjInfo->filePath, ncCreateInp->mode, &myncid ); if ( status != NC_NOERR ) { rodsLog( LOG_ERROR, "rsNcCreate: nc_open %s error, status = %d, %s", ncCreateInp->objPath, status, nc_strerror( status ) ); freeL1desc( l1descInx ); return ( NETCDF_CREATE_ERR + status ); } } else { /* execute it remotely with dataObjInfo->filePath */ ncOpenInp_t myNcCreateInp; bzero( &myNcCreateInp, sizeof( myNcCreateInp ) ); rstrcpy( myNcCreateInp.objPath, my_desc.dataObjInfo->filePath, MAX_NAME_LEN ); addKeyVal( &myNcCreateInp.condInput, NATIVE_NETCDF_CALL_KW, "" ); status = rcNcCreate( rodsServerHost->conn, &myNcCreateInp, &myncid ); clearKeyVal( &myNcCreateInp.condInput ); if ( status < 0 ) { rodsLog( LOG_ERROR, "rsNcCreate: _rcNcCreate %s error, status = %d", myNcCreateInp.objPath, status ); freeL1desc( l1descInx ); return ( status ); } } my_desc.l3descInx = myncid; /* need to reg here since NO_OPEN_FLAG_KW does not do it */ if ( my_desc.dataObjInfo->specColl == NULL ) { status = svrRegDataObj( rsComm, my_desc.dataObjInfo ); if ( status < 0 ) { ncCloseInp_t myNcCloseInp; bzero( &myNcCloseInp, sizeof( myNcCloseInp ) ); myNcCloseInp.ncid = l1descInx; irods::server_api_call ( NC_CLOSE_AN, rsComm, &myNcCloseInp ); l3Unlink( rsComm, my_desc.dataObjInfo ); rodsLog( LOG_ERROR, "rsNcCreate: svrRegDataObj for %s failed, status = %d", my_desc.dataObjInfo->objPath, status ); freeL1desc( l1descInx ); return ( NETCDF_CREATE_ERR + status ); } } } else { addKeyVal( &dataObjInp.condInput, CROSS_ZONE_CREATE_KW, "" ); status = rcNcCreate( rodsServerHost->conn, ncCreateInp, &myncid ); /* rm it to avoid confusion */ rmKeyVal( &dataObjInp.condInput, CROSS_ZONE_CREATE_KW ); if ( status < 0 ) { rodsLog( LOG_ERROR, "rsNcCreate: _rcNcCreate %s error, status = %d", ncCreateInp->objPath, status ); return ( status ); } l1descInx = allocAndSetL1descForZoneOpr( myncid, &dataObjInp, rodsServerHost, NULL ); } l1desc_t& my_desc = irods::get_l1desc( l1descInx ); my_desc.oprType = NC_CREATE; *ncid = ( int * ) malloc( sizeof( int ) ); *( *ncid ) = l1descInx; return 0; }